xref: /dports/editors/e93/e93/xgui/misc.c

// Misc low level stuff
// Copyright (C) 2000 Core Technologies.

// This file is part of e93.
//
// e93 is free software; you can redistribute it and/or modify
// it under the terms of the e93 LICENSE AGREEMENT.
//
// e93 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// e93 LICENSE AGREEMENT for more details.
//
// You should have received a copy of the e93 LICENSE AGREEMENT
// along with e93; see the file "LICENSE.TXT".

#include	"includes.h"

// routines callable by the editor

const char *GetEditorLocalVersion()
// return a pointer to a constant string, that tells something about this local
// version of the editor (used by the "version" command)
// it is ok to return NULL
{
	return("X Windows");
}

bool PointInRECT(INT32 x,INT32 y,EDITOR_RECT *rect)
// return true if x, and y fall within rect
{
	if((x>=rect->x)&&(y>=rect->y))
	{
		if((x<(rect->x+(int)rect->w))&&(y<(rect->y+(int)rect->h)))
		{
			return(true);
		}
	}
	return(false);
}

static void GlobalOffset(Window xWindow,INT32 *outX,INT32 *outY)
// return the global offset of xWindow
// NOTE: although this should always work, it is nasty
// X should provide a better way to do this
{
	XWindowAttributes
		attributes;
	Window
		current,
		root,
		parent,
		*children;
	unsigned int
		numChildren;

	(*outX)=0;
	(*outY)=0;
	current=xWindow;
	root=RootWindow(xDisplay,xScreenNum);									// get the root
	while(current!=root)
	{
		XGetWindowAttributes(xDisplay,current,&attributes);
		(*outX)+=attributes.x;												// offset by parent
		(*outY)+=attributes.y;
		XQueryTree(xDisplay,current,&root,&parent,&children,&numChildren);	// this is an annoying way to get the parent, but it is all X allows
		if(children)
		{
			XFree((char *)children);
		}
		current=parent;														// step back to the parent
	}
}

void GlobalToLocal(Window xWindow,INT32 x,INT32 y,INT32 *outX,INT32 *outY)
// passed an x and y at the root level of the screen that xWindow is on,
// convert the coordinates to those local to xWindow, and return them
{
	GlobalOffset(xWindow,outX,outY);
	(*outX)=x-(*outX);
	(*outY)=y-(*outY);
}

void LocalToGlobal(Window xWindow,INT32 x,INT32 y,INT32 *outX,INT32 *outY)
// passed an x and y within xWindow, return the root equivalent
{
	GlobalOffset(xWindow,outX,outY);
	(*outX)+=x;
	(*outY)+=y;
}

void EditorBeep()
// make a noise so we can tell what is going on
{
	XBell(xDisplay,0);
}

void ReportMessage(const char *format,...)
// report messages to the console
{
	va_list
		args;
	char
		tempString[256];

	va_start(args,format);
	vsnprintf(tempString,sizeof(tempString),format,args);	// make the string
	va_end(args);

	OkDialog(tempString);
}

void ShowBusy()
// the editor calls this when it is doing something that may take some
// time, it should show the user (by changing the pointer or something)
// this call is nestable
{
	if(!showingBusy)
	{
//		XRecolorCursor(xDisplay,caretCursor,&gray2,&gray2);
	}
	showingBusy++;
}

void ShowNotBusy()
// when the editor is again ready to accept user input, it will call this
// it should undo anything ShowBusy did
// every ShowBusy will be exactly balanced by a call to ShowNotBusy
{
	if(showingBusy)
	{
		showingBusy--;
	}
	if(!showingBusy)
	{
//		XRecolorCursor(xDisplay,caretCursor,&gray0,&gray3);
	}
}

