e93/e93/select.c

// Selection list management functions
// 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"

typedef struct selectionElement
{
	SPARSE_ARRAY_HEADER
		saHeader;					// only need the header
} SELECTION_ELEMENT;

typedef struct selectionUniverse
{
	UINT32
		cursorPosition;				// if there is no selection, this is the cursor's position
	SPARSE_ARRAY
		selectionArray;
} SELECTION_UNIVERSE;

enum
{
	DUPLICATE_NAME
};

static const char *errorDescriptions[]=
{
	"Duplicate mark names are not allowed"
};

void DeleteAllSelections(SELECTION_UNIVERSE *universe)
// Remove all selections from universe
{
	DeleteSARange(&universe->selectionArray,0,universe->selectionArray.totalElements);
}

void DeleteSelectionRange(SELECTION_UNIVERSE *universe,UINT32 startPosition,UINT32 numElements)
// Remove selection array elements from startPosition for numElements
// NOTE: this does not mind being called for positions outside of the current array
// This pulls the remaining array elements to the left.
{
	DeleteSARange(&universe->selectionArray,startPosition,numElements);
}

bool InsertSelectionRange(SELECTION_UNIVERSE *universe,UINT32 startPosition,UINT32 numElements)
// insert numElements into the selection array at startPosition
// the elements inserted will be selected if the insertion was inside a current selection
// This pushes the existing array elements after startPosition to the right.
{
	return(InsertSARange(&universe->selectionArray,startPosition,numElements));
}

bool ClearSelectionRange(SELECTION_UNIVERSE *universe,UINT32 startPosition,UINT32 numElements)
// clear selection at startPosition for numElements of universe
// if there is a problem, return false
{
	return(ClearSARange(&universe->selectionArray,startPosition,numElements));
}

bool SetSelectionRange(SELECTION_UNIVERSE *universe,UINT32 startPosition,UINT32 numElements)
// set selection at startPosition for numElements of universe
// if there is a problem, return false
// the selection will overwrite anything currently in the array at
// the given positions (no insertion (right shift) is performed)
{
	SELECTION_ELEMENT
		element;

	return(SetSARange(&universe->selectionArray,startPosition,numElements,&element));
}

bool GetSelectionAtOrAfterPosition(SELECTION_UNIVERSE *universe,UINT32 position,UINT32 *startPosition,UINT32 *numElements)
// Return the index of the selection which occupies position,
// or the first one after the position if the position is not occupied.
// If the passed position is past the end of the array, return false
// NOTE: this uses a cache so it is efficient to call
// repeatedly for positions which are nearby each other
{
	SELECTION_ELEMENT
		*element;

	if(GetSARecordAtOrAfterPosition(&universe->selectionArray,position,startPosition,numElements,(void **)&element))
	{
		return(true);
	}
	return(false);
}

bool GetSelectionAtOrBeforePosition(SELECTION_UNIVERSE *universe,UINT32 position,UINT32 *startPosition,UINT32 *numElements)
// Return the index of the selection which occupies position,
// or the first one before the position if the position is not occupied.
// If the passed position is before the first element of the array, return false.
// NOTE: this uses a cache so it is efficient to call
// repeatedly for positions which are nearby each other
{
	SELECTION_ELEMENT
		*element;

	if(GetSARecordAtOrBeforePosition(&universe->selectionArray,position,startPosition,numElements,(void **)&element))
	{
		return(true);
	}
	return(false);
}

bool GetSelectionRange(SELECTION_UNIVERSE *universe,UINT32 position,UINT32 *startPosition,UINT32 *numElements,bool *isActive)
// return the range of positions in the array which include position
// and are selected (or not selected) the same as position
// NOTE: this uses a cache so it is efficient to call
// repeatedly for positions which are nearby each other
// NOTE: if position is off the end of the array, isActive will be returned as false,
// startPosition will contain the position where the array ended and
// this will return false (numElements will not be set)
{
	SELECTION_ELEMENT
		*element;

	*isActive=false;
	if(GetSARecordForPosition(&universe->selectionArray,position,startPosition,numElements,(void **)&element))
	{
		if(element)
		{
			*isActive=true;
		}
		return(true);
	}
	return(false);
}

