RenderRegionList Class Reference

Holds a list of RenderRegion objects for the application to process. It should be used to add or remove render regions, or to initiate background rendering on idle events. More...

#include <rgnlist.h>

Inheritance diagram for RenderRegionList:

List of all members.

Public Member Functions
	RenderRegionList ()
	Initialises the RenderRegionList - in particular, the pointer to the last render region to be rendered.
	~RenderRegionList ()
	Destroys all render regions in the list, and then destroys the list.
void	Merge (RenderRegion *NewRegion)
	Add a render region object to the application's global list of render regions.
void	Remove (RenderRegion *)
	Removes a render region from the application's list of render regions, It DOES NOT delete the RenderRegion object itself. This is used when the region has been completely rendered and is no longer needed.
void	Remove (Document *)
void	Remove (View *)
	Removes all render regions from the application's list of render regions that are associated with a particular document. Usually called because the document is being closed (deleted). It deletes all RenderRegion objects it removes.Removes all render regions from the application's list of render regions that are associated with a particular view. Usually called because the docview is being closed (deleted). It deletes all RenderRegion objects it removes.
BOOL	BackgroundRender ()
	Cycles through the members of the render region list, rendering each one in turn. Only one render region is rendered on each call to BackgroundRender().
void	ImmediateRender (BOOL bForceImmediate=FALSE)
	Finds all render regions associated with DocViews that have background rendering disabled, and renders them all immediately (i.e. to completion).
void	HandleNodeDeletion (Node *pNode)
	Tells RenderRegions that they should be afraid, very afraid, if they are holding a pointer to this node...
Private Member Functions
	CC_DECLARE_MEMDUMP (RenderRegionList)
void	TidyUpAdjacentRegions (RenderRegion *)
	Goes through all the regions in the list and tests to see if any of them line up exactly. If they do, they are joined into a single region.
void	MergeRenderRegions (RenderRegion *NewRenderRegion)
	Attempts to find regions which can be merged together to make redrawing more efficient. At the moment, the two regions to be merged must satisfy the following conditions:.
void	StrictMerge (RenderRegion *pRegionToMerge)
	Tries to merge the render region supplied with the rest of the list. They must be exactly adjacent ie. They don't intersect, and the union contains no area outside the two rectangles.
void	RemoveRegionOverlap (RenderRegion *NewRenderRegion)
	Called when adding a new render region to the list. It checks the new render region for overlap with all the old render regions and if it overlapps any of them, the old region is slit up. This function should guarantee that you never get render regions that overlap, so that the EORed stuff does not get screwed up by getting rendered more than once.
void	ClipRectsToClient ()
	Clips the RenderRegions in the list to the client area, incase it has been scrolled.
void	TryTotalUnion ()
	For each DocView, try to union all the render regions, and see if the individual areas add up to more than 70% of the union area. If they do then we union all the regions together and just render one big one.
void	DoTotalUnion (RenderRegion *pRegion, View *pView, DocRect TotalUnion)
	For the specified DocView, find all the regions that are attached to it, and union them all together and use the region 'pRegion' to hold this new region. All the other regions of this DocView are removed from the list and deleted.
Private Attributes
RenderRegion *	LastRendered
MILLIPOINT	PixelWidth
BOOL	ListIsOptimal

---

Detailed Description

Holds a list of RenderRegion objects for the application to process. It should be used to add or remove render regions, or to initiate background rendering on idle events.

Author:

Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>

Date:

26/5/93

See also:

RenderRegion

Definition at line 124 of file rgnlist.h.

---

Constructor & Destructor Documentation

RenderRegionList::RenderRegionList (   )

Initialises the RenderRegionList - in particular, the pointer to the last render region to be rendered. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Definition at line 256 of file rgnlist.cpp. { LastRendered = NULL; ListIsOptimal = FALSE; }

RenderRegionList::~RenderRegionList (   )