char *CreateWindowTitleFromPath(const char *absolutePath)
// use absolute path to generate a string (which is returned) that
// should be placed in the title of a window
// the string should be disposed of using MDisposePtr
// if there is a problem, SetError, and return NULL
{
	int
		pathLength;
	int
		nameLength;
	char
		*returnString;

	pathLength=strlen(absolutePath);
	if((returnString=(char *)MNewPtr(pathLength+5)))
	{
		nameLength=0;
		while(pathLength&&absolutePath[pathLength-1]!=PATH_SEP)	// move backwards until the first part of the path is encountered
		{
			nameLength++;
			pathLength--;
		}
		sprintf(returnString,"%.*s -- %.*s",nameLength,&(absolutePath[pathLength]),pathLength,&(absolutePath[0]));
		return(returnString);
	}
	return(NULL);
}

char *realpath2(const char *path,char *outputPath)
// This routine replaces the system call "realpath" since there
// still exist machines that do not implement it
// This function directly replaces "realpath"
// NOTE: if path is passed as a string of length 0, this
// will return the current directory (which is what the real
// realpath does)
{

#define	MAX_LINK_DEPTH	256						// maximum number of links we will follow before giving up

	int
		currentLinkPath;						// tells which linkBuffer to read into next time we readlink
	char
		linkBuffer[2][MAXPATHLEN];				// two buffers to read links into
	char
		*linkPath;								// pointer to current link buffer
	int
		linkDepth,								// number of times links have been traversed
		outputLength,							// current length of output buffer
		linkLength;								// length of link returned by readlink
	bool
		hadRelativeComponent;					// boolean to tell if ., or .. was seen

	currentLinkPath=0;							// use buffer 0 next time
	linkDepth=0;								// so far, no links encountered
	outputLength=0;								// current length of output path

	if(*path!=PATH_SEP)							// if path does not start with PATH_SEP it is relative to current directory (even if path[0]=='\0')
	{
		if(getcwd(outputPath,MAXPATHLEN))		// get absolute path up to this point
		{
			outputLength=strlen(outputPath);	// get the length of the path returned
			if((!outputLength)||outputPath[outputLength-1]!=PATH_SEP)	// make sure the end of the path has a PATH_SEP on it
			{
				outputPath[outputLength++]=PATH_SEP;	// drop it in
			}
		}
		else
		{
			errno=ENOENT;						// something went amiss with getcwd, so make up an error code, and leave
			return(NULL);
		}
	}
	else
	{
		outputPath[outputLength++]=PATH_SEP;	// path is absolute, so start it
		path++;									// eat the PATH_SEP in the input
	}

	while(*path)								// get each component of the path, and expand
	{
		if(*path!=PATH_SEP)						// gobble up separators
		{
			hadRelativeComponent=false;			// assume no ., or ..
			if(path[0]=='.')					// see if possible relative path component
			{
				if(path[1]=='.')
				{
					if(!path[2]||path[2]==PATH_SEP)	// just got '..', so move back over it, and previous path component, if any
					{
						path+=2;				// skip over '..' of input
						if(outputLength>1)		// if at root, do not backup
						{
							outputLength--;		// step back over trailing PATH_SEP
							while(outputLength&&outputPath[outputLength-1]!=PATH_SEP)
							{
								outputLength--;
							}
						}
						hadRelativeComponent=true;	// tell rest of loop this was handled
					}
				}
				else
				{
					if(!path[1]||path[1]==PATH_SEP)	// just saw '.', which is redundant, so remove it
					{
						path++;						// skip over '.'
						hadRelativeComponent=true;	// tell rest of loop this was handled
					}
				}
			}

			if(!hadRelativeComponent)				// if the component was not relative, copy it to the output, and check for links
			{
				while(*path&&*path!=PATH_SEP)		// copy the next pathname component
				{
					if(outputLength<MAXPATHLEN-1)	// check for overflow, leave room for 0 termination
					{
						outputPath[outputLength++]=*path++;	// copy the character
					}
					else
					{
						errno=ENAMETOOLONG;			// ran out of space during the copy, complain
						return(NULL);
					}
				}

				outputPath[outputLength]='\0';		// terminate the path that is being created
				linkPath=linkBuffer[currentLinkPath];	// point to the spare link buffer
				if((linkLength=readlink(outputPath,linkPath,MAXPATHLEN-1))>=0)	// attempt to see what this is linked to, MAXPATHLEN-1 is to leave room for 0 terminator
				{
					if(linkDepth++<=MAX_LINK_DEPTH)	// make sure we have not exhausted max number of links
					{
						linkPath[linkLength]='\0';	// terminate the path returned by readlink
						if(linkPath[0]==PATH_SEP)	// see if the link is absolute or relative
						{
							outputLength=0;			// if the link is absolute, then the output is completely re-written, and scan continues from this point
						}
						else
						{
							while(outputLength&&outputPath[outputLength-1]!=PATH_SEP)	// the link is relative, so remove the link component from the output
							{
								outputLength--;
							}
							if(outputLength)		// step back over the path separator too
							{
								outputLength--;
							}
						}
						if(linkLength+strlen(path)<MAXPATHLEN)	// make sure the remainder of the path will fit into the buffer
						{
							strcat(linkPath,path);	// append what's left of the path to the output of readlink
							path=linkPath;			// call this the new path
							currentLinkPath^=1;		// swap link buffers
						}
						else
						{
							errno=ENAMETOOLONG;
							return(NULL);
						}
					}
					else
					{
						errno=ELOOP;				// too many links traversed, complain
						return(NULL);
					}
				}
				else
				{
					if(errno!=EINVAL)				// anything but EINVAL is fatal, EINVAL is ok, the file is just not a symbolic link
					{
						return(NULL);
					}
				}
				outputPath[outputLength++]=PATH_SEP;	// add separator to the output
			}
		}
		else
		{
			path++;									// skip extraneous path separators
		}
	}

	if((outputLength>1)&&outputPath[outputLength-1]==PATH_SEP)	// realpath does not return the last PATH_SEP unless we're at the root
	{
		outputLength--;								// strip off final PATH_SEP
	}
	outputPath[outputLength]='\0';					// terminate the result
	return(outputPath);								// return it
}