bool GetSelectionAtPosition(SELECTION_UNIVERSE *universe,UINT32 position)
// call this to return the selection at the given position of
// the given selection universe.
// NOTE: if position is off the end of the array, this will return false.
// NOTE: this uses a cache so it is efficient to call
// repeatedly for positions which are nearby each other
{
	UINT32
		startPosition,
		numElements;
	bool
		selection;

	GetSelectionRange(universe,position,&startPosition,&numElements,&selection);
	return(selection);
}

bool IsSelectionEmpty(SELECTION_UNIVERSE *universe)
// return TRUE if universe contains no selection elements
{
	return(IsSAEmpty(&universe->selectionArray));
}

void GetSelectionEndPositions(SELECTION_UNIVERSE *universe,UINT32 *startPosition,UINT32 *endPosition)
// return the start and end absolute text positions of the passed selection universe
// if there are no selections, then the cursor position is returned as both the start and the end
{
	if(!GetSAElementEnds(&universe->selectionArray,startPosition,endPosition))
	{
		(*startPosition)=(*endPosition)=universe->cursorPosition;
	}
}

UINT32 GetSelectionCursorPosition(SELECTION_UNIVERSE *universe)
// Get the cursor position for the passed selection universe
{
	return(universe->cursorPosition);
}

void SetSelectionCursorPosition(SELECTION_UNIVERSE *universe,UINT32 position)
// Set the cursor position for the passed selection universe
{
	universe->cursorPosition=position;
}

void AdjustSelectionsForChange(SELECTION_UNIVERSE *universe,UINT32 startOffset,UINT32 oldEndOffset,UINT32 newEndOffset)
// given a change at startOffset, run through the given selection list, and fix it up
// NOTE: this can cause all the selections to disappear
// If it does, then the cursor will be left at the end of the change
{
	UINT32
		startPosition,
		endPosition;

	if(GetSAElementEnds(&universe->selectionArray,&startPosition,&endPosition))	// if there is some selection, then move the cursor to the start so if the selection goes away, the cursor is left in the correct spot
	{
		universe->cursorPosition=startPosition;			// push to the start
	}

	DeleteSelectionRange(universe,startOffset,oldEndOffset-startOffset);
	InsertSelectionRange(universe,startOffset,newEndOffset-startOffset);

	if(universe->cursorPosition>=startOffset)			// if cursor was before the change, then do not move it
	{
		if(universe->cursorPosition>oldEndOffset)		// see if cursor was past changed area (move it relatively)
		{
			universe->cursorPosition=(universe->cursorPosition+newEndOffset)-oldEndOffset;
		}
		else
		{
			universe->cursorPosition=newEndOffset;		// if cursor in middle of change, put it at the end
		}
	}
}

bool CopySelectionUniverse(SELECTION_UNIVERSE *sourceUniverse,SELECTION_UNIVERSE *destUniverse)
// copy sourceUniverse to destUniverse
// if there is a problem, SetError, and return false
// This may be called with sourceUniverse==destUniverse
{
	bool
		fail;
	UINT32
		startPosition,
		numElements;

	fail=false;
	DeleteAllSelections(destUniverse);
	destUniverse->cursorPosition=sourceUniverse->cursorPosition;	// copy the cursor position

	startPosition=0;
	while(!fail&&GetSelectionAtOrAfterPosition(sourceUniverse,startPosition,&startPosition,&numElements))
	{
		fail=!SetSelectionRange(destUniverse,startPosition,numElements);
		startPosition+=numElements;
	}
	return(!fail);
}

