e93/e93/views.c

// High level management of views
// Copyright (C) 2004 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"

static SELECTION_UNIVERSE *GetSelectionInView(EDITOR_VIEW *view,SELECTION_UNIVERSE *selection)
// Work out a selection which is the part of the passed selection which
// intersects the visible view.
// If there is a problem, clean up, and return NULL
{
	UINT32
		topLine,
		numLines;
	INT32
		leftPixel;
	UINT32
		numPixels;
	CHUNK_HEADER
		*chunk;
	UINT32
		offset,
		startPosition,
		endPosition;
	SELECTION_UNIVERSE
		*selectionOut;

	if((selectionOut=OpenSelectionUniverse()))					// get selection to work in
	{
		GetEditorViewTextInfo(view,&topLine,&numLines,&leftPixel,&numPixels);

		LineToChunkPosition(view->parentBuffer->textUniverse,topLine,&chunk,&offset,&startPosition);		// get position of top line in this view
		LineToChunkPosition(view->parentBuffer->textUniverse,topLine+numLines,&chunk,&offset,&endPosition);	// get position past last line in this view

		SetSelectionRange(selectionOut,startPosition,endPosition-startPosition);			// select the entire visible area of the view
		AndSelectionUniverse(selection,selectionOut);			// get only the visible part of the current selection
	}
	return(selectionOut);
}

void ViewEndSelectionChange(EDITOR_VIEW *view)
// The selection in this view has been changed, update the view
{
	SELECTION_UNIVERSE
		*finalSelection;

	if(view->heldSelection)										// make sure we did not fail to create this at the start
	{
		if((finalSelection=GetSelectionInView(view,view->parentBuffer->selectionUniverse)))	// get selection that intersects view
		{
			XorSelectionUniverse(view->heldSelection,finalSelection);
			InvalidateViewSelection(view,finalSelection);
			CloseSelectionUniverse(finalSelection);				// get rid of this
		}
		CloseSelectionUniverse(view->heldSelection);			// get rid of memory this occupies
	}
	UpdateEditorWindows();

	ViewEndChange(view);

	if(view->viewSelectionChangedVector)						// see if someone needs to be called because of the change
	{
		view->viewSelectionChangedVector(view);					// call him
	}
}

void ViewStartSelectionChange(EDITOR_VIEW *view)
// The selection in this view is about to change, so prepare for it
// This copies the visible part of the current selection, and compares
// it to the updated version when the end function is called
{
	view->heldSelection=GetSelectionInView(view,view->parentBuffer->selectionUniverse);	// get a selection universe, use it to work out what changes are about to occur
	ViewStartChange(view);
}

void ViewEndMarkChange(MARK_VISIBILITY *visibility)
// A visible mark in this view has been changed, update the view
{
	SELECTION_UNIVERSE
		*finalSelection;

	if(visibility->heldMark)									// make sure we did not fail to create this at the start
	{
		if((finalSelection=GetSelectionInView(visibility->parentView,visibility->parentMark->selectionUniverse)))	// work out where the mark is now
		{
			XorSelectionUniverse(visibility->heldMark,finalSelection);
			InvalidateViewSelection(visibility->parentView,finalSelection);
			CloseSelectionUniverse(finalSelection);				// get rid of this
		}
		CloseSelectionUniverse(visibility->heldMark);			// get rid of memory this occupies
	}
	UpdateEditorWindows();

	ViewEndChange(visibility->parentView);
}

void ViewStartMarkChange(MARK_VISIBILITY *visibility)
// A visible mark in this view is about to change, so prepare for it
{
	visibility->heldMark=GetSelectionInView(visibility->parentView,visibility->parentMark->selectionUniverse);	// get a selection universe, use it to work out what changes are about to occur
	ViewStartChange(visibility->parentView);
}

void ViewEndStyleAttributeChange(EDITOR_VIEW *view)
// The attributes of styles in view have finished changing
{
	ViewStyleFontsChanged(view);
	InvalidateView(view);									// this is pretty lazy
}

void ViewStartStyleAttributeChange(EDITOR_VIEW *view)
// The attributes of styles in the view are being changed
{
}

