SuperGallery Class Reference

#include <sgallery.h>

Inheritance diagram for SuperGallery:

List of all members.

Public Member Functions
	SuperGallery (CCRuntimeClass *Class=NULL)
	SuperGallery constructor (Identical to DialogOp).
	SuperGallery (String_32 &NewName, CCRuntimeClass *Class=NULL)
	SuperGallery constructor (Identical to DialogOp).
	~SuperGallery ()
	SuperGallery destructor.
virtual BOOL	Create (void)
	The SuperGallery Create method This method has been overridden to de-specialize the DialogOp.
virtual void	SetVisibility (BOOL Open)
	Used by the tool bar customize system to open and close a tool bar.
void	SetGallerySize (wxSize Size)
wxSize	GetGallerySize (void)
BOOL	Write (CCLexFile &file)
	Write the Gallery to the file in a tokenized form Write the SuperGallery to the file in a tokenized form.
BOOL	Write (SaveRegistryEntries &Saver)
	Write the SuperGallery to the registry.
virtual MsgResult	Message (Msg *Message)
	A standard message handler, really. If you override this in a derived class, you must pass any unhandled event on to this base class method after handling the messages you are interested in.
INT32	GetDisplayExtent (void)
	To determine the length of the displayed list, in MILLIPOINTS; actually, in terms of the mimimum displayed Y coordinate, which is really -(Length).
void	ForceGroupFolded (SGDisplayGroup *GroupToFold, BOOL FoldedState)
	Ensures that the given group is in an {un}folded state. If it is not oin the desired state, the state is changed, and the tree is reformatted and invalidated for redraw.
void	ScrollToShow (DocRect *Area, BOOL PreferToSeeBottom=FALSE)
	Determines if the given rectangle is entirely visible in the display window. If it is not, the window is scrolled to show the rectangle. Used to scroll the display to ensure a single item or set of items is visible on screen.
void	ScrollArea (DocRect *Area, DocCoord *ScrollBy)
	To scroll the list gadget in the super gallery. Basically just a veneer function for sgdisplayrootscroll which can't tidily access the DialogOp method...
void	PaintListNow (void)
	Direct veneer function for DialogOp::PaintGadgetNow for the ListBox gadget. Allows SGDisplayNodes to force an immediate update.
void	ReformatNow (BOOL ForceReformat)
	Immediately reformats the display tree if necessary. NOTE: This is done automatically on any redraw if the cached format is known to be out of date. However, sometimes (e.g. when unfolding a group and then scrolling to it) you may want to chnage the display tree format and then cause the formatting to be recalculated before it is needed for the next step (scrolling) of your operation.
void	ForceRedrawOfList (void)
	Reformats, and then redraws the entire displayed list.
void	ForceRedrawOfArea (DocRect *Area)
	Redraws the given region of the list. The area specified is a MILLIPOINT offset within the SuperGallery Virtual Coordinate Space.