bool OrSelectionUniverse(SELECTION_UNIVERSE *sourceUniverse,SELECTION_UNIVERSE *destUniverse)
// Logical OR sourceUniverse to destUniverse
// if there is a problem, SetError, and return false
// NOTE: adjacent selection boundaries that are not shared
// will be coalesced in the result.
// This may be called with sourceUniverse==destUniverse
{
	bool
		fail;
	UINT32
		startPosition,
		numElements;
	UINT32
		destPosition,
		destElements;

	fail=false;

	startPosition=0;
	while(!fail&&GetSelectionAtOrAfterPosition(sourceUniverse,startPosition,&startPosition,&numElements))
	{
		if(GetSelectionAtOrAfterPosition(destUniverse,startPosition,&destPosition,&destElements))
		{
			if(destPosition<startPosition)					// if dest selection has a section that extends back from the start, coalesce it in
			{
				numElements+=startPosition-destPosition;
				startPosition=destPosition;
			}
			if(GetSelectionAtOrAfterPosition(destUniverse,startPosition+numElements,&destPosition,&destElements))
			{
				if(destPosition<startPosition+numElements)	// if dest selection has a section that extends beyond the end, coalesce it in
				{
					numElements=destPosition+destElements-startPosition;
				}
			}
		}
		fail=!SetSelectionRange(destUniverse,startPosition,numElements);
		startPosition+=numElements;
	}
	return(!fail);
}

bool AndSelectionUniverse(SELECTION_UNIVERSE *sourceUniverse,SELECTION_UNIVERSE *destUniverse)
// Logical AND sourceUniverse to destUniverse
// if there is a problem, SetError, and return false
// NOTE: all selections boundaries occuring in either selection will be
// present in the resulting selection.
// This may be called with sourceUniverse==destUniverse
{
	bool
		fail;
	UINT32
		clearPosition,
		startPosition,
		endPosition,
		numElements;
	UINT32
		destPosition,
		destElements;

	fail=false;

	clearPosition=startPosition=0;
	while(!fail&&GetSelectionAtOrAfterPosition(sourceUniverse,startPosition,&startPosition,&numElements))
	{
		fail=!ClearSelectionRange(destUniverse,clearPosition,startPosition-clearPosition);
		if(GetSelectionAtOrAfterPosition(destUniverse,startPosition+numElements,&destPosition,&destElements))
		{
			if(destPosition<startPosition+numElements)	// make sure to break dest at end of start if needed
			{
				fail=!SetSelectionRange(destUniverse,destPosition,startPosition+numElements-destPosition);
			}
		}
		startPosition+=numElements;
		clearPosition=startPosition;
	}

	if(!fail&&GetSAElementEnds(&destUniverse->selectionArray,&startPosition,&endPosition))
	{
		if(endPosition>clearPosition)
		{
			fail=!ClearSelectionRange(destUniverse,clearPosition,endPosition-clearPosition);
		}
	}
	return(!fail);
}

bool XorSelectionUniverse(SELECTION_UNIVERSE *sourceUniverse,SELECTION_UNIVERSE *destUniverse)
// Logical XOR sourceUniverse to destUniverse
// if there is a problem, SetError, and return false
// NOTE: all selections boundaries occuring in either selection will be
// present in the resulting selection.
// This may be called with sourceUniverse==destUniverse
{
	bool
		fail;
	UINT32
		startPositionS,
		numElementsS,
		startPositionD,
		numElementsD,
		numToDo;

	fail=false;

	startPositionS=startPositionD=0;
	while(!fail&&GetSelectionAtOrAfterPosition(sourceUniverse,startPositionS,&startPositionS,&numElementsS))
	{
		while(!fail&&numElementsS)
		{
			if(GetSelectionAtOrAfterPosition(destUniverse,startPositionS,&startPositionD,&numElementsD))
			{
				if(startPositionS<startPositionD)
				{
					numToDo=startPositionD-startPositionS;
					if(numToDo>numElementsS)
					{
						numToDo=numElementsS;
					}
					fail=!SetSelectionRange(destUniverse,startPositionS,numToDo);
					numElementsS-=numToDo;
					startPositionS+=numToDo;
				}
				if(!fail&&numElementsS)		// still some to do?
				{
					numToDo=startPositionD+numElementsD-startPositionS;
					if(numToDo>numElementsS)
					{
						numToDo=numElementsS;
					}
					fail=!ClearSelectionRange(destUniverse,startPositionS,numToDo);
					numElementsS-=numToDo;
					startPositionS+=numToDo;
				}
			}
			else	// just copy S to D now
			{
				fail=!SetSelectionRange(destUniverse,startPositionS,numElementsS);
				startPositionS+=numElementsS;
				numElementsS=0;
			}
		}
	}
	return(!fail);
}

void CloseSelectionUniverse(SELECTION_UNIVERSE *universe)
// dispose of a selection universe
{
	UnInitSA(&(universe->selectionArray));
	MDisposePtr(universe);
}