void ViewEndStyleChange(EDITOR_VIEW *view)
// The styles applied the text for this view have been changed, invalidate the view
{
	UINT32
		topLine,
		numLines;
	INT32
		leftPixel,
		xPosition;
	UINT32
		slopLeft,
		slopRight;
	UINT32
		numPixels;
	CHUNK_HEADER
		*chunk;
	UINT32
		offset,
		currentPosition;
	UINT32
		lineLength,
		maxPosition;
	UINT32
		oldStyleStart,
		newStyleStart;
	UINT32
		oldStyleElements,
		newStyleElements;
	UINT32
		oldStyle,
		newStyle;
	bool
		hadOldStyle,
		hadNewStyle;
	UINT32
		i;
	bool
		done;

	if(view->heldStyle)										// make sure we did not fail to create this at the start
	{
		GetEditorViewTextInfo(view,&topLine,&numLines,&leftPixel,&numPixels);
		done=false;
		for(i=0;!done&&(i<numLines);i++)					// add invalidations a line at a time
		{
			LineToChunkPosition(view->parentBuffer->textUniverse,topLine+i,&chunk,&offset,&currentPosition);	// get position of top line in this view
			ChunkPositionToNextLine(view->parentBuffer->textUniverse,chunk,offset,&chunk,&offset,&lineLength);	// get length of this line
			maxPosition=currentPosition+lineLength;			// go no further than this looking for a style change in this line

			while(!done&&(currentPosition<maxPosition))		// walk through the current line looking for a style change
			{
				hadOldStyle=GetStyleRange(view->heldStyle,currentPosition,&oldStyleStart,&oldStyleElements,&oldStyle);
				hadNewStyle=GetStyleRange(view->parentBuffer->styleUniverse,currentPosition,&newStyleStart,&newStyleElements,&newStyle);

				if(hadOldStyle||hadNewStyle)				// make sure there are some changes to look at
				{
					if(oldStyle!=newStyle)					// is there a change?
					{
						// currentPosition now contains the location of the style change, invalidate to the end of the line
						xPosition=leftPixel+numPixels;		// don't look past here
						GetEditorViewTextToGraphicPosition(view,currentPosition,&xPosition,true,&slopLeft,&slopRight);
						if(xPosition>(INT32)slopLeft)
						{
							xPosition-=slopLeft;			// shift back to account for font overhang
						}
						else
						{
							xPosition=0;
						}
						if(xPosition<leftPixel)
						{
							xPosition=leftPixel;
						}
						xPosition-=leftPixel;				// make relative to scrolled view
						if(xPosition<(INT32)numPixels)		// work to do?
						{
							InvalidateViewPortion(view,i,i+1,xPosition,numPixels);	// invalidate to the end of the view
						}
						currentPosition=maxPosition;		// done with this line
					}
					else
					{
						// move forward to the nearest change
						if(hadOldStyle)						// see if we had an old style
						{
							currentPosition=oldStyleStart+oldStyleElements;
							if(hadNewStyle)					// if had new style too, see if it changes sooner
							{
								if(currentPosition>newStyleStart+newStyleElements)
								{
									currentPosition=newStyleStart+newStyleElements;
								}
							}
						}
						else								// no old style, so must have had new
						{
							currentPosition=newStyleStart+newStyleElements;
						}
					}
				}
				else
				{
					done=true;								// no styles defined here, so no changes
				}
			}
		}
		CloseStyleUniverse(view->heldStyle);				// get rid of memory this occupies
	}
	UpdateEditorWindows();
	ViewEndChange(view);
}

void ViewStartStyleChange(EDITOR_VIEW *view)
// The styles applied to text in this view are about to change, so prepare for it
{
	UINT32
		topLine,
		numLines;
	INT32
		leftPixel;
	UINT32
		numPixels;
	CHUNK_HEADER
		*chunk;
	UINT32
		offset,
		startPosition,
		endPosition,
		actualStart,
		length;
	UINT32
		style;
	UINT32
		i;
	bool
		done;

	if((view->heldStyle=OpenStyleUniverse()))			// get a style universe, and add the styles visible in this view to it
	{
		GetEditorViewTextInfo(view,&topLine,&numLines,&leftPixel,&numPixels);
		LineToChunkPosition(view->parentBuffer->textUniverse,topLine,&chunk,&offset,&startPosition);		// get position of top line in this view
		LineToChunkPosition(view->parentBuffer->textUniverse,topLine+numLines,&chunk,&offset,&endPosition);	// get position past last line in this view
		done=false;
		i=startPosition;
		while(i<endPosition&&!done)						// copy the part of the style array that intersects the view
		{
			if(GetStyleRange(view->parentBuffer->styleUniverse,i,&actualStart,&length,&style))
			{
				ForceStyleIntoRange(style);
				if(actualStart<endPosition)
				{
					if(actualStart+length>endPosition)
					{
						length=endPosition-actualStart;
					}
					SetStyleRange(view->heldStyle,actualStart,length,style);
					i=actualStart+length;
				}
				else
				{
					done=true;
				}
			}
			else
			{
				done=true;
			}
		}
	}
}