void	RedrawEverythingBelow (INT32 TopYCoord)
	To redraw the display list from a given positio downwards (e.g. if a document list changes, you'll need to redraw its display, plus any displays below it which may have moved around).
void	RedrawDocumentDisplay (Document *TheDocument)
	To redraw the entire display list for the given document. If the cached formatting information is known to be compromised, a reformat will occur, and the necessary regions will be redrawn. Otherwise, just the document's display will be redrawn.
void	ReformatAndRedrawIfNecessary (void)
	If the cached format information is thought to be out of date (eg after someone has called InvalidateCachedFormat) then this method will cause a reformatting operation to be carried out, and will then redraw any areas which are affected (have changed due to the reformatting).
void	InvalidateCachedFormat (void)
	Indicates to the super gallery that the cached display tree formatting is out of date, and must be recalculated before next redraw of the display.
void	ShadeGallery (BOOL ShadeIt)
	Shades (disables) the SuperGallery window. This calls the DoShadeGallery upcall to allow derived classes to take special action for any extra controls they may own, etc.
void	SelectItems (BOOL SelectThem, BOOL Exclusive=FALSE, Document *ParentDocument=NULL, Library *ParentLibrary=NULL)
	To select/deselect groups of display items (or all display items) in this Gallery display. All items whose state changes will force redraw themselves automatically.
void	SelectGroups (BOOL SelectThem, BOOL Exclusive=FALSE, Document *ParentDocument=NULL, Library *ParentLibrary=NULL)
	To select/deselect groups of display groups (or all display groups) in this Gallery display. All groups whose state changes will force redraw themselves automatically.
void	SelectRange (SGDisplayNode *PrimeNode, SGDisplayNode *AnchorNode)
	Selects the PrimeNode, and if possible, all sibling nodes between it and the Anchor node. If Anchor == NULL or is not found, only PrimeNode is selected. Does not deselect any nodes - you should call SelectItems first to clear the seln.
INT32	GetSelectedItemCount (Document *TheDocument=NULL, Library *TheLibrary=NULL)
	Counts the number of selected items in the display tree or a subtree.
INT32	GetSelectedGroupCount (void)
	Counts the number of selected groups in the display tree.
virtual void	SelectionHasChanged (void)
	To inform the gallery that the selection has changed in some way. The base gallery class will do the following things:.
BOOL	AreYouRedrawingNow (void)
	To determine if the gallery is currently redrawing. This is necessary for two reasons: (1) To ensure we don't go re-entrant in redraw code (because we can't have more than one active render region or it'll go bang), (2) To allow things like the SGDisplayRootScroll to take special action when they try to chnage the scroll position if we are in a redraw (obviously at this point, doing a ScrollWindow and force redraws would be silly, if not downright dangerous).
CGadgetID	GetListGadgetID (void)
	To allow outside entities to determine the list box gadget ID. Meant only for gallery drags to determine their target area.
INT32	GetDisplayMode () const
SGDisplayRoot *	GetDisplayTree () const
virtual BOOL	CanSearchKeywords (void)
	Used to determine if this type of gallery supports keyword searching. By default galleries do not. Override and return TRUE if you do.
virtual BOOL	GetStatusLineHelp (DocCoord *MousePos, String_256 *Result)
	Gets status line help from the gallery.
virtual BOOL	PreContextMenu (void)
	Give the gallery a chance to do something before popping up the context menu. Called before the context menu is popped up on a right click. At present, used by the bitmap gallery to ensure that the plug-ins have all been parsed. Notes: The base class method does nothing. Override it in galleries which require this assistance.
virtual BOOL	InitMenuCommands (void)
	Initialises any menu commands that this gallery needs.
BOOL	InitMenuCommand (StringBase *CommandID, UINT32 MenuTextID)
	To initialise a menu command for future use. This should be called for any potential menu commands *on startup* - it essentially adds OpDescriptors to the system, and they must be initialised and ready to go right from startup of the application.
virtual BOOL	BuildCommandMenu (GalleryContextMenu *TheMenu, SGMenuID MenuID)
	To build a menu of commands to be popped up over the gallery.
BOOL	AddCommand (GalleryContextMenu *TheMenu, StringBase *CommandID, BOOL Separator=FALSE, MenuItem *pRootMenu=NULL)
	To add a gallery command (or separator) to the end of a menu currently being built. Call this from your overridden BuildCommandMenu method to add each appropriate command to the menu. NOTE that this command must have been registered on startup by calling InitMenuCommand.
virtual OpState	GetCommandState (StringBase *CommandID, String_256 *ShadeReason)
	To determine the state of a given menu item. This method is an exact parallel to an Op's GetState method (in fact, it is called by an Op's GetState).
virtual void	DoCommand (StringBase *CommandID)
	To apply a given command when it is chosen from the menu.
SGDisplayGroup *	FindCommandGroup (void)
	Determines which group will be affected by a menu command, if any. Esentially finds the first selected group in the gallery, or the parent group of the first selected item.
virtual SGDisplayItem *	CopyDisplayItem (SGDisplayItem *SourceItem, SGDisplayGroup *DestGroup, SGDisplayItem *TargetPosition=NULL)
	"Copies" the existing node in the tree in an appropriate fashion.
virtual void	AllItemsCopied (SGDisplayGroup *DestGroup)
	This upcall method is called after one or more items have been copied or moved by a gallery drag. It allows the gallery to do update things like broadcasting a message or getting a related window (eg colour line) to redraw at the end of a move/copy operation. This allows thousands of items to be moved/copied with only a single redraw/message-broadcast, etc at the very end.
SGDisplayNode *	FindNodeUnderPointer (DocCoord *ThePoint)
	To allow outside entities to determine which display node lies under the (current mouse pointer) position.
void	AutoScrollForDrag (DocCoord *MousePosition)
	If the given point is near the top or bottom of the window, this will cause the supergallery to auto-scroll the window up/down. Intended to allow drags to autoscroll as necessary.
void	FillInMiscInfo (SGMiscInfo *MiscInfo, ReDrawInfoType *DlgRedrawInfo=NULL)
	Sets up a MiscInfo structure, ready for use.
virtual SGDisplayGroup *	AddLibraryGroup (Library *LibraryToDisplay, INT32 NumItems)
	Creates a blank group in the displaytree representing the given library. (If a suitable group already exists, its contents are wiped in preparation for being filled in again).
virtual void	RemoveLibraryGroup (Library *DisplayedLibrary)
	Ensures that there are no display groups representing this library in the DisplayTree- deletes any related group from the tree if necessary. Used when Library objects are destructed to ensure no references to them are held by their parent gallery.