SELECTION_UNIVERSE *OpenSelectionUniverse()
// Open a selection universe (with no elements)
// If there is a problem, set the error, and return NULL
{
	SELECTION_UNIVERSE
		*universe;

	if((universe=(SELECTION_UNIVERSE *)MNewPtr(sizeof(SELECTION_UNIVERSE))))
	{
		universe->cursorPosition=0;						// no cursor position yet, so just set it to 0
		if(InitSA(&(universe->selectionArray),sizeof(SELECTION_ELEMENT)))
		{
			return(universe);
		}
		MDisposePtr(universe);
	}
	return(NULL);
}

// --------------------------------------------------------------------------------------------------------------------------
// Mark management

static void UnlinkVisibilityFromMark(EDITOR_MARK *mark,MARK_VISIBILITY *visibility)
// unlink the visibility record from the mark's list
{
	if(visibility->prevView)
	{
		visibility->prevView->nextView=visibility->nextView;
	}
	else
	{
		mark->headVisibility=visibility->nextView;
	}
	if(visibility->nextView)
	{
		visibility->nextView->prevView=visibility->prevView;
	}
	else
	{
		mark->tailVisibility=visibility->prevView;
	}
}

static void LinkVisibilityToMark(EDITOR_MARK *mark,MARK_VISIBILITY *visibility)
// Link the visibility record to the list of views that this mark is visible in
{
	visibility->parentMark=mark;

	visibility->nextView=NULL;
	if((visibility->prevView=mark->tailVisibility))
	{
		mark->tailVisibility->nextView=visibility;
	}
	else
	{
		mark->headVisibility=visibility;
	}
	mark->tailVisibility=visibility;
}

static void UnlinkVisibilityFromView(EDITOR_VIEW *view,MARK_VISIBILITY *visibility)
// unlink the visibility record from the view's list
{
	if(visibility->prevMark)
	{
		visibility->prevMark->nextMark=visibility->nextMark;
	}
	else
	{
		view->headVisibility=visibility->nextMark;
	}
	if(visibility->nextMark)
	{
		visibility->nextMark->prevMark=visibility->prevMark;
	}
	else
	{
		view->tailVisibility=visibility->prevMark;
	}
}

static void LinkVisibilityToView(EDITOR_VIEW *view,MARK_VISIBILITY *visibility)
// Link the visibility record to the list of marks visible on the
// passed view
{
	visibility->parentView=view;

	visibility->nextMark=NULL;
	if((visibility->prevMark=view->tailVisibility))
	{
		view->tailVisibility->nextMark=visibility;
	}
	else
	{
		view->headVisibility=visibility;
	}
	view->tailVisibility=visibility;
}

MARK_VISIBILITY *LocateMarkVisibilityInView(EDITOR_VIEW *view,EDITOR_MARK *mark)
// hunt the passed view to see if mark is present in its visible
// mark list
{
	MARK_VISIBILITY
		*visibility;

	visibility=view->headVisibility;
	while(visibility)
	{
		if(visibility->parentMark==mark)
		{
			return(visibility);
		}
		visibility=visibility->nextMark;
	}
	return(NULL);
}

static void DisposeMarkVisible(MARK_VISIBILITY *visibility)
// unlink and remove mark visibility record
{
	UnlinkVisibilityFromView(visibility->parentView,visibility);
	UnlinkVisibilityFromMark(visibility->parentMark,visibility);
	MDisposePtr(visibility);
}

void UnlinkVisibleMarksFromView(EDITOR_VIEW *view)
// Get rid of all visible marks attached to the passed view (usually done
// when closing the view)
{
	while(view->headVisibility)
	{
		DisposeMarkVisible(view->headVisibility);		// remove all visible marks
	}
}

void ClearEditorMarkVisible(EDITOR_MARK *mark,EDITOR_VIEW *view)
// Remove the mark from the list of those visible on the passed view
{
	MARK_VISIBILITY
		*visibility;

	if((visibility=LocateMarkVisibilityInView(view,mark)))
	{
		ViewInvalidateMark(view,mark);					// invalidate it in the view so that it will disappear
		DisposeMarkVisible(visibility);
	}
}