void ViewEndTabSizeChange(EDITOR_VIEW *view)
// The tab size on the passed view has finished changing
{
	InvalidateView(view);								// this is pretty lazy
}

void ViewStartTabSizeChange(EDITOR_VIEW *view)
// The tab size on the passed view is about to change
{
}

void ViewEndTextChange(EDITOR_VIEW *view)
// The text in view has finished being changed bring the view back
// up to date
{
	ViewEndChange(view);
	if(view->viewTextChangedVector)						// see if someone needs to be called because of the change
	{
		view->viewTextChangedVector(view);				// call him with my pointer
	}
}

void ViewStartTextChange(EDITOR_VIEW *view)
// The text in view is about to be changed in some way, do whatever is needed
// so that when ViewEndTextChange is called, the correct parts of the view are
// invalidated.
// NOTE: when the text changes, it is possible that the selection information
// will also change, so that updates will be handled correctly
{
	ViewStartChange(view);
}

void ViewEndActiveChange(EDITOR_VIEW *view)
// View's active status is done changing
{
	ViewEndSelectionChange(view);
}

void ViewStartActiveChange(EDITOR_VIEW *view)
// View's active status is changing
{
	ViewStartSelectionChange(view);
}

static void UnSetViewStyleFont(EDITOR_VIEW *view,UINT32 style)
// Free the font currently in use by style of view
// NOTE: it is a bad idea to call this for the default style until the window
// will no longer be used, since the default is used when the given style
// is not available
{
	if(view->viewStyles[style].font)
	{
		FreeEditorFont(view->viewStyles[style].font);
		view->viewStyles[style].font=NULL;				// mark this font as unused
	}
}

static bool SetViewStyleFont(EDITOR_VIEW *view,UINT32 style,char *fontName)
// Update the font used for a style in view
// NOTE: it is necessary to call RecalculateViewFontInfo
// after calling this (that is left to the caller, since he may need to make
// many calls to this in a row and the recalculation can be left until after
// the last call)
{
	EDITOR_FONT
		*newFont;

	if((newFont=LoadEditorFont(fontName)))
	{
		UnSetViewStyleFont(view,style);					// get rid of old font that was there (if any)
		view->viewStyles[style].font=newFont;
		return(true);
	}
	return(false);
}

static void SetViewTabSize(EDITOR_VIEW *view,UINT32 size)
// set the tabSize for view
{
	if(size>255)
	{
		size=255;			// limit this
	}
	view->tabSize=size;
}

static void UnInitializeViewStyles(EDITOR_VIEW *view)
// get rid of style information tied to view
{
	UINT32
		i;

	for(i=0;i<VIEW_MAX_STYLES;i++)
	{
		UnSetViewStyleFont(view,i);
	}
}

static bool InitializeViewStyles(EDITOR_VIEW *view,EDITOR_VIEW_DESCRIPTOR *descriptor)
// initialize style information for view
{
	UINT32
		i;

	for(i=0;i<VIEW_MAX_STYLES;i++)
	{
		view->viewStyles[i].font=NULL;					// clear pointer
		view->viewStyles[i].haveForegroundColor=false;	// no colors defined yet
		view->viewStyles[i].haveBackgroundColor=false;
	}

	// set up default style (which must be present)
	view->viewStyles[0].foregroundColor=descriptor->foregroundColor;
	view->viewStyles[0].haveForegroundColor=true;

	view->viewStyles[0].backgroundColor=descriptor->backgroundColor;
	view->viewStyles[0].haveBackgroundColor=true;

	if(SetViewStyleFont(view,0,descriptor->fontName))
	{
		return(true);
	}
	return(false);
}