virtual SGDisplayItem *	AddLibraryItem (SGDisplayGroup *LibraryGroup, Library *ParentLib, LibraryIndex ItemIndex, BOOL bNew=FALSE)
	Called by the Library class to create a display item for every item in a newly-scanned library file. It is essentially a callback to the gallery which requested that the library be scanned.
void	ConvertToVirtualCoords (SGMiscInfo *MiscInfo, DocCoord *SourceAndResult)
	Converts a standard DocCoord, as passed in for kernel-rendered dialogues, into a standard Display-list virtual coordinate, as used by Display items.
BOOL	ConvertFromVirtualCoords (SGMiscInfo *MiscInfo, DocRect *SourceAndResult)
	Converts a standard Display-list virtual rectangle, as used by Display items, into a rect as used in kernel-rendered dialogues. The returned rectangle may be outside the visible display area of the gadget.
virtual BOOL	ApplyAction (SGActionType Action)
	Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc).
SGSortKey *	GetCurrentSortKeys (void)
virtual void	ApplySortNow (BOOL ApplyToEntireList)
	Applies the current gallery sort mode (member array SortKeys) to the display list.
BOOL	DeVirtualiseAllGroups (StringBase *ProgressBarMsg)
	Go through all the gallery groups and de-virtualise all virtual groups. A virtual group is a group with no associated items, de-virtualising will create all these items.
void	SetLastSelectedNode (SGDisplayNode *JustSelected)
	To set which node, if any, was last selected in this gallery. Used by the display tree to determine the anchor point for selection extension exercises.
SGDisplayNode *	GetLastSelectedNode (void)
	To determine which node, if any, was last selected in this gallery. Used by the display tree to determine the anchor point for selection extension exercises.
virtual BOOL	GetQuietStatus (void)
	Get the Quiet status of the gallery - used when a load of indexes are being added to the gallery and there are problems...
virtual void	SetQuietStatus (BOOL Status)
	Set the Quiet status of the gallery - used when a load of indexes are being added to the gallery and there are problems...
virtual BOOL	IsLibraryGallery (void)
	To check if we're a library gallery.
virtual BOOL	IsLibraryGalleryWithNonLibraryGroups (void)
	To check if we're a dedicated library gallery, or a half+half (like the font gallery).
void	IncrementPendingRedraws (void)
	Called by SGDisplayNode classes to handle background redraw. This increments our count of how many items are awaiting background redraw. While this counter is greater than zero, we use an idle processor to kick off background redraws every now and then.
void	DecrementPendingRedraws (void)
	Called by SGDisplayNode classes to handle background redraw. This increments our count of how many items are awaiting background redraw. While this counter is greater than zero, we use an idle processor to kick off background redraws every now and then.
virtual BOOL	OnIdleEvent (void)
	Processes idle events for the supergallery. This is used to provide backgrounded redraw of gallery items.
void	FlushBackgroundRedraws (void)
	Resets the BG rendering system - flushes all pending bg redraws, and then ensures the system is in the default (inactive) state. This has the useful side effect that if bg rendering has become confused it will reset the state and 'unconfuse' the renderer.
void	SetLastBackgroundNode (SGDisplayNode *LastNodeRendered)\
SGDisplayNode *	GetLastBackgroundNode (void)\
virtual BOOL	IsABar ()
virtual BOOL	IsAGallery ()
String_32 &	GetGalName ()
void	SetGalName (const String_32 &str)
Static Public Member Functions
static SuperGallery *	FindSuperGallery (String_32 &SuperGalleryName, INT32 limit=-1)
	Looks for a given SuperGallery by using its name.
static SuperGallery *	FindSuperGallery (ResourceID SuperGalleryID)
	Looks for a given SuperGallery by using its name.
Public Attributes
SGDisplayRoot *	DisplayTree
String_32	Name
Static Public Attributes
static INT32	UseFixedColourSet = FALSE
Protected Member Functions
void	InsertCopiedItem (SGDisplayItem *CopiedItem, SGDisplayGroup *DestGroup, SGDisplayItem *TargetPosition)
	Inserts a given copied-node into the tree in an appropriate fashion. Used for re-organising the tree at the conclusion of a drag. Intended to be called only from overridden CopyDisplayItem() methods, to take all the work out of the process of copying display items around.
void	BroadcastEvent (SGEventType EventType, void *EventInfo, SGMiscInfo *MiscInfo=NULL)
	Passes the given event through the DisplayTree.
void	CalcVirtualSize (ReDrawInfoType *DlgRedrawInfo, DocRect *VirtualSize, INT32 *PixelSize)
	Shared internal code to determine the virtual coordinate space of the region of the display list which is visible n screen.