Destroys all render regions in the list, and then destroys the list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 277 of file rgnlist.cpp. { // Call destructors on all objects in the list RenderRegion *Item = (RenderRegion *) RemoveHead(); while (Item != NULL) { // Delete the list item delete Item; // Try the next item Item = (RenderRegion *) RemoveHead(); } }

---

Member Function Documentation

BOOL RenderRegionList::BackgroundRender (   )

Cycles through the members of the render region list, rendering each one in turn. Only one render region is rendered on each call to BackgroundRender(). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if rendering was done, FALSE if no render regions to render. Errors: - See also: - Definition at line 1027 of file rgnlist.cpp. { if ( CCamApp::IsDisabled() ) { // TRACE( wxT("BGR - IsDisabled\n") ); return FALSE; // If he has got the system disabled, ignore } // print monitor not present on viewer // Make sure printing is ok. if (!PrintMonitor::IsPrintStatusOK()) { // No - a print job has gone wrong, so we delete all printing render regions // before continuing. RenderRegion *pRender = (RenderRegion *) GetHead(); while (pRender != NULL) { if (pRender->IsPrinting()) { // Render region is printing (well it's not really as an exception // has occured) so delete it. Remove(pRender); delete pRender; } // Try next region pRender = (RenderRegion *) GetNext(pRender); } // Reset the last rendered render region LastRendered = NULL; } if (GetCount() == 0) { // TRACE( wxT("BGR - No regions\n") ); return FALSE; } //GAT // if (ControlHelper::IsUserInterfaceCaptured()) // return FALSE; // No bg rendering if UI is captured (e.g. menu is up) // // if (DragManagerOp::IsDragActive()) // return FALSE; // No bg rendering if a DragManager op is active (NB this is for // colour/bitmap/bar drags only - not doc operation drags). if (ViewOps::IsFullScreenPending()) // no bg rendering if we are about to enter full screen mode { // TRACE( wxT("BGR - About to full screen\n") ); return FALSE; } // Optimise list based on render region percentage coverage TryTotalUnion(); // Work out which render region to render if (LastRendered != NULL) LastRendered = (RenderRegion*) GetNext(LastRendered); if (LastRendered == NULL) LastRendered = (RenderRegion*) GetHead(); if (LastRendered == NULL) { // TRACE( wxT("BGR - No last region\n") ); return FALSE; // No regions to render } // Ignore the RenderRegion if we are Printing, because // we have probably been called from the Print AbortProc // and are already rendering. if (LastRendered->IsPrinting()) { // TRACE( wxT("BGR - Is printing\n") ); return FALSE; } // TRACEUSER("Gerry", _T("BackgroundRender\n")); // Show the user we are rendering. if (GetApplication()->GetpStatusLine()) GetApplication()->GetpStatusLine()->SetRenderIndicator(Animate); GetApplication()->BgRendering = TRUE; // Do the render. Error::RenderThreadIn(); // Make errors close window LastRendered->DefaultRender(); Error::RenderThreadOut(); // Normal errors // Turn off render indicator if needed. if (GetCount() ==0) { if (GetApplication()->GetpStatusLine()) GetApplication()->GetpStatusLine()->SetRenderIndicator(NotRendering); GetApplication()->BgRendering = FALSE; } // We did some rendering so return TRUE return TRUE; }

RenderRegionList::CC_DECLARE_MEMDUMP (  RenderRegionList   )  [private]

void RenderRegionList::ClipRectsToClient (   )  [private]

Clips the RenderRegions in the list to the client area, incase it has been scrolled. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Scope: Private. See also: - Definition at line 804 of file rgnlist.cpp. { RenderRegion *pRegion = (RenderRegion*) GetHead(); while (pRegion != NULL) { // Find the view associated with the window and skip if null. View* pView = pRegion->GetRenderView(); if (pView != NULL && DocView::GetCurrent() == pView) { // Get the views rectangle, and convert it into spread coords DocRect ClientRect = pView->GetDocViewRect(pRegion->GetRenderSpread()); pRegion->GetRenderSpread()->DocCoordToSpreadCoord(&ClientRect); // Get the clipping rectangle of this render region DocRect ClipRect = pRegion->GetRegionRect(); // see if we need to lose any parts of the render region if (!ClientRect.ContainsRect(ClipRect)) { if (ClipRect.IsIntersectedWith(ClientRect)) { ClipRect = ClipRect.Intersection(ClientRect); pRegion->ResizeRegion(ClipRect); // pRegion->SetClipRect(ClipRect); // pRegion->ResetRegion(ClipRect); } else { // This render region is now off screen, so we can throw it away RenderRegion* pPrev = (RenderRegion *) GetPrev(pRegion); Remove(pRegion); delete pRegion; pRegion = pPrev; } } } // Try the next item. pRegion = (RenderRegion*) ((pRegion != NULL) ? GetNext(pRegion) : GetHead()); } }

void RenderRegionList::DoTotalUnion (  RenderRegion *  pRegion, View *  pView, DocRect  TotalUnion )  [private]

For the specified DocView, find all the regions that are attached to it, and union them all together and use the region 'pRegion' to hold this new region. All the other regions of this DocView are removed from the list and deleted. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/94 Parameters: pRegion  - the region to put the merged area into. [INPUTS] pView - the View that should have all its regions merged. TotalUnion - the union of all the regions for this DocView. See also: RenderRegionList::TryTotalUnion Definition at line 1404 of file rgnlist.cpp. { pRegion->ResetRegion(TotalUnion); Spread* pSpread = pRegion->GetRenderSpread(); // Delete all the others RenderRegion *pRegion2 =(RenderRegion *) GetNext(pRegion); while (pRegion2 != NULL) { // Remember the 'next' region because we might delete this one. RenderRegion *pNextRegion = (RenderRegion *) GetNext(pRegion2); // Is this the correct DocView and render context? if ((pRegion2->GetRenderView() == pView) && (pRegion2->GetRenderSpread() == pSpread) && (pRegion2->CanBeMerged())) { // Yes - delete this region pRegion->NeedsOSPaper = pRegion->NeedsOSPaper && pRegion2->NeedsOSPaper; Remove(pRegion2); delete pRegion2; // Make sure we don't have a dangling pointer to this region. if (pRegion2 == LastRendered) // Start from the beginning of the list again. LastRendered = NULL; } // Find the next render region pRegion2 = pNextRegion; } }

void RenderRegionList::HandleNodeDeletion (  Node *  pNode  )

Tells RenderRegions that they should be afraid, very afraid, if they are holding a pointer to this node... Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/2004 Definition at line 1245 of file rgnlist.cpp. { if (GetCount() == 0) return; RenderRegion *pRegion = (RenderRegion *) GetHead(); while (pRegion != NULL) { // Find the next region before this one is deleted RenderRegion* pNext = (RenderRegion *) GetNext(pRegion); // TODO: Could attack the context pointer here as well! // Make sure we're not holding onto a pointer to this node as the "backmost" pRegion->ClearBackmostChangedNode(pNode); // And hope that this region is about to get merged out of existence!!! // Find the next render region pRegion = pNext; } }

void RenderRegionList::ImmediateRender (  BOOL  bForceImmediate = FALSE  )

Finds all render regions associated with DocViews that have background rendering disabled, and renders them all immediately (i.e. to completion). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/94 Definition at line 1140 of file rgnlist.cpp. { TRACE( wxT("Warning - RenderRegionList::ImmediateRender - removed code\n") ); // TRACE( _T("Look, I'm in RenderRegionList::ImmediateRender()\n")); if ( CCamApp::IsDisabled() ) return; // If he has got the system disabled, ignore #ifndef STANDALONE // Make sure printing is ok. if (!PrintMonitor::IsPrintStatusOK()) { // No - a print job has gone wrong, so we delete all printing render regions // before continuing. RenderRegion *pRender = (RenderRegion *) GetHead(); while (pRender != NULL) { if (pRender->IsPrinting()) { // Render region is printing (well it's not really as an exception // has occured) so delete it. Remove(pRender); delete pRender; } // Try next region pRender = (RenderRegion *) GetNext(pRender); } // Reset the last rendered render region LastRendered = NULL; } #endif if (GetCount() == 0) return; PORTNOTE("other", "Disabled ControlHelper") #ifndef EXCLUDE_FROM_XARALX if (ControlHelper::IsUserInterfaceCaptured()) return; // No bg rendering if UI is captured (e.g. menu is up) #endif if (DragManagerOp::IsDragActive()) return; // No bg rendering if a DragManager op is active (NB this is for // colour/bitmap/bar drags only - not doc operation drags) if(ViewOps::IsFullScreenPending()) // no bg rendering if we are about to enter full screen mode return; // Optimise list based on render region percentage coverage TryTotalUnion(); RenderRegion *pRegion = (RenderRegion *) GetHead(); // Start the rendering indicator going. if (GetApplication()->GetpStatusLine()) GetApplication()->GetpStatusLine()->SetRenderIndicator(Rendering); while (pRegion != NULL) { // Find the next region before this one is deleted RenderRegion* pNext = (RenderRegion *) GetNext(pRegion); if (pRegion->IsPrinting() == FALSE) { // If this render region's DocView does not have background rendering enabled, // then it must be an immediate render region, so render it. View *pView = pRegion->GetRenderView(); ENSURE(pView != NULL, "No DocView in ImmediateRender!"); if ( !pView->GetForeBackMode() || bForceImmediate ) { // Keep user up to date if (GetApplication()->GetpStatusLine()) GetApplication()->GetpStatusLine()->SetRenderIndicator(Animate); //TRACE( _T("Immediate Render now\n")); // Render it. Error::RenderThreadIn(); // Make errors close window pRegion->DefaultRender(bForceImmediate); Error::RenderThreadOut(); // Normal errors } } // Find the next render region pRegion = pNext; } // Disable rendering indicator. if (GetApplication()->GetpStatusLine()) GetApplication()->GetpStatusLine()->SetRenderIndicator(NotRendering); }

void RenderRegionList::Merge (  RenderRegion *  NewRenderRegion  )

Add a render region object to the application's global list of render regions. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: NewRegion  - the RenderRegion object to add to the list. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 336 of file rgnlist.cpp. { // If it's a printer region, just render it to completion and return, because // we don't do background printing yet. if (NewRenderRegion->IsPrinting()) { NewRenderRegion->DefaultRender(); return; } // Adjust any render regions that are being scrolled away ClipRectsToClient(); // TRACE( _T("RenderRegionList::Merge GetCount == %d\n"), GetCount()); if (GetCount() == 0) { // Couldn't merge with any others, so just add it to the list. AddTail((ListItem *) NewRenderRegion); // IMMEDIATE REDRAW //#if _DEBUG // ImmediateRender(true); // Added by GAT //#endif return; } // Find out how big a pixel is PixelWidth = NewRenderRegion->GetScaledPixelWidth(); // Attempt to compact the list MergeRenderRegions(NewRenderRegion); // Make sure that there are no render regions that overlap - ever! RemoveRegionOverlap(NewRenderRegion); // add the New RenderRegion on the end of the List AddTail((ListItem *) NewRenderRegion); // Go though all the regions in the list and try to strictly // merge them with all the other in the list TidyUpAdjacentRegions(NewRenderRegion); // Set flag to indicate that one or more new regions have been added, and so we // should check for the possibility of merging all regions the next time we try a // background render. ListIsOptimal = FALSE; // IMMEDIATE REDRAW // ImmediateRender(); }

void RenderRegionList::MergeRenderRegions (  RenderRegion *  pRegionToMerge  )  [private]

Attempts to find regions which can be merged together to make redrawing more efficient. At the moment, the two regions to be merged must satisfy the following conditions:. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - They must be have got to the same node in the tree when they last stopped rendering. They must be rendering into the same View and Chapter. One of the regions must completely enclose or be adjacent to the other. Returns: Errors: - See also: - Definition at line 573 of file rgnlist.cpp. { // set a flag to indicate if none of the render regions could be merged BOOL Merged; // loop round until we can find no more render regions to merge together do { // We have not merged anything yet, so set the flag Merged = FALSE; // Find the render region to merges clipping rectangle and context node DocRect MergeClipRect = pRegionToMerge->GetRegionRect(); // Find which view the render region is to be rendering to View* MergeView = pRegionToMerge->GetRenderView(); // Get the first render region in the list RenderRegion* pOldRegion = (RenderRegion*) GetHead(); RenderRegion* pNextRegion; while (pOldRegion != NULL) { pNextRegion = (RenderRegion *) GetNext(pOldRegion); if (pOldRegion != pRegionToMerge) { // Find this old render regions view View* OldView = pOldRegion->GetRenderView(); // see if the two render regions can be merged if ( (MergeView == OldView) && (pOldRegion->GetRenderSpread()==pRegionToMerge->GetRenderSpread()) && (pOldRegion->CanBeMerged()) && (pRegionToMerge->CanBeMerged())) { // Find this regions clip rect DocRect OldClipRect = pOldRegion->GetRegionRect(); // see if one of the render regions contains the other if (MergeClipRect.ContainsRect(OldClipRect)) { // Get rid of the region that is inside the other pRegionToMerge->SetBackmostChangedNode(pOldRegion->GetBackmostChangedNode()); pRegionToMerge->NeedsOSPaper = pRegionToMerge->NeedsOSPaper && pOldRegion->NeedsOSPaper; Remove(pOldRegion); delete pOldRegion; Merged = TRUE; break; } else if (OldClipRect.ContainsRect(MergeClipRect)) { // Get rid of the region that is inside the other // pRegionToMerge->SetClipRect(OldClipRect, TRUE); pRegionToMerge->SetBackmostChangedNode(pOldRegion->GetBackmostChangedNode()); pRegionToMerge->ResetRegion(OldClipRect); pRegionToMerge->NeedsOSPaper = pRegionToMerge->NeedsOSPaper && pOldRegion->NeedsOSPaper; Remove(pOldRegion); delete pOldRegion; Merged = TRUE; break; } else { // Find the smallest dimension of the new region INT32 ShortSide = MergeClipRect.Height(); if (MergeClipRect.Width() < ShortSide) ShortSide = MergeClipRect.Width(); // Make sure that this figure is smaller than the sides ShortSide /= 3; // Want a fuzzyness of at least 64 pixels INT32 MinFuzzy = PixelWidth * 64; if (ShortSide<MinFuzzy) ShortSide = MinFuzzy; // If there is an overlap, then do some merging if (OldClipRect.IsAdjacent(MergeClipRect, ShortSide)) { DocRect ClipRect = OldClipRect.Union(MergeClipRect); // pRegionToMerge->SetClipRect(ClipRect, TRUE); pRegionToMerge->SetBackmostChangedNode(pOldRegion->GetBackmostChangedNode()); pRegionToMerge->ResetRegion(ClipRect); pRegionToMerge->NeedsOSPaper = pRegionToMerge->NeedsOSPaper && pOldRegion->NeedsOSPaper; Remove(pOldRegion); delete pOldRegion; Merged = TRUE; break; } } } } // Get the next render region in the list // pOldRegion = (RenderRegion *) GetNext(pOldRegion); pOldRegion = pNextRegion; } } while( Merged ); }

void RenderRegionList::Remove (  View *  pView  )

Removes all render regions from the application's list of render regions that are associated with a particular document. Usually called because the document is being closed (deleted). It deletes all RenderRegion objects it removes.Removes all render regions from the application's list of render regions that are associated with a particular view. Usually called because the docview is being closed (deleted). It deletes all RenderRegion objects it removes. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: pView  - the parent view that is being removed. [INPUTS] Definition at line 979 of file rgnlist.cpp. { // Start at the beginning and try to find render regions attached to this CWnd object. RenderRegion *Item = (RenderRegion *) GetHead(); while (Item != NULL) { // Is it the same as the View passed by the caller? if (Item->GetRenderView() == pView) { // Is it the LastRendered one? if (Item == LastRendered) { // Yes - so make LastRendered point to the previous render region // which means if Item is first in the list, LastRendered is set to // NULL, which is what we want - see BackgroundRender(). LastRendered = (RenderRegion *) GetPrev(Item); } // Move to next region and remove this one from the list and delete it. RenderRegion *Tmp = Item; Item = (RenderRegion *) GetNext(Item); RemoveItem((ListItem *) Tmp); delete Tmp; } else // Try the next region Item = (RenderRegion *) GetNext(Item); } }

void RenderRegionList::Remove (  Document *   )

void RenderRegionList::Remove (  RenderRegion *  RegionToRemove  )

Removes a render region from the application's list of render regions, It DOES NOT delete the RenderRegion object itself. This is used when the region has been completely rendered and is no longer needed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: RegionToRemove  - the render region object to remove from the list. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 864 of file rgnlist.cpp. { ENSURE( FindPosition(RegionToRemove) != NOT_IN_LIST, "Could not find RenderRegion to Remove" ); // Is it the LastRendered one? if (RegionToRemove == LastRendered) { // Yes - so make LastRendered point to the previous render region // which means if Item is first in the list, LastRendered is set to // NULL, which is what we want - see BackgroundRender(). LastRendered = (RenderRegion *) GetPrev(RegionToRemove); } // Remove the item from the list RemoveItem((ListItem *) RegionToRemove); }

void RenderRegionList::RemoveRegionOverlap (  RenderRegion *  NewRenderRegion  )  [private]

Called when adding a new render region to the list. It checks the new render region for overlap with all the old render regions and if it overlapps any of them, the old region is slit up. This function should guarantee that you never get render regions that overlap, so that the EORed stuff does not get screwed up by getting rendered more than once. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 10/01/94 Parameters: NewRenderRegion  - pointer to the render region being added [INPUTS] Definition at line 691 of file rgnlist.cpp. { // Find the clipping rect of the new render region DocRect NewClipRect = NewRenderRegion->GetRegionRect(); DocRect OldClipRect; // Find which view and spread the render region is to be rendering to View* NewView = NewRenderRegion->GetRenderView(); Spread* NewSpread = NewRenderRegion->GetRenderSpread(); // Get the first render region in the list RenderRegion* pOldRegion = (RenderRegion*) GetHead(); while (pOldRegion != NULL) { // Get the old render regions clipping rectangle OldClipRect = pOldRegion->GetRegionRect(); // Find which view and spread the render region is to be rendering to View* OldView = pOldRegion->GetRenderView(); Spread* OldSpread = pOldRegion->GetRenderSpread(); // If they intersect, split the old rectangle up into bits if ((OldView==NewView) && (OldSpread==NewSpread) && (OldClipRect.IsIntersectedWith(NewClipRect))) { if (NewClipRect.ContainsRect(OldClipRect)) { // The 2 regions were the same, so get rid of it, and go back around // the loop with the next region in the list. NewRenderRegion->SetBackmostChangedNode(pOldRegion->GetBackmostChangedNode()); NewRenderRegion->NeedsOSPaper = NewRenderRegion->NeedsOSPaper && pOldRegion->NeedsOSPaper; RenderRegion *Tmp = pOldRegion; pOldRegion = (RenderRegion *) GetNext(pOldRegion); Remove(Tmp); delete Tmp; continue; } else { // Split the old rect into sub-rects and add the new one DocRect SubRects[4]; INT32 RectCount = OldClipRect.SplitRect(NewClipRect, SubRects); ENSURE( RectCount!=0, "No rectangles found in SplitRect" ); // Change the clip rect of the region already in the list // pOldRegion->ResizeRegion(SubRects[0]); // pOldRegion->SetClipRect(SubRects[0]); pOldRegion->ResetRegion(SubRects[0]); // and create some new render regions if needed for (INT32 i=1; i<RectCount; i++) { // Create a new render region. // NB. important to pass in View pointer so that we get correct bitmap depth. RenderRegion* SubRenderRegion = OSRenderRegion::Create(SubRects[i], pOldRegion->GetMatrix(), OldView->GetViewScale(), RENDERTYPE_SCREEN, NewView); //OSRenderRegion* SubRenderRegion = new OSRenderRegion(*(OSRenderRegion*)pOldRegion); ENSURE( SubRenderRegion != NULL, "RenderRegionList::Merge: SubRenderRegion == 0"); if (SubRenderRegion == NULL) return; // Set the new clip region and see if it joins exactly if (!SubRenderRegion->CopyRenderInfo(*pOldRegion)) { // copying failed, so tidy up delete SubRenderRegion; TRACE( _T("CopyRenderInfo %d failed\n"), i); continue; // carry on round loop } // make sure the region is re-rendered // SubRenderRegion->IsPaperRendered = FALSE; // SubRenderRegion->IsInkRenderStarted = FALSE; // SubRenderRegion->SetClipRect(SubRects[i]); SubRenderRegion->ResetRegion(SubRects[i]); // SubRenderRegion->ResizeRegion(SubRects[i]); StrictMerge(SubRenderRegion); } } } // Get the next region in the list pOldRegion = (RenderRegion*) GetNext(pOldRegion); } }

void RenderRegionList::StrictMerge (  RenderRegion *  pRegionToMerge  )  [private]

Tries to merge the render region supplied with the rest of the list. They must be exactly adjacent ie. They don't intersect, and the union contains no area outside the two rectangles. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/01/94 Parameters: pRegionToMerge  - The region that we are planning to add to the list [INPUTS] Definition at line 483 of file rgnlist.cpp. { // set a flag to indicate if none of the render regions could be merged BOOL Merged; // loop round until we can find no more render regions to merge together do { // We have not merged anything yet, so set the flag Merged = FALSE; // Find the render region to merges clipping rectangle and context node and // find which view the render region is to be rendering to DocRect MergeClipRect = pRegionToMerge->GetRegionRect(); View* MergeView = pRegionToMerge->GetRenderView(); Node* NewContext = pRegionToMerge->GetRenderState(); // Get the first render region in the list RenderRegion* pOldRegion = (RenderRegion*) GetHead(); RenderRegion* pNextRegion; while (pOldRegion != NULL) { pNextRegion = (RenderRegion *) GetNext(pOldRegion); // Find this old render regions view View* OldView = pOldRegion->GetRenderView(); Node* OldContext = pOldRegion->GetRenderState(); // see if the two render regions can be merged if ( (MergeView == OldView) && (pOldRegion->GetRenderSpread()==pRegionToMerge->GetRenderSpread()) && ((OldContext==NewContext) || ((pOldRegion->CanBeMerged()) && (pRegionToMerge->CanBeMerged())))) { // Find this regions clip rect DocRect OldClipRect = pOldRegion->GetRegionRect(); // see if one of the render regions is EXACTLY adjacent to this one if (OldClipRect.IsAdjacent(MergeClipRect, 0)) { DocRect ClipRect = OldClipRect.Union(MergeClipRect); // Set the clip rect and get the render region to find its starting context node again // as things could have changed. // pRegionToMerge->SetClipRect(ClipRect, TRUE); pRegionToMerge->ResetRegion(ClipRect); Remove(pOldRegion); delete pOldRegion; Merged = TRUE; break; } } // Get the next render region in the list // pOldRegion = (RenderRegion *) GetNext(pOldRegion); pOldRegion = pNextRegion; } } while( Merged ); AddTail( (ListItem *) pRegionToMerge); }

void RenderRegionList::TidyUpAdjacentRegions (  RenderRegion *  pBrandNewRegion  )  [private]

Goes through all the regions in the list and tests to see if any of them line up exactly. If they do, they are joined into a single region. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/94 Parameters: pBrandNewRegion  - The region that has just been added to the list by OnDraw. [INPUTS] We should not delete this region during the Tidy up or OnDraw gets upset Definition at line 401 of file rgnlist.cpp. { // Need to perform an Nsquared loop through the regions RenderRegion* pRegion = (RenderRegion*) GetHead(); while(pRegion!=NULL) { // Get info about the region that we will need to test DocRect MergeClipRect = pRegion->GetRegionRect(); View* MergeView = pRegion->GetRenderView(); Node* NewContext = pRegion->GetRenderState(); // Find the region after pRegion to start searching from RenderRegion* pCompare = (RenderRegion*) GetNext(pRegion); // loop through all the regions that come after pRegion // see if any are suitbale for merging while(pCompare!=NULL) { // Find the next one now, as we may delete pCompare on the way through RenderRegion* pNextOne = (RenderRegion*) GetNext(pCompare); // We do not want to delete the brand new region, we should delete the others first if (pCompare!=pBrandNewRegion) { // Find the equivalent information in this region ready for testing View* OldView = pCompare->GetRenderView(); Node* OldContext = pCompare->GetRenderState(); // See if they can be merged if ( (MergeView == OldView) && (pRegion->GetRenderSpread()==pCompare->GetRenderSpread()) && ((OldContext==NewContext) || ((pRegion->CanBeMerged()) && (pCompare->CanBeMerged())))) { // So far so good. Just check that they are adjacent // Find this regions clip rect DocRect OldClipRect = pCompare->GetRegionRect(); // see if one of the render regions is EXACTLY adjacent to this one if (OldClipRect.IsAdjacent(MergeClipRect, 0)) { DocRect ClipRect = OldClipRect.Union(MergeClipRect); // Set the clip rect of one of the regions to be the union of both regions // pRegion->SetClipRect(ClipRect, TRUE); pRegion->SetBackmostChangedNode(pCompare->GetBackmostChangedNode()); pRegion->ResetRegion(ClipRect); // Get rid of the other region Remove(pCompare); delete pCompare; } } } // Get the next region pCompare = pNextOne; } // Get the next region in the outer loop pRegion = (RenderRegion*) GetNext(pRegion); } }

void RenderRegionList::TryTotalUnion (   )  [private]

For each DocView, try to union all the render regions, and see if the individual areas add up to more than 70% of the union area. If they do then we union all the regions together and just render one big one. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/94 See also: RenderRegionList::DoTotalUnion Definition at line 1284 of file rgnlist.cpp. { if (ListIsOptimal) // No need to do our checks return; DocRect TotalUnion; // List of DocViews we have optimised so far ViewList Views; // Go through each render region, and for each View, work out if it's worth // merging all the rectangles into one. RenderRegion *pRegion = (RenderRegion *) GetHead(); while (pRegion != NULL) { View *pView = pRegion->GetRenderView(); Spread* pSpread = pRegion->GetRenderSpread(); // Have we optimised this region's View already? if (!Views.IsViewOptimised(pView)) { // Haven't done this one yet - add it to the list for future reference if (!Views.AddView(pView)) { // Error - abort merging Views.DeleteAll(); return; } // We only do this merging for regions that have not started ink rendering yet. if (pRegion->CanBeMerged()) { // Get the union of all regions in this View, and the total area of them RenderRegion *pRegion2 = pRegion; // Indicates whether to test the percentage coverage - we don't if either: // (a) This View has only one region, or // (b) This View has regions which have started drawing ink already. BOOL TryUnion = FALSE; DocRect TotalUnion; double CombinedArea = 0.0; while (pRegion2 != NULL) { // Is this the correct View and render context? if (pRegion2->GetRenderView() == pView && pRegion2->GetRenderSpread() == pSpread ) { // More than one region - we can try to union them TryUnion = TRUE; // Have we started rendering the ink into this region yet? if (!pRegion2->CanBeMerged()) { // Yes, and we can't union if any have started rendering ink TryUnion = FALSE; // Quit the while loop break; } else { // No - so accumulate this region. DocRect ClipRect = pRegion2->GetRegionRect(); TotalUnion = TotalUnion.Union(ClipRect); CombinedArea += ((double) ClipRect.Width()) * ((double) ClipRect.Height()); } } // Find the next render region pRegion2 = (RenderRegion *) GetNext(pRegion2); } if (TryUnion) { // Ok - if the combined area is 70% or more of the area of the union, then // we might as well union all these regions. double UnionArea = (double) TotalUnion.Width() * (double) TotalUnion.Height(); double Coverage = CombinedArea / UnionArea; if (Coverage > 0.60) { // Yes - let's union all these regions DoTotalUnion(pRegion, pView, TotalUnion); } } } } // Find the next render region pRegion = (RenderRegion *) GetNext(pRegion); } // Don't bother with this again unless a new render region is added. ListIsOptimal = TRUE; }

---

Member Data Documentation

RenderRegion* RenderRegionList::LastRendered [private]

Definition at line 149 of file rgnlist.h.

BOOL RenderRegionList::ListIsOptimal [private]

Definition at line 154 of file rgnlist.h.

MILLIPOINT RenderRegionList::PixelWidth [private]

Definition at line 151 of file rgnlist.h.

---

The documentation for this class was generated from the following files:

• Kernel/rgnlist.h (r1785/r751)
• Kernel/rgnlist.cpp (r1785/r1328)

---