UINT32 GetEditorViewTabSize(EDITOR_VIEW *view)
// get the current tab size for the given view
{
	return(view->tabSize);
}

bool SetEditorViewTabSize(EDITOR_VIEW *view,UINT32 size)
// set the tab size to be used in view
// if there is a problem, leave the tab size unchanged, set the error
// and return false
{
	ViewStartTabSizeChange(view);
	SetViewTabSize(view,size);
	ViewEndTabSizeChange(view);
	return(true);
}

static void ForceStyleRange(UINT32 *style)
// make sure the style is in range (for externally called routines)
{
	if(*style>=VIEW_MAX_STYLES)
	{
		*style=VIEW_MAX_STYLES-1;
	}
}

bool GetEditorViewStyleFont(EDITOR_VIEW *view,UINT32 style,char *font,UINT32 stringBytes)
// get the font that is in use in view for the given style
// if the font will not fit within string bytes, return false
// if there is no font in use, return an empty string
{
	ForceStyleRange(&style);
	if(stringBytes)
	{
		if(view->viewStyles[style].font)
		{
			GetEditorFontName(view->viewStyles[style].font,font,stringBytes);
			return(true);
		}
		else
		{
			font[0]='\0';
			return(true);
		}
	}
	return(false);
}

bool SetEditorViewStyleFont(EDITOR_VIEW *view,UINT32 style,char *font)
// set the font to be used in view
// this will force an update of view
// if there is a problem, leave the window font unchanged, set the error
// and return false
{
	bool
		result;

	result=false;
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	if(SetViewStyleFont(view,style,font))				// set new font
	{
		result=true;
	}
	ViewEndStyleAttributeChange(view);
	return(result);
}

void ClearEditorViewStyleFont(EDITOR_VIEW *view,UINT32 style)
// clear the font to be used for style in view
// this will force an update of view
{
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	UnSetViewStyleFont(view,style);
	ViewEndStyleAttributeChange(view);
}

bool GetEditorViewStyleForegroundColor(EDITOR_VIEW *view,UINT32 style,EDITOR_COLOR *foregroundColor)
// get the foreground color in use by style of view
// if the style does not have a foreground color associated with it, return false
{
	ForceStyleRange(&style);
	if(view->viewStyles[style].haveForegroundColor)
	{
		*foregroundColor=view->viewStyles[style].foregroundColor;	// get pixel of foreground for this style
		return(true);
	}
	return(false);
}

bool SetEditorViewStyleForegroundColor(EDITOR_VIEW *view,UINT32 style,EDITOR_COLOR foregroundColor)
// set the foreground color to be used by style of view
// this will force an update of view
// if there is a problem, leave the color unchanged, set the error
// and return false
{
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	view->viewStyles[style].foregroundColor=foregroundColor;
	view->viewStyles[style].haveForegroundColor=true;
	ViewEndStyleAttributeChange(view);
	return(true);
}

void ClearEditorViewStyleForegroundColor(EDITOR_VIEW *view,UINT32 style)
// clear the foreground color to be used for style in view
// this will force an update of view
{
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	view->viewStyles[style].haveForegroundColor=false;
	ViewEndStyleAttributeChange(view);
}

bool GetEditorViewStyleBackgroundColor(EDITOR_VIEW *view,UINT32 style,EDITOR_COLOR *backgroundColor)
// get the background color in use by style of view
// if the style does not have a background color associated with it, return false
{
	ForceStyleRange(&style);
	if(view->viewStyles[style].haveBackgroundColor)
	{
		*backgroundColor=view->viewStyles[style].backgroundColor;	// get pixel of background for this style
		return(true);
	}
	return(false);
}

bool SetEditorViewStyleBackgroundColor(EDITOR_VIEW *view,UINT32 style,EDITOR_COLOR backgroundColor)
// set the background color to be used by style of view
// this will force an update of view
// if there is a problem, leave the color unchanged, set the error
// and return false
{
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	view->viewStyles[style].backgroundColor=backgroundColor;
	view->viewStyles[style].haveBackgroundColor=true;
	ViewEndStyleAttributeChange(view);
	return(true);
}