void	RenderListBox (ReDrawInfoType *RedrawInfo)
	Renders the displayed list of items into the 'list box' control.
void	ConvertToVirtualCoords (ReDrawInfoType *DlgRedrawInfo, DocCoord *SourceAndResult)
	Converts a standard DocCoord, as passed in for kernel-rendered dialogues, into a standard Display-list virtual coordinate, as used by Display items.
virtual BOOL	PreCreate (void)
	A call to be overridden by the derived class. This is called BEFORE the SuperGallery::Create function tries to create the gallery window. Derived galleries then initialise any unintialised data, and return TRUE if it is safe to continue creating the gallery window.
virtual BOOL	PostCreate (void)
	A call to be overridden by the derived class. This is called AFTER the SuperGallery::Create function has succeeded. Derived galleries can then initialise any unintialised data, and return TRUE if it is safe to open the gallery window.
virtual void	DoShadeGallery (BOOL ShadeIt)
	Shades (disables) the SuperGallery window. This calls the DoShadeGallery upcall to allow derived classes to take special action for any extra controls they may own, etc.
virtual void	HandleDragStart (DragMessage *DragMsg)
	Checks a DragMessage to see if it is a gallery list-drag. If so, it adds a new drag target to handle drops on the gallery list box.
virtual RenderRegion *	CreateRenderRegion (DocRect *VirtualSize, ReDrawInfoType *DlgRedrawInfo)
	An overridable veneer to the DialogOp CreateOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering.
virtual void	DestroyRenderRegion (RenderRegion *pRender)
	An overridable veneer to the DialogOp DestroyOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering.
virtual void	CloseOwnedDialogs (void)
	Checks and closes the various dialogs which can be owned by galleries.
Static Protected Member Functions
static INT32 __cdecl	SortComparator (const void *Item1, const void *Item2)
	'qsort' comparator function, used when quicksorting the display list
Protected Attributes
wxSize	GallerySize
INT32	PendingRedraws
SGDisplayNode *	LastBGNode
INT32	DisplayMode
BOOL	FormatIsCached
INT32	LastWindowDX
INT32	LastWindowDY
BOOL	AmShaded
BOOL	AmRedrawing
SGDisplayNode *	LastSelectedNode
MonotonicTime	LastClickTime
DocCoord	LastClickPos
BOOL	DblClickPending
SGalleryOptionsDlg *	CurrentOptionsDlg
SGallerySortDlg *	CurrentSortDlg
SGallerySearchDlg *	CurrentSearchDlg
SGSortKey	SortKeys [MaxSGSortKeys]
SGalleryLinePropertiesDlg *	CurrentLinePropertiesDlg
Static Protected Attributes
static SuperGallery *	CurrentSortGallery = NULL
Private Member Functions
void	InitData (void)
	Internal method to initialise data mambers. Shared code for constructors.
Friends
class	SGalleryOptionsDlg
class	SGallerySortDlg
class	SGallerySearchDlg
class	SGalleryLinePropertiesDlg

---

Detailed Description

Definition at line 243 of file sgallery.h.

---

Constructor & Destructor Documentation

SuperGallery::SuperGallery (  CCRuntimeClass *  Class = NULL  )

SuperGallery constructor (Identical to DialogOp). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 Definition at line 228 of file sgallery.cpp. : DialogOp(_R(IDD_BLANKBAR), MODELESS,0,GSAFECLASS(Class)) { String_32 str = String_32(_R(IDS_K_BARS_NONAME)); Name=str; InitData(); }

SuperGallery::SuperGallery (  String_32 &  NewName, CCRuntimeClass *  Class = NULL )

SuperGallery constructor (Identical to DialogOp). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 Definition at line 248 of file sgallery.cpp. : DialogOp(_R(IDD_BLANKBAR), MODELESS,0,GSAFECLASS(Class)) { String_32 str = String_32(_R(IDS_K_BARS_NONAME)); Name=str; InitData(); }

SuperGallery::~SuperGallery (   )