char *CreateAbsolutePath(const char *relativePath)
// given a relative path, attempt to make it an absolute path
// NOTE: if the relativePath does not point to anything valid, or the absolute path buffer
// could not be allocated, SetError, and return NULL
// the returned buffer will be 0 terminated, and must be freed by calling
// MDisposePtr
// NOTE: the result of calling this for the same file MUST always be
// EXACTLY the same string (case sensitive). The editor may perform
// strcmp style operations on these.
{
	char
		resolvedPath[MAXPATHLEN];
	char
		*returnPath;

	if(realpath2(relativePath,&(resolvedPath[0])))				// get real path if possible
	{
		if((returnPath=(char *)MNewPtr(strlen(&(resolvedPath[0]))+1)))	// create buffer to pass it back in
		{
			strcpy(returnPath,&(resolvedPath[0]));				// copy it into the buffer
			return(returnPath);
		}
	}
	else
	{
		SetStdCLibError();
	}
	return(NULL);
}

#define	STARTUP_NAME		"e93lib/e93rc.tcl"					// name of the startup file

static bool ScriptExists(const char *scriptPath)
// See if the script at script path exists, and is readable
// If so, return true, if not, return false
{
	int
		fileID;

	if((fileID=open(scriptPath,O_RDONLY))>=0)
	{
		close(fileID);
		return(true);
	}
	return(false);
}

bool LocateStartupScript(char *scriptPath)
// Search for the editor's startup script, return a path
// to the script which is located.
// NOTE: scriptPath must point to at least MAXPATHLEN bytes
// If no script could be located, SetError and return false
{
	sprintf(scriptPath,"%s/lib/%s",PREFIX,STARTUP_NAME);
	if(ScriptExists(scriptPath))
	{
		return(true);
	}
	SetError("Failed to locate '%s'",scriptPath);
	return(false);
}

EDITOR_FILE *OpenEditorReadFile(const char *path)
// open a document file for reading into the editor
// if there is an error, SetError will be called, and NULL returned
{
	EDITOR_FILE
		*editorFile;

	if((editorFile=(EDITOR_FILE *)MNewPtr(sizeof(EDITOR_FILE))))
	{
		if((editorFile->fileHandle=open(path,O_RDONLY,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))!=-1)
		{
			return(editorFile);
		}
		else
		{
			SetStdCLibError();						// set high level error information
		}
		MDisposePtr(editorFile);
	}
	return(NULL);
}