void ClearEditorViewStyleBackgroundColor(EDITOR_VIEW *view,UINT32 style)
// clear the background color to be used for style in view
// this will force an update of view
{
	ForceStyleRange(&style);
	ViewStartStyleAttributeChange(view);
	view->viewStyles[style].haveBackgroundColor=false;
	ViewEndStyleAttributeChange(view);
}

bool GetEditorViewSelectionForegroundColor(EDITOR_VIEW *view,EDITOR_COLOR *foregroundColor)
// get the foreground color in use by the selection of view
// NOTE: it is possible that no color has been specified.
// If that is the case, this will return false
{
	if(view->haveSelectionForegroundColor)
	{
		*foregroundColor=view->selectionForegroundColor;
		return(true);
	}
	return(false);
}

bool SetEditorViewSelectionForegroundColor(EDITOR_VIEW *view,EDITOR_COLOR foregroundColor)
// set the foreground color to be used for selections in view
// this will force an update of view
// if there is a problem, leave the color unchanged, set the error
// and return false
// NOTE: if haveForeground is false, this will clear the foreground color
// making the selection draw the foreground as the inverse of the current
// color
{
	view->selectionForegroundColor=foregroundColor;
	view->haveSelectionForegroundColor=true;
	InvalidateViewSelection(view,view->parentBuffer->selectionUniverse);
	return(true);
}

void ClearEditorViewSelectionForegroundColor(EDITOR_VIEW *view)
// Clear the foreground color, making the selection draw the foreground
// as the inverse of the current color
{
	view->haveSelectionForegroundColor=false;
	InvalidateViewSelection(view,view->parentBuffer->selectionUniverse);
}

bool GetEditorViewSelectionBackgroundColor(EDITOR_VIEW *view,EDITOR_COLOR *backgroundColor)
// get the background color in use by the selection of view
// NOTE: it is possible that no color has been specified.
// If that is the case, this will return false
{
	if(view->haveSelectionBackgroundColor)
	{
		*backgroundColor=view->selectionBackgroundColor;
		return(true);
	}
	return(false);
}

bool SetEditorViewSelectionBackgroundColor(EDITOR_VIEW *view,EDITOR_COLOR backgroundColor)
// set the background color to be used for selections in view
// this will force an update of view
// if there is a problem, leave the color unchanged, set the error
// and return false
// NOTE: if haveBackground is false, this will clear the background color
// making the selection draw the background as the inverse of the current
// color
{
	view->selectionBackgroundColor=backgroundColor;
	view->haveSelectionBackgroundColor=true;
	InvalidateViewSelection(view,view->parentBuffer->selectionUniverse);
	return(true);
}

void ClearEditorViewSelectionBackgroundColor(EDITOR_VIEW *view)
// Clear the background color, making the selection draw the background
// as the inverse of the current color
{
	view->haveSelectionBackgroundColor=false;
	InvalidateViewSelection(view,view->parentBuffer->selectionUniverse);
}

void ViewsEndSelectionChange(EDITOR_BUFFER *buffer)
// The selection in buffer has finished being changed
// do whatever needs to be done
// to get it up to date
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewEndSelectionChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void ViewsStartSelectionChange(EDITOR_BUFFER *buffer)
// The selection in buffer are about to be changed in some way, do whatever is needed
// NOTE: a change in the selection could mean something as simple as a cursor position change
// NOTE also: selection changes cannot be nested, and nothing except the selection is allowed
// to be altered during a selection change
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewStartSelectionChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void ViewInvalidateMark(EDITOR_VIEW *view,EDITOR_MARK *mark)
// Invalidate the selection of the passed mark in the passed view
{
	InvalidateViewSelection(view,mark->selectionUniverse);
}

void ViewsInvalidateMark(EDITOR_MARK *mark)
// Invalidate the selection of the passed mark in all visible views
{
	MARK_VISIBILITY
		*currentVisibility;

	currentVisibility=mark->headVisibility;
	while(currentVisibility)							// walk through all views, update each one as needed
	{
		ViewInvalidateMark(currentVisibility->parentView,mark);
		currentVisibility=currentVisibility->nextView;	// locate next view this mark is visible in
	}
}