SuperGallery destructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 Definition at line 268 of file sgallery.cpp. { if (DisplayTree != NULL) { DisplayTree->DestroySubtree(); // Destroy the tree, destructing all nodes except root delete DisplayTree; // And delete the root as well DisplayTree = NULL; } CloseOwnedDialogs(); // Remove any idle event processor we had registered for BG redraws GetApplication()->RemoveIdleProcessor(MyIdlePriority, this); }

---

Member Function Documentation

BOOL SuperGallery::AddCommand (  GalleryContextMenu *  TheMenu, StringBase *  CommandID, BOOL  Separator = FALSE, MenuItem *  pRootMenu = NULL )

To add a gallery command (or separator) to the end of a menu currently being built. Call this from your overridden BuildCommandMenu method to add each appropriate command to the menu. NOTE that this command must have been registered on startup by calling InitMenuCommand. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: TheMenu  - The menu to add commands to [INPUTS] CommandID - The command to add to the menu - May not be NULL Separator - TRUE to follow this item with a separator pRootMenu Pointer to root menu to add this to or NULL for main root Returns: TRUE if it succeeded See also: SuperGallery::BuildCommandMenu; SuperGallery::InitMenuCommand Definition at line 2694 of file sgallery.cpp. { String_256 OpToken = GetGalName(); // With the new GIF Animation frame gallery, this can mean that the OpToken can easily // overrun its String_32 allocation. Therefore, restrict the name to the first 16 characters. // Unfortunately, we then use the name to find the gallery to send the command to! // So we match that only using the GalleryBarNameLimitSize (16) characters String_256 OpTokenT = OpToken; OpToken.Left(&OpTokenT, GalleryBarNameLimitSize); OpTokenT += TEXT(":"); OpTokenT += *CommandID; return(TheMenu->BuildCommand(OpTokenT, Separator, pRootMenu)); }

SGDisplayGroup * SuperGallery::AddLibraryGroup (  Library *  LibraryToDisplay, INT32  NumItems )  [virtual]

Creates a blank group in the displaytree representing the given library. (If a suitable group already exists, its contents are wiped in preparation for being filled in again). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/2/95 Parameters: LibraryToDisplay  - points to a Library object which needs to be displayed [INPUTS] in this gallery. NumItems - The expected number of items that will be added to this group. Returns: NULL, or the newly created group Notes: This is a callback function called by a newly created Library as a result of that library having been opened by this gallery. See also: SuperGallery::RemoveLibraryGroup; SuperGallery::AddLibraryItem Reimplemented in LibraryGallery, LibClipartSGallery, LibFillsSGallery, and FontsSGallery. Definition at line 2438 of file sgallery.cpp. { ERROR3IF(LibraryToDisplay == NULL, "SuperGallery::AddLibraryGroup - NULL parameter is illegal"); if (DisplayTree == NULL) { ERROR3("SuperGallery::AddLibraryGroup called before the DisplayTree was initialised!"); return(NULL); } SGDisplayGroup *TheGroup = DisplayTree->FindSubtree(this, NULL, LibraryToDisplay); if (TheGroup == NULL) { // No existing group for that library, so create a new one TheGroup = new SGDisplayGroup(this, NULL, LibraryToDisplay); if (TheGroup == NULL) // Failed! return(NULL); // And add it to our display tree DisplayTree->AddItem(TheGroup); } else TheGroup->DestroySubtree(FALSE); // Delete all items in the group return(TheGroup); }

SGDisplayItem * SuperGallery::AddLibraryItem (  SGDisplayGroup *  LibraryGroup, Library *  ParentLib, LibraryIndex  ItemIndex, BOOL  bNew = FALSE )  [virtual]

Called by the Library class to create a display item for every item in a newly-scanned library file. It is essentially a callback to the gallery which requested that the library be scanned. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/2/95 Parameters: LibraryGroup  - The group to add the item into [INPUTS] ParentLib - (For cross checking inputs) the library you allege the above group is for. ItemIndex - The Library generated index for this item Returns: NULL, or a pointer to the created item Notes: This method MUST BE OVERRIDDEN by the derived gallery that opens the library, in order to create appropriate SGDisplayItem-derived nodes for the things in the library (e.g. a clipart library gallery will have to create items that display clipart thumbnails) See also: SuperGallery::AddLibraryGroup; SuperGallery::RemoveLibraryGroup Reimplemented in LibraryGallery, LibClipartSGallery, LibFillsSGallery, and FontsSGallery. Definition at line 2535 of file sgallery.cpp. { ERROR3IF(LibraryGroup == NULL || ParentLib == NULL, "SuperGallery::AddLibraryItem - NULL params are illegal"); ERROR3IF(LibraryGroup->GetParentLibrary() != ParentLib, "SuperGallery::AddLibraryitem - The DisplayGroup is not for the same library!"); // The base class cannot add library items - derived classes must override this method // in order to provide the necessary functionality (as they must create items of the // correct type in order to display things from the given library ERROR3("Illegal attempt to add a library item to a gallery which doesn't support it!"); return(NULL); }

void SuperGallery::AllItemsCopied (  SGDisplayGroup *  DestGroup  )  [virtual]

This upcall method is called after one or more items have been copied or moved by a gallery drag. It allows the gallery to do update things like broadcasting a message or getting a related window (eg colour line) to redraw at the end of a move/copy operation. This allows thousands of items to be moved/copied with only a single redraw/message-broadcast, etc at the very end. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/3/95 Parameters: DestGroup  - Indicates where the copy/move took place. [INPUTS] An example where this methodis used is the colour gallery. Notes: The caller automatically causes the appropriate things to be redrawn, so we just need to update other things. e.g. The colour gallery broadcasts a ColourChangingMsg to make sure that the colour line and other interested parties all update appropriately. See also: SuperGallery::CopyDisplayItem; SGDisplayItem::MoveBefore; SGDisplayItem::MoveAfter; ColourSGallery::AllItemsCopied Reimplemented in ColourSGallery, LibraryGallery, and FontsSGallery. Definition at line 3174 of file sgallery.cpp. { // The base class does nothing }

BOOL SuperGallery::ApplyAction (  SGActionType  Action  )  [virtual]

Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/95 Parameters: Action  - Indicates what action to apply [INPUTS] Returns FALSE (Derived classes will return TRUE to indicate successful handling of the action, or FALSE to indicate failure) Notes: This base-class method should be overridden by derived classes. It does nothing by default, and returns FALSE. See also: SGActionType Reimplemented in NameGallery, TEMPLATESGallery, BitmapSGallery, ColourSGallery, FrameSGallery, LayerSGallery, LibraryGallery, LibClipartSGallery, LibFillsSGallery, LineGallery, NameGallery, and FontsSGallery. Definition at line 1019 of file sgallery.cpp. { return(FALSE); }

void SuperGallery::ApplySortNow (  BOOL  ApplyToEntireList  )  [virtual]

Applies the current gallery sort mode (member array SortKeys) to the display list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/95 Parameters: ApplyToEntireList  - TRUE to sort the entire DisplayList, [INPUTS] FALSE to sort only groups which contain a selection See also: SuperGallery::SortComparator; qsort Reimplemented in FontsSGallery. Definition at line 1085 of file sgallery.cpp. { if (SortKeys[0].SortKey == 0 || DisplayTree == NULL) return; CurrentSortGallery = this; SGDisplayNode *CurrentGroup = DisplayTree->GetChild(); if (CurrentGroup == NULL) // Nothing to sort return; SGDisplayNode *Ptr = CurrentGroup; // Pre-run progress indicator String_64 ProgMsg(_R(IDS_GALLERY_PREPARE_FOR_SORT)); BeginSlowJob(-1, FALSE, &ProgMsg); // For library galleries we need to set the Quiet button status ready to un-supress errors SetQuietStatus(FALSE); // Count the number of available items to sort BOOL HasSelection = FALSE; INT32 NumItemsToSort = 0; while (Ptr != NULL) { if(ApplyToEntireList || ((SGDisplayGroup *)Ptr)->IsSelected()) if(((SGDisplayGroup *)Ptr)->IsVirtualised()) ((SGDisplayGroup *)Ptr)->DeVirtualise(); if (ApplyToEntireList || ((SGDisplayGroup *)Ptr)->FindNextSelectedItem(NULL) != NULL) { SGDisplayNode *Item = Ptr->GetChild(); // Count number of items to sort in this group INT32 ItemsInThisGroup = 0; while (Item != NULL) { ItemsInThisGroup++; if (Item->Flags.Selected) HasSelection = TRUE; Item = Item->GetNext(); } if (ItemsInThisGroup > 1 && (ApplyToEntireList || HasSelection)) NumItemsToSort += ItemsInThisGroup; } Ptr = Ptr->GetNext(); } EndSlowJob(); // If there is no point in trying to sort, abort now if (NumItemsToSort < 2) return; // Start progress indicators, with a percentage based upon the number of items. // We will update twice for each group (after qsort and shuffle-items stages) String_64 Description(_R(IDS_SGOPTS_SORTING)); BeginSlowJob(NumItemsToSort * 2, FALSE, &Description); NumItemsToSort = 0; INT32 NumItems; INT32 i; BOOL GroupHasChanged = FALSE; while (CurrentGroup != NULL) { // Don't sort virtualised-out groups ! (they should have all been devirtualised before) if(!((SGDisplayGroup *)CurrentGroup)->IsVirtualised()) { HasSelection = FALSE; Ptr = CurrentGroup->GetChild(); ERROR3IF(Ptr != NULL && !Ptr->IsKindOf(CC_RUNTIME_CLASS(SGDisplayItem)), "Sort hasn't found items! Heinous failure imminent!" ); // Count the number of items we have to sort NumItems = 0; while (Ptr != NULL) { NumItems++; if (Ptr->Flags.Selected) HasSelection = TRUE; Ptr = Ptr->GetNext(); } // If there are 2 or more items, and we are either applying to all groups, or this // group contains selected item(s), then we will sort it.. if (NumItems > 1 && (ApplyToEntireList || HasSelection)) { // Get memory for an array of pointers to these items SGDisplayNode **SortArray = (SGDisplayNode **)CCMalloc(NumItems * sizeof(SGDisplayNode *)); if (SortArray == NULL) { CurrentSortGallery = NULL; InvalidateCachedFormat(); EndSlowJob(); InformError(); return; } // Fill in the array with pointers to display items to sort i = 0; Ptr = CurrentGroup->GetChild(); while (Ptr != NULL) { SortArray[i++] = Ptr; Ptr = Ptr->GetNext(); } // Sort the array of pointers qsort(SortArray, NumItems, sizeof(SGDisplayNode *), SuperGallery::SortComparator); NumItemsToSort += NumItems; if (!ContinueSlowJob(NumItemsToSort)) // Update percentage complete for the number of items processed { // User has cancelled by pressing escape CCFree(SortArray); break; } GroupHasChanged = FALSE; // Now, take the sorted array, and rearrange the display items to be in that order // Special case the first item if (SortArray[0]->GetPrevious() != NULL) { SortArray[1]->MoveBefore(SortArray[0]); GroupHasChanged = TRUE; } // Then whip through the rest of the items for (i = 1; i < NumItems; i++) { if (SortArray[i]->GetPrevious() != SortArray[i-1]) { SortArray[i-1]->MoveAfter(SortArray[i]); GroupHasChanged = TRUE; } } // Free our temporary workspace CCFree(SortArray); // Tell the derived gallery that the items in this group have been moved about if (GroupHasChanged) AllItemsCopied((SGDisplayGroup *)CurrentGroup); NumItemsToSort += NumItems; if (!ContinueSlowJob(NumItemsToSort)) break; // Update percentage complete for the number of items processed, and quit if aborted } } // And go on to the next group CurrentGroup = CurrentGroup->GetNext(); } CurrentSortGallery = NULL; EndSlowJob(); InvalidateCachedFormat(); ReformatAndRedrawIfNecessary(); }

BOOL SuperGallery::AreYouRedrawingNow (  void   )  [inline]

To determine if the gallery is currently redrawing. This is necessary for two reasons: (1) To ensure we don't go re-entrant in redraw code (because we can't have more than one active render region or it'll go bang), (2) To allow things like the SGDisplayRootScroll to take special action when they try to chnage the scroll position if we are in a redraw (obviously at this point, doing a ScrollWindow and force redraws would be silly, if not downright dangerous). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/2/95 Returns: TRUE if we are currently processing a redraw event Definition at line 694 of file sgallery.h. { return(AmRedrawing); }

void SuperGallery::AutoScrollForDrag (  DocCoord *  MousePosition  )

If the given point is near the top or bottom of the window, this will cause the supergallery to auto-scroll the window up/down. Intended to allow drags to autoscroll as necessary. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/3/95 Parameters: MousePosition  - A point, in normal kernel-rendered-dialogue coordinates [INPUTS] within the gallery list-box control. (Millipoint offsets from the bottom left corner of the window). Notes: Does nothing if the window is closed, or there is no display tree See also: SGListDragTarget::HandlEvent Definition at line 3257 of file sgallery.cpp. { if (DisplayTree == NULL || !IsVisible()) return; const INT32 AutoScrollDist = 28000/2; // MILLIPOINT distance for autoscroll activation // Get our kernel-rendered-dlg info ReDrawInfoType DlgRedrawInfo; GetKernelRenderedGadgetInfo(GetListGadgetID(), &DlgRedrawInfo); // Find distance from top (or bottom) of the window, and determine a // scroll speed/direction factor to use below INT32 Dist = DlgRedrawInfo.dy - MousePosition->y; INT32 ScrollSpeed = -3; if (Dist < 0 || Dist > AutoScrollDist) { Dist = MousePosition->y - 0; ScrollSpeed = +3; } if (Dist > 0 && Dist < AutoScrollDist) { // We're within AutoScrollDist of the top/bottom - let's scroll Dist = (AutoScrollDist - Dist) * ScrollSpeed; SGMiscInfo MiscInfo; FillInMiscInfo(&MiscInfo, &DlgRedrawInfo); DisplayTree->SetScrollOffset(DisplayTree->GetScrollOffset() + Dist, &MiscInfo); } }

void SuperGallery::BroadcastEvent (  SGEventType  EventType, void *  EventInfo, SGMiscInfo *  MiscInfo = NULL )  [protected]

Passes the given event through the DisplayTree. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/1/95 Parameters: EventType  - the type of the event to broadcast [INPUTS] EventInfo - the information to pass in 'EventInfo' to all event handlers (FormatInfo/RedrawInfo/MouseInfo, etc, depending upon EventType) MiscInfo - the MiscInfo to pass to the event handlers. If this is passed in as NULL, a MiscInfo structure will be set up automatically and passed in (as MiscInfo must *always* be supplied) See also: SGDisplayNode::HandleEvent Definition at line 344 of file sgallery.cpp. { if (DisplayTree == NULL) return; SGMiscInfo TheMiscInfo; if (MiscInfo == NULL && IsVisible()) { FillInMiscInfo(&TheMiscInfo); MiscInfo = &TheMiscInfo; } ERROR3IF(MiscInfo == NULL && (EventType != SGEVENT_THUMBMSG && EventType != SGEVENT_BGFLUSH), "Attempt to broadcast an event when the gallery is closed could be dangerous. Tell Jason"); DisplayTree->HandleEvent(EventType, EventInfo, MiscInfo); }

BOOL SuperGallery::BuildCommandMenu (  GalleryContextMenu *  TheMenu, SGMenuID  MenuID )  [virtual]

To build a menu of commands to be popped up over the gallery. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: TheMenu  - The menu to add commands to [INPUTS] MenuID - The type of menu (over-list or from-options-button) to create Returns: TRUE if it succeeded Notes: The base class does nothing. Override in order to provide a menu. Reimplemented in NameGallery, BitmapSGallery, ColourSGallery, FrameSGallery, LayerSGallery, LibClipartSGallery, LibFillsSGallery, LineGallery, NameGallery, and FontsSGallery. Definition at line 2731 of file sgallery.cpp. { return(FALSE); }

void SuperGallery::CalcVirtualSize (  ReDrawInfoType *  DlgRedrawInfo, DocRect *  VirtualSize, INT32 *  PixelSize )  [protected]

Shared internal code to determine the virtual coordinate space of the region of the display list which is visible n screen. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: DlgRedrawInfo  - The kernel-rendered-dilaogue info struct passed into your [INPUTS] redraw or mouse handler. VirtualSize  - Returned containing the virtual coordinate rectangle for [OUTPUTS] the visible portion of the gallery displaylist. PixelSize - Returned containing the size of an output device pixel, as it maps into millipoints in the virtual space. See also: SuperGallery::RenderListBox Definition at line 1344 of file sgallery.cpp. { ERROR3IF(DlgRedrawInfo == NULL || VirtualSize == NULL || PixelSize == NULL, "SuperGallery::CalcVirtualSize - NULL parameters are illegal"); // Calculate the size of a screen display pixel in terms of virtual space coords *PixelSize = 72000 / DlgRedrawInfo->Dpi; // Create our viewport. We specify 0,0 at the top left corner of the window, with // x increasing to the right, and y increasing upwards. This, all y coordinates // within the redrawn area are actually negative. // Coordinates are in millipoints, and no scaling is desired (i.e. if we say 20pt, // we mean 20pt on screen). *VirtualSize = DocRect(0, -DlgRedrawInfo->dy, DlgRedrawInfo->dx, 0); // Now, shift the coordinate space down to the correct scroll offset position, so // we map the correct part of the window extent into the visible portion of the window if (DisplayTree != NULL) VirtualSize->Translate(0, -DisplayTree->GetScrollOffset()); }

BOOL SuperGallery::CanSearchKeywords (  void   )  [virtual]

Used to determine if this type of gallery supports keyword searching. By default galleries do not. Override and return TRUE if you do. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 Returns: FALSE Reimplemented in LibraryGallery, LibClipartSGallery, LibFillsSGallery, and FontsSGallery. Definition at line 3306 of file sgallery.cpp. { return(FALSE); }

void SuperGallery::CloseOwnedDialogs (  void   )  [protected, virtual]

Checks and closes the various dialogs which can be owned by galleries. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 05/03/97 See also: SuperGallery::SetVisibility, SuperGallery::~SuperGallery() SuperGallery::Message(Msg* Message) Definition at line 805 of file sgallery.cpp. { if (CurrentOptionsDlg != NULL) { CurrentOptionsDlg->Close(); CurrentOptionsDlg->End(); } if (CurrentSortDlg != NULL) { CurrentSortDlg->Close(); CurrentSortDlg->End(); } if (CurrentSearchDlg != NULL) { CurrentSearchDlg->Close(); CurrentSearchDlg->End(); } PORTNOTE("dialogs", "Removed CurrentLinePropertiesDlg from SuperGallery::CloseOwnedDialogs(void)") #ifndef EXCLUDE_FROM_XARALX if (CurrentLinePropertiesDlg != NULL) { CurrentLinePropertiesDlg->Close(); CurrentLinePropertiesDlg->End(); } #endif }

BOOL SuperGallery::ConvertFromVirtualCoords (  SGMiscInfo *  MiscInfo, DocRect * <