bool SetEditorMarkVisible(EDITOR_MARK *mark,EDITOR_VIEW *view,EDITOR_COLOR backgroundColor)
// Make the passed mark visible in the passed view. If it is already visible, just
// update the colors
{
	MARK_VISIBILITY
		*visibility;

	if(!(visibility=LocateMarkVisibilityInView(view,mark)))
	{
		if((visibility=(MARK_VISIBILITY *)MNewPtr(sizeof(MARK_VISIBILITY))))	// allocate a record, and link it to the view and mark
		{
			LinkVisibilityToMark(mark,visibility);
			LinkVisibilityToView(view,visibility);
		}
	}
	if(visibility)	// found or allocated record?
	{
		visibility->backgroundColor=backgroundColor;
		ViewInvalidateMark(view,mark);					// invalidate it in the view it just became visible in
		return(true);
	}
	return(false);
}

EDITOR_MARK *LocateEditorMark(EDITOR_BUFFER *buffer,char *markName)
// attempt to locate a mark with the given name on buffer
// if one is found, return it, else, return NULL
{
	bool
		found;
	EDITOR_MARK
		*currentMark;

	currentMark=buffer->marks;
	found=false;
	while(currentMark&&!found)
	{
		if(currentMark->markName&&(strcmp(currentMark->markName,markName)==0))
		{
			found=true;
		}
		else
		{
			currentMark=currentMark->nextMark;		// locate the mark to delete
		}
	}
	return(currentMark);
}

static void UnlinkEditorMarkFromBuffer(EDITOR_BUFFER *buffer,EDITOR_MARK *mark)
// unlink a mark from the buffer
{
	EDITOR_MARK
		*previousMark,
		*currentMark;

	previousMark=NULL;
	currentMark=buffer->marks;
	while(currentMark&&(currentMark!=mark))
	{
		previousMark=currentMark;
		currentMark=currentMark->nextMark;			// locate the mark to delete
	}
	if(currentMark)									// make sure we located it
	{
		if(previousMark)							// see if it was at the top
		{
			previousMark->nextMark=currentMark->nextMark;	// link across
		}
		else
		{
			buffer->marks=currentMark->nextMark;	// set new top of list
		}
	}
}

static void LinkEditorMarkToBuffer(EDITOR_BUFFER *buffer,EDITOR_MARK *mark)
// link a mark to the buffer
{
	mark->nextMark=buffer->marks;					// link onto start of list
	buffer->marks=mark;
}

void CloseEditorMark(EDITOR_BUFFER *buffer,EDITOR_MARK *mark)
// Remove a mark from the buffer
{
	ViewsInvalidateMark(mark);						// invalidate it if it was visible in any view
	while(mark->headVisibility)
	{
		DisposeMarkVisible(mark->headVisibility);	// remove all visibility of this mark
	}
	UnlinkEditorMarkFromBuffer(buffer,mark);
	MDisposePtr(mark->markName);
	CloseSelectionUniverse(mark->selectionUniverse);	// close the selections
	MDisposePtr(mark);								// get rid of the mark
}

EDITOR_MARK *NewEditorMark(EDITOR_BUFFER *buffer,char *markName)
// Create a new empty mark on the buffer with markName
// If the name is already taken, return SetError, and return NULL
{
	EDITOR_MARK
		*mark;

	if(!LocateEditorMark(buffer,markName))
	{
		if((mark=(EDITOR_MARK *)MNewPtr(sizeof(EDITOR_MARK))))
		{
			if((mark->selectionUniverse=OpenSelectionUniverse()))
			{
				if((mark->markName=(char *)MNewPtr(strlen(markName)+1)))
				{
					strcpy(mark->markName,markName);		// copy the name
					mark->headVisibility=NULL;				// this mark is not yet visible in any view
					mark->tailVisibility=NULL;
					LinkEditorMarkToBuffer(buffer,mark);	// link the mark to its buffer
					return(mark);
				}
				CloseSelectionUniverse(mark->selectionUniverse);
			}
			MDisposePtr(mark);
		}
	}
	else
	{
		SetError(errorDescriptions[DUPLICATE_NAME]);
	}
	return(NULL);
}