void ViewsEndMarkChange(EDITOR_MARK *mark)
// The passed mark has finished being changed, update all
// affected views.
{
	MARK_VISIBILITY
		*currentVisibility;

	currentVisibility=mark->headVisibility;
	while(currentVisibility)							// walk through all views, update each one as needed
	{
		ViewEndMarkChange(currentVisibility);
		currentVisibility=currentVisibility->nextView;	// locate next view this mark is visible in
	}
}

void ViewsStartMarkChange(EDITOR_MARK *mark)
// Marks (which may be visible) in buffer are about to be changed in some way, do whatever is needed
// NOTE: mark changes cannot be nested, and nothing except a mark is allowed
// to be altered during a mark change
{
	MARK_VISIBILITY
		*currentVisibility;

	currentVisibility=mark->headVisibility;
	while(currentVisibility)							// walk through all views, update each one as needed
	{
		ViewStartMarkChange(currentVisibility);
		currentVisibility=currentVisibility->nextView;	// locate next view this mark is visible in
	}
}

void ViewsStartStyleChange(EDITOR_BUFFER *buffer)
// The style in buffer is about to be changed in some way, do whatever is needed
// NOTE also: style changes cannot be nested, and nothing except the style is allowed
// to be altered during a style change
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewStartStyleChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void ViewsEndStyleChange(EDITOR_BUFFER *buffer)
// The style in buffer has finished being changed
// do whatever needs to be done to get it up to date
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewEndStyleChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void ViewsStartTextChange(EDITOR_BUFFER *buffer)
// The text in buffer is about to be changed in some way, do whatever is needed
// NOTE: when the text changes, it is possible that the selection information
// will also change, so that updates will be handled correctly
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewStartTextChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void ViewsEndTextChange(EDITOR_BUFFER *buffer)
// The text in buffer has finished being changed, and the views have been
// updated, do whatever needs to be done
{
	EDITOR_VIEW
		*currentView;

	currentView=buffer->firstView;
	while(currentView)									// walk through all views, update each one as needed
	{
		ViewEndTextChange(currentView);
		currentView=currentView->nextBufferView;		// locate next view of this buffer
	}
}

void EditorActivateView(EDITOR_VIEW *view)
// activate view (this is not nestable)
{
	ViewStartActiveChange(view);
	view->active=true;
	ViewEndActiveChange(view);
}

void EditorDeactivateView(EDITOR_VIEW *view)
// deactivate view (this is not nestable)
{
	ViewStartActiveChange(view);
	view->active=false;
	ViewEndActiveChange(view);
}

void DisposeEditorView(EDITOR_VIEW *view)
// unlink view from everywhere, and dispose of it
{
	DisposeViewInfo(view);							// tell GUI to tear it down
	UnInitializeViewStyles(view);					// get rid of style information for view
	UnlinkVisibleMarksFromView(view);				// get rid of any visible marks hanging off the view
	UnlinkViewFromBuffer(view);
	MDisposePtr(view);
}

EDITOR_VIEW *CreateEditorView(EDITOR_WINDOW *window,EDITOR_VIEW_DESCRIPTOR *descriptor)
// create a view in window using descriptor
// if there is a problem, SetError, and return NULL
{
	EDITOR_VIEW
		*view;

	if((view=(EDITOR_VIEW *)MNewPtr(sizeof(EDITOR_VIEW))))
	{
		LinkViewToBuffer(view,descriptor->buffer);
		view->parentWindow=window;
		view->active=descriptor->active;
		view->wantHome=false;
		SetViewTabSize(view,descriptor->tabSize);	// set, and limit the tab size
		view->haveSelectionForegroundColor=false;	// select by inverting text colors by default
		view->haveSelectionBackgroundColor=false;
		view->headVisibility=NULL;					// no visible marks hanging off of this view yet
		view->tailVisibility=NULL;
		view->viewTextChangedVector=descriptor->viewTextChangedVector;
		view->viewSelectionChangedVector=descriptor->viewSelectionChangedVector;
		view->viewPositionChangedVector=descriptor->viewPositionChangedVector;

		if(InitializeViewStyles(view,descriptor))
		{
			if(CreateViewInfo(view,descriptor))
			{
				return(view);
			}
		}
		UnlinkViewFromBuffer(view);
		MDisposePtr(view);
	}
	return(NULL);
}