EDITOR_FILE *OpenEditorWriteFile(const char *path)
// open a document file for writing into by the editor
// if there is an error, SetError will be called, and NULL returned
{
	EDITOR_FILE
		*editorFile;

	if((editorFile=(EDITOR_FILE *)MNewPtr(sizeof(EDITOR_FILE))))
	{
		if((editorFile->fileHandle=open(path,O_CREAT|O_TRUNC|O_WRONLY,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))!=-1)
		{
			return(editorFile);
		}
		else
		{
			SetStdCLibError();						// set high level error information
		}
		MDisposePtr(editorFile);
	}
	return(NULL);
}

bool ReadEditorFile(EDITOR_FILE *file,UINT8 *buffer,UINT32 bytesToRead,UINT32 *bytesRead)
// read at most bytesToRead from file into buffer
// return the actual amount read in bytesRead
// if bytesRead is less than bytesToRead, then EOF is assumed
// if there is an error, SetError will be called, and false returned
{
	int
		bytesJustRead;

	if((bytesJustRead=read(file->fileHandle,(char *)buffer,(int)bytesToRead))!=(int)bytesToRead)
	{
		if(bytesJustRead==-1)			// if there was an error, set it it
		{
			SetStdCLibError();			// set high level error information
			*bytesRead=0;
			return(false);
		}
	}
	*bytesRead=bytesJustRead;
	return(true);
}

bool WriteEditorFile(EDITOR_FILE *file,UINT8 *buffer,UINT32 bytesToWrite,UINT32 *bytesWritten)
// write bytesToWrite from buffer into file
// return the actual amount written in bytesWritten
// bytesWritten should be the same as bytesToWrite, unless there was an error
// if there is an error, SetError will be called, and false returned
{
	int
		bytesJustWritten;

	if((bytesJustWritten=write(file->fileHandle,(char *)buffer,(int)bytesToWrite))!=(int)bytesToWrite)
	{
		if(bytesJustWritten==-1)			// if there was an error, set it it
		{
			SetStdCLibError();				// set high level error information
			*bytesWritten=0;
			return(false);
		}
	}
	*bytesWritten=bytesJustWritten;
	return(true);
}

void CloseEditorFile(EDITOR_FILE *file)
// when the editor is finished with a file, it will call this
{
	close(file->fileHandle);					// get rid of the file
	MDisposePtr(file);
}

void OutlineShadowRectangle(Window xWindow,EDITOR_RECT *rect,EDITOR_COLOR upperLeftColor,EDITOR_COLOR lowerRightColor,UINT32 thickness)
// outline rect with a shadow effect in thickness
{
	UINT32
		thicknessCount;

	for(thicknessCount=0;thicknessCount<thickness&&thicknessCount<(rect->h/2);thicknessCount++)
	{
		XSetForeground(xDisplay,xGraphicsContext,EditorColorToXPixel(upperLeftColor));
		XDrawLine(xDisplay,xWindow,xGraphicsContext,rect->x,rect->y+thicknessCount,rect->x+rect->w-thicknessCount-1,rect->y+thicknessCount);	// top
		XDrawLine(xDisplay,xWindow,xGraphicsContext,rect->x+thicknessCount,rect->y,rect->x+thicknessCount,rect->y+rect->h-thicknessCount-1);	// left

		XSetForeground(xDisplay,xGraphicsContext,EditorColorToXPixel(lowerRightColor));
		XDrawLine(xDisplay,xWindow,xGraphicsContext,rect->x+thicknessCount,rect->y+rect->h-thicknessCount-1,rect->x+rect->w-thicknessCount-1,rect->y+rect->h-thicknessCount-1); // bottom
		XDrawLine(xDisplay,xWindow,xGraphicsContext,rect->x+rect->w-thicknessCount-1,rect->y+thicknessCount,rect->x+rect->w-thicknessCount-1,rect->y+rect->h-thicknessCount-1); // right
	}
}