BitmapSGallery Class Reference

The Bitmap SuperGallery class. More...

#include <sgbitmap.h>

Inheritance diagram for BitmapSGallery:

List of all members.

Public Member Functions
	BitmapSGallery ()
	BitmapSGallery default constructor.
	~BitmapSGallery ()
	BitmapSGallery destructor.
virtual MsgResult	Message (Msg *Message)
	A standard message handler, really.
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:.
virtual SGDisplayItem *	CopyDisplayItem (SGDisplayItem *SourceItem, SGDisplayGroup *DestGroup, SGDisplayItem *TargetPosition=NULL)
	"Copies" the existing node in the tree in an appropriate fashion.
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.
virtual BOOL	InitMenuCommands (void)
	Initialises any menu commands that this gallery needs.
virtual BOOL	BuildCommandMenu (GalleryContextMenu *TheMenu, SGMenuID MenuID)
	To build a menu of commands to be popped up over the gallery.
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.
BOOL	HasDelayValueChanged ()
BOOL	IsJPEG (KernelBitmap **pList, UINT32 ListSize, BmpDlgParam *Param, INT32 *pBytes)
	To determine whether an imported bitmap is a compressed JPEG.
Static Public Attributes
static BOOL	IgnoreBmpListChange = FALSE
Protected Member Functions
virtual BOOL	PreCreate (void)
	The BitmapSGallery PreCreate handler. This overrides the base class PreCreate function. It is called at the very end of the SuperGallery::Create method, after the window has been created.
virtual BOOL	ApplyAction (SGActionType Action)
	Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc).
virtual void	HandleDragStart (DragMessage *DragMsg)
	Checks a DragMessage to see if it is a bitmap drag. If it is, then it creates a drag target for this gallerys listbox.
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	DoShadeGallery (BOOL ShadeIt)
	Called by the base class whenever the shaded status of the gallery is changed, to allow derived galleries to shade/unshade any extra controls that they provide in the window. ONLY called if the gallery is actually open/visible.
void	CreateNewSubtree (Document *ParentDoc, SGDisplayGroup *ExistingGroup=NULL)
	Internal call. This takes the KernelBitmap list of the given document and creates a DisplayTree subtree from it. This subtree is then added to the DisplayTree. Note that this does not force a redraw of the list - after making this call, you should also call ForceRedrawOfList.
KernelBitmap *	GetSelectedBitmap ()
BOOL	GetSelectedBitmaps (KernelBitmap ***pOutputArray, UINT32 *pOutputCount)
	Generates a list of all the selected bitmaps in the gallery. Note that the generated array becomes the callers responsibility if TRUE is returned; the caller must CCFree it.
BOOL	DeleteSelection ()
	Deletes the selected bitmaps.
KernelBitmap *	CheckTextureBitmap (KernelBitmap *pBitmap)
	Checks a bitmap to see if can be applied as a texture, and gives the option to create a grey level version if not.
BOOL	FindCentreInsertionPosition (Spread **Spread, DocCoord *Position)
	Finds the centre insertion position for clipboard objects.
void	SetSelectionFromDocument (BOOL AlwaysScroll=FALSE)
	Sets the bitmap gallery listbox selection state based upon the currently selected object(s) in the document.
BOOL	GetBmpInfo (BmpDlgParam *Param)
	Retrieves inforamtion from Bitmaps selected in the Bitmaps Gallery.
BOOL	SetBmpInfo (BmpDlgParam *Param)
	Stores info, retrieved from the Bitmap Properties Dialog, in an OILBitmap.

---

Detailed Description

The Bitmap SuperGallery class.

Author:

Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> (Based on template code by Jason)

Date:

27/1/95 (Based on the Colour SGallery code)

Notes: SuperGalleries are specced in a number of docs including specs.doc ("super" gallery extensions) specs.doc (gallery basic ui) There is also howtouse.doc which describes creating a supergallery

See also:

SuperGallery; SGDisplayBitmap

Definition at line 296 of file sgbitmap.h.

---

Constructor & Destructor Documentation

BitmapSGallery::BitmapSGallery (   )

BitmapSGallery default constructor. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Definition at line 1635 of file sgbitmap.cpp. { DlgResID = _R(IDD_BITMAPSGALLERY); // WEBSTER - markn 9/12/96 // Default gallery size #ifdef WEBSTER CSize Size(333, 256); SetGallerySize(Size); #endif }

BitmapSGallery::~BitmapSGallery (   )

BitmapSGallery destructor. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Definition at line 1659 of file sgbitmap.cpp. { }

---

Member Function Documentation

BOOL BitmapSGallery::ApplyAction (  SGActionType  Action  )  [protected, virtual]

Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc). Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: Action  - Indicates what action to apply [INPUTS] Returns: TRUE to indicate successful handling of the action, or FALSE to indicate failure (NOTE that this is not necessarily an error, but may simply be that we don't support the given action. e.g. if we don't handle APPLYADJUST, we'll be called again with a normal APPLY call) See also: SGActionType Reimplemented from SuperGallery. Definition at line 2002 of file sgbitmap.cpp. { // No display tree? Better forget about it then! if (DisplayTree == NULL) return(FALSE); // Determine useful info - this is usually needed for most actions, so always get it Document *SelectedDoc = Document::GetSelected(); /*SGDisplayGroup *DocumentGroup =*/ DisplayTree->FindSubtree(this, SelectedDoc, NULL); SGDisplayKernelBitmap *FirstSelected = NULL; // Lets see if any of our Items are selected Document *ParentDoc = (Document *) GetApplication()->Documents.GetHead(); while (ParentDoc != NULL) { SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, ParentDoc, NULL); if (DocGroup != NULL) FirstSelected = (SGDisplayKernelBitmap *) DocGroup->FindNextSelectedItem(NULL); if (FirstSelected) break; ParentDoc = (Document *) GetApplication()->Documents.GetNext(ParentDoc); } KernelBitmap *SelectedBitmap = NULL; if (FirstSelected != NULL) { SelectedBitmap = FirstSelected->GetDisplayedKernelBitmap(); } // Now, process the action TO DO! - see Colour gallery for examples switch(Action) { case SGACTION_APPLY: if (SelectedBitmap != NULL) { // Fill colour selected so create a fill colour attribute NodeAttribute *Attrib = new AttrBitmapColourFill; if (Attrib == NULL) return(FALSE); ((AttrBitmapColourFill *)Attrib)->AttachBitmap(SelectedBitmap); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); } break; case SGACTION_DELETE: return DeleteSelection(); break; case SGACTION_SETOPTIONS: // Set values in the options dialogue as it is opened if (CurrentOptionsDlg == NULL) return(FALSE); // Display Modes CurrentOptionsDlg->AddDisplayModeName(_R(IDS_GALLERYDM_FULLINFO)); // 0 break; case SGACTION_DISPLAYMODECHANGED: if (DisplayMode < 0 || DisplayMode > 1) DisplayMode = 0; break; default: // Unknown/unsupported command (e.g. CREATE, APPLYADJUST), so we failed to do it return(FALSE); } return(TRUE); }

BOOL BitmapSGallery::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: Override this method to stop the default menus being built Reimplemented from SuperGallery. Definition at line 3122 of file sgbitmap.cpp. { BOOL ok = TRUE; if (MenuID == SGMENU_OPTIONS) { // Options menu ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Find); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Sort); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Properties); } else { // Over-list menu ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Insert); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Fill); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Transp,TRUE); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Delete); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Save); //#if _DEBUG ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Preview); //#endif // WEBSTER-ranbirr-22/11/96 #ifndef WEBSTER ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_XPE_Edit); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Trace); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Effects); #endif //webster #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present // Need to say which document and more importantly which bitmap we // want the menu to apply to. KernelBitmap * pSelectedBitmap = GetSelectedBitmap(); // Now find out what the selected group is, which will be the document group SGDisplayNode * FirstSelected = DisplayTree->FindNextSelectedItem(NULL); Document *pDocument = NULL; if (FirstSelected == NULL) pDocument = Document::GetSelected(); else pDocument = ((SGDisplayGroup *) FirstSelected->GetParent())->GetParentDocument(); ERROR3IF(pDocument == NULL, "No parent document?!"); // Add plug-in ("Special Effects" is the only one still used since Live Effects) to the // main menu, not a submenu. Fixes #11376 // Well, in fact we will ask the PlugInsContextMenu to do it for us! ok = ok && PlugInsContextMenu::BuildMenu(pSelectedBitmap, pDocument, TheMenu, NULL, TRUE); #endif // WEBSTER-ranbirr-22/11/96 ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Props,TRUE); // This is the set background menu option ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_SetBackground, TRUE); // With separator // Add the fold and unfold group items SGDisplayGroup *TheGroup = FindCommandGroup(); // Fold or unfold as appropriate if (TheGroup == NULL || !TheGroup->Flags.Folded) ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_FoldGroup); else ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_UnfoldGroup); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_PrevGroup); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_NextGroup); } return(ok); }

KernelBitmap * BitmapSGallery::CheckTextureBitmap (  KernelBitmap *  pBitmap  )  [protected]

Checks a bitmap to see if can be applied as a texture, and gives the option to create a grey level version if not. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/95 Definition at line 2184 of file sgbitmap.cpp. { return NodeBitmap::CheckGreyscaleBitmap(pBitmap, _R(IDS_BMPGAL_MAKEGREY), _R(IDS_BMPGAL_DOGREY)); /* if (!BfxALU::IsGreyscaleBitmap(pBitmap)) // Should do proper Grey Level check here { INT32 ButtonPressed = 1; ButtonPressed = AskQuestion(_R(IDS_BMPGAL_MAKEGREY), _R(IDS_BMPGAL_DOGREY), _R(IDS_CANCEL), 0, 0, 1, 1); // CANCEL=default, CANCEL=cancel if (ButtonPressed == 2) // Apply was cancelled - return NULL return NULL; if (ButtonPressed == 1) { // Make a new grey level version of the bitmap, and apply that instead ABFXMakeGreyscale GSBfx; KernelBitmap* pNewBitmap = GSBfx.GetProcessedBitmap(pBitmap); if (pNewBitmap == NULL) { InformError(); return NULL; } // We need to check the Document bitmap list to see if // there is already a grey-level version. BitmapList* pBmpList = pBitmap->GetParentBitmapList(); ListItem* pItem = pBmpList->GetHead(); while (pItem != NULL) { KernelBitmap* pBmp = (KernelBitmap*)pItem; if (pBmp->ActualBitmap != pNewBitmap->ActualBitmap && *pBmp->ActualBitmap == *pNewBitmap->ActualBitmap) { pNewBitmap->ActualBitmap->Detach(); delete pNewBitmap; return pBmp; } pItem = pBmpList->GetNext(pItem); } // There is no grey level version in this document, // but there might be one in another document somewhere // so we'll have a look in the global list. GlobalBitmapList* pGlobalBmpList = GetApplication()->GetGlobalBitmapList(); pItem = pGlobalBmpList->GetHead(); while (pItem != NULL) { OILBitmap* pBmp = (OILBitmap*)pItem; if (pBmp != pNewBitmap->ActualBitmap && *pBmp == *pNewBitmap->ActualBitmap) { pNewBitmap->ActualBitmap->Detach(); delete pNewBitmap; return new KernelBitmap(pBmp); } pItem = pGlobalBmpList->GetNext(pItem); } String_256 NewName = pBitmap->ActualBitmap->GetName(); NewName += " (Greyscale)"; pNewBitmap->ActualBitmap->SetName(NewName); return pNewBitmap; } } return pBitmap; */ }

SGDisplayItem * BitmapSGallery::CopyDisplayItem (  SGDisplayItem *  SourceItem, SGDisplayGroup *  DestGroup, SGDisplayItem *  TargetPosition = NULL )  [virtual]

"Copies" the existing node in the tree in an appropriate fashion. Parameters: SourceItem  - The item to copy elsewhere in the tree (see below) [INPUTS] DestGroup - The group into which the item should be inserted TargetPosition - NULL (to add the copied item to the end of the sibling list), or points to an item BEFORE which the copied item will be inserted. Returns: NULL (failed) or a pointer to the new (copied) display item This method is normally called when a gallery-organising drag completes, and it is discovered that the dragged item(s) have been dragged to a different display group. Notes: This method should be overridden by derived galleries to provide appropriate behaviour (some galleries (e.g colour) will copy the real-item that the given display-item references to the new group (document), while other galleries (layer) may just move the item after all). Note the handy InsertCopiedItem and MoveBefore/After methods which are available to take all of the hard work out of copying/moving items! See the body of this method in the source code for example pseudocode. For real code, see the Colour Gallery (sgcolour.cpp) See also: SuperGallery::InsertCopiedItem; SGDisplayItem::MoveBefore; SGDisplayItem::MoveAfter; SGColour::CopyDisplayItem Example psuedocode **** Find the real item (Thingy) to be moved/copied Thingy *ThingyToCopy = ((SGDisplayThingy *)SourceItem)->GetDisplayedThingy(); if (we really want to copy the items, rather than just move them) { Just copy the items... First, copy the real-item associated with the display item ThingyType *NewThingy = new ThingyType(ThingyToCopy); Add the copied item to your 'real item' list or whatever. DocThingyList = DestGroup->GetParentDocument()->FindThingyList(); if (TargetPosition == NULL) DocThingyList->AddTail(NewThingy); else { Thingy *TargetPos = ((SGDisplayThingy *)TargetPosition)->GetDisplayedThingy(); if (TargetPos == NULL) DocThingyList->AddTail(NewThingy); else DocThingyList->InsertBefore(TargetPos, NewThingy); } Now, create a new display item for the copied Thingy, and call the base class helper method to insert it as appropriate. SGDisplayThingy *NewThingyDisplayItem = new SGDisplayThingy(NewThingy); if (NewThingyDisplayItem != NULL) SuperGallery::InsertCopiedItem(NewThingyDisplayItem, DestGroup, TargetPosition); return(NewThingyDisplayItem); } else { Just move the items This code will be much the same as the above, but instead of copying the real-item, you will have to move it as appropriate. Instead of making a new DisplayItem to pass on to InsertCopiedItem, simply delink it from the DisplayTree, and then pass it to InsertCopiedItem as follows: SourceItem->RemoveFromTree(); // Delink from current displaytree position SuperGallery::InsertCopiedItem(SourceItem, DestGroup, TargetPosition); return(SourceItem); } Reimplemented from SuperGallery. Definition at line 1889 of file sgbitmap.cpp. { ERROR3IF(SourceItem == NULL || DestGroup == NULL, "Illegal NULL param"); return(NULL); /**** Example psuedocode **** // Find the real item (Thingy) to be moved/copied Thingy *ThingyToCopy = ((SGDisplayThingy *)SourceItem)->GetDisplayedThingy(); if (we really want to copy the items, rather than just move them) { // Just copy the items... // First, copy the real-item associated with the display item ThingyType *NewThingy = new ThingyType(ThingyToCopy); // Add the copied item to your 'real item' list or whatever. DocThingyList = DestGroup->GetParentDocument()->FindThingyList(); if (TargetPosition == NULL) DocThingyList->AddTail(NewThingy); else { Thingy *TargetPos = ((SGDisplayThingy *)TargetPosition)->GetDisplayedThingy(); if (TargetPos == NULL) DocThingyList->AddTail(NewThingy); else DocThingyList->InsertBefore(TargetPos, NewThingy); } // Now, create a new display item for the copied Thingy, and call the // base class helper method to insert it as appropriate. SGDisplayThingy *NewThingyDisplayItem = new SGDisplayThingy(NewThingy); if (NewThingyDisplayItem != NULL) SuperGallery::InsertCopiedItem(NewThingyDisplayItem, DestGroup, TargetPosition); return(NewThingyDisplayItem); } else { // Just move the items // This code will be much the same as the above, but instead of copying the // real-item, you will have to move it as appropriate. Instead of making // a new DisplayItem to pass on to InsertCopiedItem, simply delink it from the // DisplayTree, and then pass it to InsertCopiedItem as follows: SourceItem->RemoveFromTree(); // Delink from current displaytree position SuperGallery::InsertCopiedItem(SourceItem, DestGroup, TargetPosition); return(SourceItem); } ****/ }

void BitmapSGallery::CreateNewSubtree (  Document *  ParentDoc, SGDisplayGroup *  ExistingGroup = NULL )  [protected]

Internal call. This takes the KernelBitmap list of the given document and creates a DisplayTree subtree from it. This subtree is then added to the DisplayTree. Note that this does not force a redraw of the list - after making this call, you should also call ForceRedrawOfList. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: ParentDoc  - The document to create a display subtree for [INPUTS] ExistingGroup - NULL (creates a new group for this document), or a pointer to the existing group-node for this document (in which case it clears all displayitems from the group and rebuilds it in place - this stops the display group moving around the tree at random!) Notes: Passing in a NULL parent document pointer results in an ERROR3 - the function returns without doing anything in retail builds See also: SuperGallery::ForceRedrawOfList Definition at line 1690 of file sgbitmap.cpp. { ERROR3IF(ParentDoc == NULL, "BitmapSGallery::CreateNewSubtree - NULL parameter passed in"); if (ParentDoc == NULL || DisplayTree == NULL) return; SGDisplayGroup *DisplayDocument; SGDisplayKernelBitmap *DisplayKernelBitmap; if (ExistingGroup != NULL) { ERROR3IF(ExistingGroup->GetParentDocument() != ParentDoc, "This group is not for that document! What's going down, dude?"); DisplayDocument = ExistingGroup; // Use existing group DisplayDocument->DestroySubtree(FALSE); // Wipe any existing KernelBitmap display items } else { DisplayDocument = new SGDisplayGroup(this, ParentDoc,NULL); // Create new Group if (DisplayDocument == NULL) // Total failure - abort return; DisplayDocument->Flags.CanSelect = TRUE; // Groups are selectable DisplayTree->AddItem(DisplayDocument); // Add new group to tree } // Lets generate some SGDisplayKernelBitmaps to be displayed ... // Get the bitmap list BitmapList* Bitmaps = ParentDoc->GetBitmapList(); // now iterate though the list, creating display items for each bitmap KernelBitmap* Ptr = (KernelBitmap*)Bitmaps->GetHead(); while (Ptr != NULL) { // Ignore bitmaps that have been deleted if (!Ptr->GetActualBitmap()->IsHiddenInGallery()) { DisplayKernelBitmap = new SGDisplayKernelBitmap(Ptr); if (DisplayKernelBitmap != NULL) DisplayDocument->AddItem(DisplayKernelBitmap); } Ptr = (KernelBitmap*)Bitmaps->GetNext(Ptr); } }

RenderRegion * BitmapSGallery::CreateRenderRegion (  DocRect *  VirtualSize, ReDrawInfoType *  DlgRedrawInfo )  [protected, virtual]

An overridable veneer to the DialogOp CreateOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 If you override this, you MUST also override DestroyRenderRegion! See also: SuperGallery::DestroyRenderRegion Reimplemented from SuperGallery. Definition at line 2973 of file sgbitmap.cpp. { return(CreateOSRenderRegion(VirtualSize, DlgRedrawInfo)); }

BOOL BitmapSGallery::DeleteSelection (   )  [protected]

Deletes the selected bitmaps. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/95 Definition at line 2084 of file sgbitmap.cpp. { INT32 ButtonPressed = 2; ButtonPressed = AskQuestion(_R(IDS_BMPGAL_BMPINUSE), _R(IDS_BMPGAL_KILL), _R(IDS_CANCEL), 0, 0, 2, 2); // CANCEL=default, CANCEL=cancel if (ButtonPressed == 2) // Delete was cancelled - return FALSE return(FALSE); if (ButtonPressed == 1) // Force-delete all items, so go ahead and delete { BOOL DeletedBitmaps = FALSE; IgnoreBmpListChange = TRUE; GlobalBitmapList* pGlobalBmpList = GetApplication()->GetGlobalBitmapList(); Document *ParentDoc = (Document *) GetApplication()->Documents.GetHead(); while (ParentDoc != NULL) { // Get the bitmap list BitmapList* pDocBitmaps = ParentDoc->GetBitmapList(); SGDisplayKernelBitmap* Selected = NULL; SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, ParentDoc, NULL); if (DocGroup != NULL) Selected = (SGDisplayKernelBitmap *) DocGroup->FindNextSelectedItem(NULL); while (Selected != NULL) { KernelBitmap* SelectedBitmap = Selected->GetDisplayedKernelBitmap(); // Get the next one before we delete this one Selected = (SGDisplayKernelBitmap*)DocGroup->FindNextSelectedItem(Selected); // Is this Kernel bitmap pointer still valid ? if (!pDocBitmaps->IsEmpty() && pDocBitmaps->FindPosition(SelectedBitmap) != NOT_IN_LIST) { if (SelectedBitmap->ActualBitmap != OILBitmap::Default) { // Is this Actual bitmap pointer still valid ? if (!pGlobalBmpList->IsEmpty() && pGlobalBmpList->FindPosition(SelectedBitmap->ActualBitmap) != NOT_IN_LIST) { OpDeleteBitmap* pOp = new OpDeleteBitmap(); if (pOp) { pOp->DoDelete(SelectedBitmap->ActualBitmap); DeletedBitmaps = TRUE; } } } else { // Shouldn't we be using an error from the resource file here?? Error::SetError(0, _T("You cannot delete the Default Bitmap"),0); InformError(); } } } ParentDoc = (Document *) GetApplication()->Documents.GetNext(ParentDoc); } IgnoreBmpListChange = FALSE; if (DeletedBitmaps) { Document *ParentDoc = (Document *) GetApplication()->Documents.GetHead(); while (ParentDoc != NULL) { SGDisplayNode *Ptr = DisplayTree->FindSubtree(this, ParentDoc, NULL); CreateNewSubtree(ParentDoc, (SGDisplayGroup *) Ptr); ParentDoc = (Document *) GetApplication()->Documents.GetNext(ParentDoc); } // And force a redraw of the entire list ForceRedrawOfList(); SelectionHasChanged(); } } return TRUE; }

void BitmapSGallery::DestroyRenderRegion (  RenderRegion *  pRender  )  [protected, virtual]

An overridable veneer to the DialogOp DestroyOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 If you override this, you MUST also override CreateRenderRegion! See also: SuperGallery::CreateRenderRegion Reimplemented from SuperGallery. Definition at line 2997 of file sgbitmap.cpp. { DestroyOSRenderRegion(pRender); }

void BitmapSGallery::DoCommand (  StringBase *  CommandID  )  [virtual]

To apply a given command when it is chosen from the menu. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: CommandID  - The String ID of the command [INPUTS] Notes: Override this method to provide handling for your special commands. Call the base class if you don't recognise the command, so that it can handle standard commands. The base class handles all of these (maybe more - see the base class help) Properties, Sort, Find; New, Edit, Delete, Redefine; (it calls ApplyAction as appropriate) NextGroup, PrevGroup, FoldGroup, UnfoldGroup; Reimplemented from SuperGallery. Definition at line 3316 of file sgbitmap.cpp. { if (*CommandID == SGCmd_Insert) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_CREATE)); Message(&Bob); } else if (*CommandID == SGCmd_Fill) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_FILL)); Message(&Bob); } // WEBSTER-ranbirr-22/11/96 #ifndef WEBSTER else if (*CommandID == SGCmd_Transp) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_TEXTURE)); Message(&Bob); } #endif //webster else if (*CommandID == SGCmd_Save) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_SAVE)); Message(&Bob); } else if (*CommandID == SGCmd_Preview) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_PREVIEW)); Message(&Bob); } else if (*CommandID == SGCmd_XPE_Edit) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_XPE_EDIT)); Message(&Bob); } // WEBSTER-ranbirr-22/11/96 #ifndef WEBSTER else if (*CommandID == SGCmd_Trace) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_TRACE)); Message(&Bob); } /* else if (*CommandID == SGCmd_Effects) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_EFFECTS)); Message(&Bob); } */ #endif //webster #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present else if (*CommandID == SGCmd_PlugIns) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_PLUGINS)); Message(&Bob); } #endif else if (*CommandID == SGCmd_SetBackground) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_BACKGROUND)); Message(&Bob); } // WEBSTER-ranbirr-22/11/96 else if (*CommandID == SGCmd_Props) { // Fake a button click message to ourself DialogMsg Bob(WindowID, DIM_LFT_BN_CLICKED, _R(IDC_BMPGAL_PROPS)); Message(&Bob); } else SuperGallery::DoCommand(CommandID); // Unknown command- pass to the base class }

void BitmapSGallery::DoShadeGallery (  BOOL  ShadeIt  )  [protected, virtual]

Called by the base class whenever the shaded status of the gallery is changed, to allow derived galleries to shade/unshade any extra controls that they provide in the window. ONLY called if the gallery is actually open/visible. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/7/97 Parameters: ShadeIt  - TRUE if the gallery is being shaded [INPUTS] FALSE if the gallery is being unshaded Notes: Need not be overridden - the default action is to do nothing extra to the normal shade/unshade operation. See also: Gallery::ShadeGallery; Gallery::UnshadeGallery Reimplemented from SuperGallery. Definition at line 2364 of file sgbitmap.cpp. { // Shade any non-standard buttons that we have on the gallery EnableGadget(_R(IDC_BMPGAL_SAVE), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_PROPS), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_BACKGROUND), !ShadeIt); #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present EnableGadget(_R(IDC_BMPGAL_PLUGINS), !ShadeIt); #endif //#if _DEBUG EnableGadget(_R(IDC_BMPGAL_PREVIEW), !ShadeIt); //#endif EnableGadget(_R(IDC_BMPGAL_CREATE), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_FILL), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_TEXTURE), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_TRACE), !ShadeIt); EnableGadget(_R(IDC_BMPGAL_XPE_EDIT), !ShadeIt); //EnableGadget(_R(IDC_BMPGAL_EFFECTS), !ShadeIt); }

BOOL BitmapSGallery::FindCentreInsertionPosition (  Spread **  Spread, DocCoord *  Position )  [protected]

Finds the centre insertion position for clipboard objects. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/94 Parameters: -  [INPUTS] Spread,:  The spread to place the clipboard objects on [OUTPUTS] Position:The centre of the view (Spread coords) Returns: - Errors: - Scope: private See also: - Definition at line 2888 of file sgbitmap.cpp. { // --------------------------------------------------------------------------------- // Find out which spread is in the centre of the view // this is the spread that the pasted objects will be placed on // Obtain the current DocView DocView* CurDocView = DocView::GetCurrent(); ENSURE(CurDocView != NULL, "The current DocView is NULL"); if (CurDocView == NULL) { return FALSE; // No DocView } // Get the view rect WorkRect WrkViewRect = CurDocView->GetViewRect(); if (WrkViewRect.IsEmpty() || (!WrkViewRect.IsValid()) ) { return FALSE; // Defensive } // Determine the centre of the view WorkCoord WrkCentreOfView; WrkCentreOfView.x = WrkViewRect.lo.x + (WrkViewRect.Width()/2); WrkCentreOfView.y = WrkViewRect.lo.y + (WrkViewRect.Height()/2); // FindEnclosing spread requires an OilCoord OilCoord OilCentreOfView = WrkCentreOfView.ToOil(CurDocView->GetScrollOffsets()); // Find out which spread to insert the pasteboard objects onto (*Spread) = CurDocView->FindEnclosingSpread(OilCentreOfView); if ((*Spread) == NULL) { // There is no spread return FALSE; } // Phew // --------------------------------------------------------------------------------- // Now lets find the spread coordinate of the centre of the view DocRect DocViewRect = CurDocView->GetDocViewRect(*Spread); if ( DocViewRect.IsEmpty() || (!DocViewRect.IsValid()) ) { return FALSE; // Defensive } ENSURE( ( (!DocViewRect.IsEmpty()) && DocViewRect.IsValid()), "DocViewRect is invalid" ); // Find the centre of the DocViewRect DocCoord DocCentreOfView; DocCentreOfView.x = DocViewRect.lo.x + (DocViewRect.Width()/2); DocCentreOfView.y = DocViewRect.lo.y + (DocViewRect.Height()/2); // Now convert from DocCoords to spread coords (*Spread)->DocCoordToSpreadCoord(&DocCentreOfView); // Finally, fill in the return value *Position = DocCentreOfView; return TRUE; }

BOOL BitmapSGallery::GetBmpInfo (  BmpDlgParam *  Param  )  [protected]

Retrieves inforamtion from Bitmaps selected in the Bitmaps Gallery. BOOL BitmapSGallery::GetBmpInfo(BmpDlgPara Param) Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/96 Parameters: Param  - Allows the transfer of data to and from the bitmap poperties dialog. [INPUTS] -  [OUTPUTS] Returns: TRUE if Successful, else FALSE. See also: - Definition at line 3634 of file sgbitmap.cpp. { ERROR2IF(Param == NULL,FALSE,"Param is NULL"); UINT32 ListSize = 0; KernelBitmap** pList = NULL; // BOOL Done = FALSE; if (!GetSelectedBitmaps(&pList, &ListSize)) return FALSE; //Pass these values to our Param class, for use in the dialog code Param->SetBitmapList(pList); Param->SetListSize(ListSize); if (ListSize>1) { Param->SetMany(TRUE); } String_256* BitmapCols = new String_256[ListSize]; String_256* Width = new String_256[ListSize]; String_256* Height = new String_256[ListSize]; String_256* BitmapFormat = new String_256[ListSize]; UINT32* Delay = new UINT32[ListSize]; BOOL* Interpolation = new BOOL[ListSize]; GIFDisposalMethod* DisposalMethod = new GIFDisposalMethod[ListSize]; UINT32* TranspType = new UINT32[ListSize]; if ( !BitmapCols || !Width || !Height || !BitmapFormat || !Delay || !DisposalMethod || !TranspType ) return FALSE; UINT32 i=0; // Loop index UINT32 TempListSize=ListSize; // Keep a record of our list size. INT32 Bytes =0; // Holds the bitmap Memory info. while (ListSize>0) { ListSize--; KernelBitmap* pKernelBitmap = pList[ListSize]; if (pKernelBitmap == NULL) return FALSE; OILBitmap* pOILBitmap = pKernelBitmap->GetActualBitmap(); if (pOILBitmap == NULL) return FALSE; PORTNOTE("other", "Removed XPE hooks") #ifndef EXCLUDE_FROM_XARALX IXMLDOMDocumentPtr pEditsList = NULL; KernelBitmap* pMaster = NULL; pKernelBitmap->GetXPEInfo(pMaster, pEditsList); BOOL bIsXPE = (pMaster!=NULL && pEditsList!=NULL); #else BOOL bIsXPE = FALSE; #endif // Get the bitmap name details. Param->SetBitmapName(pOILBitmap->GetName()); // Is this bitmap a compressed JPEG? IsJPEG(pList,ListSize,Param,&Bytes); // Set the format field - JPEG\Bitmap. if(Param->GetIsJPEG()) { Param->SetBitmapFormat(_R(IDS_FORMAT_JPEG)); } else if (bIsXPE) { Param->SetBitmapFormat(_R(IDS_FORMAT_XPE)); } else { Param->SetBitmapFormat(_R(IDS_FORMAT_BITMAP)); } // Get the Delay for the selected bitmap. Param->SetAnimDelay(pKernelBitmap->GetDelay()); // Get the 'smooth when scaled up?' setting Param->SetInterpolation(pKernelBitmap->GetInterpolation()); // Now find how many colours it has? INT32 bpp = pKernelBitmap->GetBPP(); Param->SetBitmapTranspType(_R(IDS_BITMAPTRANSPTYPE_NONE)); UINT32 ttype = TT_NoTranspType; if (bpp <= 8) { // Check to see if this is a masked bitmap. INT32 Index=0; if(pKernelBitmap->GetTransparencyIndex(&Index)) { Param->SetBitmapTranspType(_R(IDS_BITMAPTRANSPTYPE_MASKED)); ttype = TT_Mix; } } else if (bpp<32) { Param->SetBitmapTranspType(_R(IDS_BITMAPTRANSPTYPE_NONE)); } else { Param->SetBitmapTranspType(_R(IDS_BITMAPTRANSPTYPE_ALPHA)); ttype = TT_StainGlass; } switch (bpp) { case 1: Param->SetBitmapCols(_R(IDS_SGBITMAP_MONOCHROME)); // "Monochrome"; break; case 2: Param->SetBitmapCols(_R(IDS_SGBITMAP_4COLOURS)); // "4 colours"; break; case 4: Param->SetBitmapCols(_R(IDS_SGBITMAP_16COLOURS)); // "16 colours"; break; case 8: Param->SetBitmapCols(_R(IDS_SGBITMAP_256COLOURS)); // "256 colours"; break; case 16: Param->SetBitmapCols(_R(IDS_SGBITMAP_65COLOURS)); // "65K colours"; break; case 24: Param->SetBitmapCols(_R(IDS_SGBITMAP_MILLIONS_COLOURS)); // "Millions of colours"; break; case 32: Param->SetBitmapCols(_R(IDS_SGBITMAP_32_BIT)); // "Millions of colours"; break; default: Param->SetBitmapCols (""); break; } // Get the bitmap Dimensions. BitmapInfo Info; if(pOILBitmap->GetInfo(&Info)) { // Get its pixel Width and Height. Convert::LongToString(Info.PixelWidth, &Param->GetBitmapWidth()); Convert::LongToString(Info.PixelHeight, &Param->GetBitmapHeight()); // If this bitmap is not have a compressed JPEG, then calculate the memeory used by the bitmap. if(!Param->GetIsJPEG() && !bIsXPE) { // Work out how much memory it is using. Bytes += (Info.PixelWidth * Info.PixelHeight * bpp)/8; } } // Get the bitmap Animation Restore details. Param->SetRestoreType(pOILBitmap->GetAnimationRestoreType()); // Keep a record of the details. BitmapCols[i] = Param->GetBitmapCols(); Width[i] = Param->GetBitmapWidth(); Height[i] = Param->GetBitmapHeight(); BitmapFormat[i] = Param->GetBitmapFormat(); Delay[i] = Param->GetAnimDelay(); Interpolation[i]= Param->GetInterpolation(); DisposalMethod[i] = Param->GetRestoreType(); TranspType[i] = ttype; i++; } // ok, we have no more bitmaps\JPEGS, so convert the memory (Bytes), into a string. Convert::BytesToString(&Param->GetMemoryUsed(),(INT32)Bytes); // Compare the bitmap colors,Dimensions,Transparency and Format fields and set their flags appropriately. // i.e. If for any one field, all the bitmaps are not the same, then we output "-", instead of the details. // Only do this if more than one bitmap is selected.. if (TempListSize>1) { for(i=0; i<TempListSize; i++) { for(UINT32 e=i+1; e<TempListSize; e++) { if (BitmapCols[i] != BitmapCols[e]) Param->SetSameColors(FALSE); if (Width[i] != Width[e]) Param->SetSameDimensions(FALSE); if (Height[i] != Height[e]) Param->SetSameDimensions(FALSE); if (BitmapFormat[i] != BitmapFormat[e]) Param->SetSameFormat(FALSE); if (DisposalMethod[i] != DisposalMethod[e]) Param->SetSameRestoreType(FALSE); if (Delay[i] != Delay[e]) Param->SetAreDelayValuesSame(FALSE); if (Interpolation[i] != Interpolation[e]) Param->SetAreInterpolationValuesSame(FALSE); if (TranspType[i] != TranspType[e]) Param->SetSameTranspType(FALSE); } } } if (pList != NULL) CCFree(pList); delete [] BitmapCols; delete [] Width; delete [] Height; delete [] DisposalMethod; delete [] BitmapFormat; delete [] Delay; delete [] Interpolation; delete [] TranspType; return TRUE; }

OpState BitmapSGallery::GetCommandState (  StringBase *  CommandID, String_256 *  ShadeReason )  [virtual]

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). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: CommandID  - TheString ID of the command [INPUTS] ShadeReason  - If you return (OpState.Greyed == TRUE) then this should be filled [OUTPUTS] in with the reason that the item is shaded/greyed. Returns: An OpState indicating the current menu item state. Notes: Override this method to provide state info for your special commands Call the base class for unknown commands to allow it to handle them for you The base class handles all of these (maybe more - see the base class help) Properties, Sort, Find; New, Edit, Delete, Redefine; NextGroup, PrevGroup, FoldGroup, UnfoldGroup; Reimplemented from SuperGallery. Definition at line 3220 of file sgbitmap.cpp. { OpState State; if (*CommandID == SGCmd_Properties || *CommandID == SGCmd_Sort) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NOTSUPPORTED)); } else if (*CommandID == SGCmd_Delete) { INT32 Count = GetSelectedItemCount(); if (Count == 0) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NOSEL)); } else if (Count == 1 && GetSelectedBitmap()->ActualBitmap == OILBitmap::Default) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NODELBITMAP)); } } else if (*CommandID == SGCmd_Insert || *CommandID == SGCmd_Fill // WEBSTER-ranbirr-22/11/96 #ifndef WEBSTER || *CommandID == SGCmd_Transp || *CommandID == SGCmd_Trace || *CommandID == SGCmd_XPE_Edit || *CommandID == SGCmd_Effects || *CommandID == SGCmd_SetBackground #endif //Webster #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present || *CommandID == SGCmd_PlugIns #endif ) { if (GetSelectedItemCount() != 1) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_SINGLE)); } } else if (*CommandID == SGCmd_Save) { if (GetSelectedItemCount() == 0) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NOSEL)); } } else if (*CommandID == SGCmd_Preview) { if (GetSelectedItemCount() == 0) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NOSEL)); } } else if (*CommandID == SGCmd_Props) { if (GetSelectedItemCount() == 0) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_NOSEL)); } } else return(SuperGallery::GetCommandState(CommandID, ShadeReason)); // Unknown command- pass to baseclass return(State); }

KernelBitmap * BitmapSGallery::GetSelectedBitmap (   )  [protected]

Definition at line 1951 of file sgbitmap.cpp. { // Determine useful info - this is usually needed for most actions, so always get it Document *SelectedDoc = Document::GetSelected(); /*SGDisplayGroup *DocumentGroup =*/ DisplayTree->FindSubtree(this, SelectedDoc, NULL); SGDisplayKernelBitmap *FirstSelected = NULL; // Lets see if any of our Items are selected Document *ParentDoc = (Document *) GetApplication()->Documents.GetHead(); while (ParentDoc != NULL) { SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, ParentDoc, NULL); if (DocGroup != NULL) FirstSelected = (SGDisplayKernelBitmap *) DocGroup->FindNextSelectedItem(NULL); if (FirstSelected) break; ParentDoc = (Document *) GetApplication()->Documents.GetNext(ParentDoc); } KernelBitmap *SelectedBitmap = NULL; if (FirstSelected != NULL) { SelectedBitmap = FirstSelected->GetDisplayedKernelBitmap(); } return SelectedBitmap; }

BOOL BitmapSGallery::GetSelectedBitmaps (  KernelBitmap ***  pOutputArray, UINT32 *  pOutputCount )  [protected]

Generates a list of all the selected bitmaps in the gallery. Note that the generated array becomes the callers responsibility if TRUE is returned; the caller must CCFree it. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/6/96 Parameters: see  Outputs [INPUTS] pOutputArray  - list of selected KernelBitmaps [OUTPUTS] pOutputCount - the length of the list Returns: TRUE/FALSE for success/error See also: BitmapSGallery::GetSelectedBitmap Definition at line 3555 of file sgbitmap.cpp. { // Init vars ERROR2IF(pOutputArray==NULL || pOutputCount==NULL, FALSE, "NULL output param"); KernelBitmap** pBuildingArray = NULL; // UINT32 BuildingCount = 0; // Lets see if any of our items are selected Document* ParentDoc = (Document*) GetApplication()->Documents.GetHead(); BOOL ok = TRUE; while (ParentDoc!=NULL && ok) { SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, ParentDoc, NULL); if (DocGroup != NULL) { // Note the selected items in this group SGDisplayKernelBitmap* pCurrent = (SGDisplayKernelBitmap*)DocGroup->FindNextSelectedItem(NULL); while (pCurrent!=NULL && ok) { if (pBuildingArray==NULL) { // Claim selected space pBuildingArray = (KernelBitmap**) CCMalloc(sizeof(KernelBitmap*)); if (pBuildingArray == NULL) ok = FALSE; else pBuildingArray[0] = pCurrent->GetDisplayedKernelBitmap(); *pOutputCount = 1; } else { // Add to end of selection KernelBitmap** pTemp = (KernelBitmap**) CCRealloc(pBuildingArray, ((*pOutputCount)+1)*sizeof(KernelBitmap*)); if (pTemp == NULL) ok = FALSE; else { pBuildingArray = pTemp; pBuildingArray[*pOutputCount] = pCurrent->GetDisplayedKernelBitmap(); } (*pOutputCount)++; } pCurrent = (SGDisplayKernelBitmap*)DocGroup->FindNextSelectedItem(pCurrent); } } ParentDoc = (Document *) GetApplication()->Documents.GetNext(ParentDoc); } if (!ok) { CCFree(pBuildingArray); *pOutputArray = NULL; *pOutputCount = 0; } else *pOutputArray = pBuildingArray; return ok; }

void BitmapSGallery::HandleDragStart (  DragMessage *  DragMsg  )  [protected, virtual]

Checks a DragMessage to see if it is a bitmap drag. If it is, then it creates a drag target for this gallerys listbox. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 25/3/95 Parameters: DragMsg  - The DRAGSTARTED message that we've just recieved, indicating [INPUTS] the type of drag being started Notes: Overrides the default base-class action. Calls down to the base class if it is not a colour drag, so that dragging of gallery groups is allowed Reimplemented from SuperGallery. Definition at line 2859 of file sgbitmap.cpp. { // If it's a bitmap drag, add a target for our window. If not, let the base class // have a look at it (to see if it is a gallery item being dragged) if (DragMsg->pInfo->IsKindOf(CC_RUNTIME_CLASS(GalleryBitmapDragInfo))) /* SGBitmapDragTarget *NewTarget =*/ new SGBitmapDragTarget(this, GetListGadgetID()); else SuperGallery::HandleDragStart(DragMsg); }

BOOL BitmapSGallery::HasDelayValueChanged (   )

BOOL BitmapSGallery::InitMenuCommands (  void   )  [virtual]

Initialises any menu commands that this gallery needs. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/9/95 Returns: TRUE for success Notes: Will only create the menu commands once - further calls in the future will return TRUE immediately without doing anything. Reimplemented from SuperGallery. Definition at line 3050 of file sgbitmap.cpp. { static BOOL MenusInitialised = FALSE; BOOL ok = TRUE; if (!MenusInitialised) { // Initialise menu command Ops // "Standard" entries for options menu ok = ok && InitMenuCommand((StringBase *) &SGCmd_Find, _R(IDS_SGMENU_FIND)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Sort, _R(IDS_SGMENU_SORT)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Properties, _R(IDS_SGMENU_PROPERTIES)); // "Special" entries for over-list menu ok = ok && InitMenuCommand((StringBase *) &SGCmd_Insert, _R(IDS_SGMENU_INSERT)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Fill, _R(IDS_SGMENU_FILL)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Transp, _R(IDS_SGMENU_TRANSP)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_XPE_Edit, _R(IDS_SGMENU_XPE_EDIT)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Delete, _R(IDS_SGMENU_DELETE)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Save, _R(IDS_SGMENU_SAVE)); //#if _DEBUG ok = ok && InitMenuCommand((StringBase *) &SGCmd_Preview, _R(IDS_SGMENU_PREVIEW)); //#endif // WEBSTER-ranbirr-22/11/96 #ifndef WEBSTER ok = ok && InitMenuCommand((StringBase *) &SGCmd_Trace, _R(IDS_SGMENU_TRACE)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Effects, _R(IDS_SGMENU_EFFECTS)); #endif //webster #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present ok = ok && InitMenuCommand((StringBase *) &SGCmd_PlugIns, _R(IDS_SGMENU_PLUGINS)); #endif ok = ok && InitMenuCommand((StringBase *) &SGCmd_SetBackground, _R(IDS_SGMENU_SETBACKGROUND)); // WEBSTER-ranbirr-22/11/96 ok = ok && InitMenuCommand((StringBase *) &SGCmd_Props, _R(IDS_SGMENU_PROPS)); // "Standard" commands for over-list menu ok = ok && InitMenuCommand((StringBase *) &SGCmd_FoldGroup, _R(IDS_SGMENU_FOLD)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_UnfoldGroup, _R(IDS_SGMENU_UNFOLD)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_NextGroup, _R(IDS_SGMENU_NEXTGROUP)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_PrevGroup, _R(IDS_SGMENU_PREVGROUP)); MenusInitialised = TRUE; } return(ok); }

BOOL BitmapSGallery::IsJPEG (  KernelBitmap **  pList, UINT32  ListSize, BmpDlgParam *  Param, INT32 *  pBytes )

To determine whether an imported bitmap is a compressed JPEG. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/96 Parameters: pList  - A ptr to a Kernel bitmap. [INPUTS] ListSize - The number of bitmaps selected in the bitmap gallery. Param - Allows data to be passed to and from the bitmap properties dialog. pBytes - If it is a JPEG, the memory (bytes), is returned to the caller. -  [OUTPUTS] Returns: True if the selected bitmap is a compressed JPEG, false otherwise See also: - Definition at line 3973 of file sgbitmap.cpp. { ERROR2IF(pList == NULL || Param == NULL || pBytes == NULL, FALSE, "NULL Parameters Passed"); BitmapSource* pSource = NULL; BaseBitmapFilter* pDummyFilter; KernelBitmap* pKernelBitmap = pList[ListSize]; if (pKernelBitmap == NULL) return FALSE; BOOL OriginalSourcePresent = pKernelBitmap->GetOriginalSource(&pSource, &pDummyFilter); if(OriginalSourcePresent) { if (pSource != NULL) { if (pSource->IsJPEG()) { Param->SetIsJPEG(TRUE); *pBytes += pSource->GetSize(); } } } else { Param->SetIsJPEG(FALSE); } return Param->GetIsJPEG(); }

MsgResult BitmapSGallery::Message (  Msg *  Message  )  [virtual]

A standard message handler, really. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: Message  - The message to handle [INPUTS] Notes: Any messages that this does not handle must be passed down to the SuperGallery base class message handler. NOTE WELL that the SuperGallery base class handler does some funky things for us - see SuperGallery::Message - such as deleting our display subtree for any document which dies (which, uncannily, would explain why they go away like that when you close documents ;-), and shading the gallery when there are no documents present. [To override this behaviour in these cases, you should respond to the message, and return OK rather than calling the base class message handler] See also: SuperGallery::Message Reimplemented from SuperGallery. Definition at line 2413 of file sgbitmap.cpp. { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; KernelBitmap* SelectedBitmap; switch (Msg->DlgMsg) { case DIM_CREATE: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAYBITMAPGALLERY), TRUE); SetSelectionFromDocument(TRUE); break; case DIM_CANCEL: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAYBITMAPGALLERY), FALSE); break; case DIM_LFT_BN_CLICKED: if (FALSE) {} else if (Msg->GadgetID == _R(IDC_BMPGAL_CREATE)) { SelectedBitmap = GetSelectedBitmap(); if (SelectedBitmap != NULL) { PageDropInfo DropInfo; DropInfo.pDocView = DocView::GetSelected(); DropInfo.pDoc = Document::GetSelected(); DropInfo.pSpread = Document::GetSelectedSpread(); FindCentreInsertionPosition(&DropInfo.pSpread, &DropInfo.DropPos); // Obtain a pointer to the op descriptor for the create operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpCreateNodeBitmap)); // Invoke the operation, passing DocView and Pos as parameters OpParam param((void *)SelectedBitmap,(void *)&DropInfo); OpDesc->Invoke(&param); } } else if (Msg->GadgetID == _R(IDC_BMPGAL_FILL)) { SelectedBitmap = GetSelectedBitmap(); if (SelectedBitmap != NULL) { // Fill colour selected so create a fill colour attribute NodeAttribute *Attrib = new AttrBitmapColourFill; if (Attrib == NULL) return(SuperGallery::Message(Message)); ((AttrBitmapColourFill *)Attrib)->AttachBitmap(SelectedBitmap); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); } } else if (Msg->GadgetID == _R(IDC_BMPGAL_TEXTURE)) { SelectedBitmap = GetSelectedBitmap(); if (SelectedBitmap != NULL) { SelectedBitmap = CheckTextureBitmap(SelectedBitmap); AttributeManager::HaveAskedAboutContoneColours = FALSE; AttributeManager::UserCancelledContoneColours = FALSE; if (SelectedBitmap == NULL) return(SuperGallery::Message(Message)); // Fill colour selected so create a fill colour attribute NodeAttribute *Attrib = new AttrBitmapTranspFill; if (Attrib == NULL) return(SuperGallery::Message(Message)); ((AttrBitmapTranspFill *)Attrib)->AttachBitmap(SelectedBitmap); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); } } PORTNOTE("other", "Remove XPE hooks") #ifndef EXCLUDE_FROM_XARALX else if (Msg->GadgetID == _R(IDC_BMPGAL_XPE_EDIT)) { SelectedBitmap = GetSelectedBitmap(); if (SelectedBitmap != NULL) { // Obtain a pointer to the op descriptor for the create operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(XPEEditItemOp)); // Invoke the operation, passing DocView and Pos as parameters OpParam param((void *)SelectedBitmap, NULL); OpDesc->Invoke(&param); } } #endif else if (Msg->GadgetID == _R(IDC_BMPGAL_TRACE)) { SelectedBitmap = GetSelectedBitmap(); // WEBSTER-Martin-09/01/97 we don't trace stuff #ifndef WEBSTER if (SelectedBitmap != NULL) { TraceMsg::OpenOrUse(SelectedBitmap); } #endif //webster } /* else if (Msg->GadgetID == _R(IDC_BMPGAL_EFFECTS)) { SelectedBitmap = GetSelectedBitmap(); // WEBSTER-Martin-09/01/97 #ifndef WEBSTER if (SelectedBitmap != NULL) { BfxMsg::OpenOrUse(SelectedBitmap); } #endif //webster break; } */ else if (Msg->GadgetID == _R(IDC_BMPGAL_SAVE)) { // Generate a list of the selected bitmaps UINT32 ListSize = 0; KernelBitmap** pList = NULL; if (!GetSelectedBitmaps(&pList, &ListSize)) InformError(); else { if (ListSize != 0) { BmpDlgParam BmpDlgParam; GetBmpInfo(&BmpDlgParam); // Save the Bitmap deatils for use in the bitmap export code.# BmpDlgParam.SetBitmapList(pList); BmpDlgParam.SetListSize(ListSize); BitmapExportParam ExportList(ListSize, pList, &BmpDlgParam); // Invoke the export operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpMenuExport)); OpDesc->Invoke(&ExportList); SetBmpInfo(&BmpDlgParam); ForceRedrawOfList(); } else ERROR3("No bitmaps were selected - how come the option wasn't greyed"); } if (pList != NULL) CCFree(pList); } else if (Msg->GadgetID == _R(IDC_BMPGAL_HELP)) { // HelpUserTopic(_R(IDH_Gallery_Bitmap)); HelpUserTopic(_R(IDS_HELPPATH_Gallery_Bitmap)); break; } else if (Msg->GadgetID == _R(IDC_BMPGAL_PREVIEW)) { // Generate a list of the selected bitmaps UINT32 ListSize = 0; KernelBitmap** pList = NULL; if (!GetSelectedBitmaps(&pList, &ListSize)) InformError(); else { if (ListSize != 0) { BmpDlgParam BmpDlgParam; GetBmpInfo(&BmpDlgParam); // Save the Bitmap deatils for use in the bitmap export code.# BmpDlgParam.SetBitmapList(pList); BmpDlgParam.SetListSize(ListSize); BitmapExportParam ExportList(ListSize, pList, &BmpDlgParam); // Invoke the preview operation // Check if there is a Preview Dialog present. PreviewDialog* pPreviewDialog = PreviewDialog::GetPreviewDialog(); if (!pPreviewDialog) { OpDescriptor* OpDesc; //if (KeyPress::IsAdjustPressed()) // OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BITMAPPREVIEWDIALOG); //else OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_PREVIEWDIALOG); if (OpDesc) { PreviewDialog::ToggleViaBitmapGallery (TRUE); OpDesc->Invoke(&ExportList); pPreviewDialog->SetDelay (100); pPreviewDialog = PreviewDialog::GetPreviewDialog(); // pPreviewDialog->ToggleViaBitmapGallery (TRUE); } } else { // If the animation is playing, stop the animation before we pass // it our new list of bitmaps. if(pPreviewDialog->GetPlayAnimation()) pPreviewDialog->SetPlayAnimation(FALSE); PreviewDialog::ToggleViaBitmapGallery (TRUE); pPreviewDialog->SetBitmapList(&ExportList); // pPreviewDialog->ToggleViaBitmapGallery (TRUE); pPreviewDialog->SetDelay (100); // Call the dialog box so that it sets up the necessary states pPreviewDialog->ReInitDialog(); } SetBmpInfo(&BmpDlgParam); ForceRedrawOfList(); } else ERROR3("No bitmaps were selected - how come the option wasn't greyed"); } if (pList != NULL) CCFree(pList); } #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present else if (Msg->GadgetID == _R(IDC_BMPGAL_PLUGINS)) { // Need to say which document and more importantly which bitmap we // want the menu to apply to. SelectedBitmap = GetSelectedBitmap(); // Now find out what the selected group is, which will be the document group SGDisplayNode * FirstSelected = DisplayTree->FindNextSelectedItem(NULL); Document *pDocument = NULL; if (FirstSelected == NULL) pDocument = Document::GetSelected(); else pDocument = ((SGDisplayGroup *) FirstSelected->GetParent())->GetParentDocument(); ERROR3IF(pDocument == NULL, "No parent document?!"); if (SelectedBitmap != NULL && pDocument != NULL) { // replaced menu with direct invocation of Bfx:Special Effects operation since this was // the only option left on menu - all the other plug-in options have been superseded // by the new Live Effects implementation. Fixes #11376. OpDescriptor *pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BFX_SPECIALEFFECTS); if(pOpDesc) { // Inform the Bfx operation what bitmap and document it will be working on BfxPlugInOp::SetBitmapAndDocument(SelectedBitmap, pDocument); // and invoke it immediately pOpDesc->Invoke(); } else { ERROR2RAW("Unable to find BFX:Special Effects operation"); } } } #endif else if (Msg->GadgetID == _R(IDC_BMPGAL_BACKGROUND)) { // Need to say which document and more importantly which bitmap we // want the menu to apply to. SelectedBitmap = GetSelectedBitmap(); // Now find out what the selected group is, which will be the document group SGDisplayNode * FirstSelected = DisplayTree->FindNextSelectedItem(NULL); Document *pDocument = NULL; if (FirstSelected == NULL) pDocument = Document::GetSelected(); else pDocument = ((SGDisplayGroup *) FirstSelected->GetParent())->GetParentDocument(); ERROR3IF(pDocument == NULL, "No parent document?!"); if (SelectedBitmap != NULL && pDocument != NULL) { // Apply the bitmap as the new background OpBackgroundParam Param; Param.pBitmap = SelectedBitmap; Param.pDoc = pDocument; // Obtain a pointer to the op descriptor for the create operation OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BACKGROUND); // Invoke the operation, passing in our parameters pOpDesc->Invoke(&Param); } } else if (Msg->GadgetID == _R(IDC_BMPGAL_PROPS)) { // Generate a list of the selected bitmaps UINT32 ListSize = 0; KernelBitmap** pList = NULL; if (!GetSelectedBitmaps(&pList, &ListSize)) InformError(); else { if (ListSize != 0) { // Opens the Bitmap Properties Dialog, from the Bitmap Gallery. BmpDlgParam BmpDlgParam; GetBmpInfo(&BmpDlgParam); BmpDlg::InvokeBmpDlg(&BmpDlgParam); SetBmpInfo(&BmpDlgParam); ForceRedrawOfList(); } else ERROR3("No bitmaps were selected - how come the option wasn't greyed"); } if (pList != NULL) CCFree(pList); } break; default: break; } return(SuperGallery::Message(Message)); } // If we have no displaytree, then we have not been shown, or something terrible has // happened, so we don't bother handling any of these messages. if (DisplayTree == NULL || !IsVisible()) return(SuperGallery::Message(Message)); if (IsVisible() && MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *TheMsg = (DocChangingMsg *) Message; switch ( TheMsg->State ) { case DocChangingMsg::BORN: // New document - add to display tree { INT32 Extent = GetDisplayExtent(); // Remember previous list extent CreateNewSubtree(TheMsg->pChangingDoc); // Add a subtree for this doc ShadeGallery(FALSE); // Unshade the gallery InvalidateCachedFormat(); // And redraw what is necessary RedrawEverythingBelow(-Extent); } break; // Pass this message on to the base class as well default: break; } } if (MESSAGE_IS_A(Message, BitmapListChangedMsg) && !IgnoreBmpListChange) { BitmapListChangedMsg *TheMsg = (BitmapListChangedMsg *) Message; // First, try to find the document which owns the changed list Document *ScopeDoc = (Document *)TheMsg->pChangedBmpList->GetParentDocument(); // Just check that the bi-directional link is sane! ERROR3IF(ScopeDoc == NULL, "A Document bitmap list is invalid"); // If we found it, recreate the display subtree for it if (ScopeDoc != NULL) { SGDisplayNode *Ptr = DisplayTree->FindSubtree(this, ScopeDoc, NULL); if (Ptr != NULL) { CreateNewSubtree(ScopeDoc, (SGDisplayGroup *) Ptr); // And force a redraw of the entire list ForceRedrawOfList(); // The above will loose the selection, so we can listen out for the special // form of the message which says which bitmap to reselect. if ((TheMsg->State == BitmapListChangedMsg::SELECTNEWBITMAP) && (TheMsg->pNewBitmap != NULL)) { // We have been sent a message that a new bitmap has been added and // this is the one we should go and select. SelectItems(FALSE); // Clear the current selection SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, ScopeDoc, NULL); SGDisplayKernelBitmap* pCurrentItem = NULL; if (DocGroup != NULL) pCurrentItem = (SGDisplayKernelBitmap *) DocGroup->GetChild(); //Selected = (SGDisplayKernelBitmap *) DocGroup->FindNextSelectedItem(NULL); // Ensure the tree format information is up to date, ready for when we sample it ReformatNow(TRUE); BOOL HaveSelected = FALSE; DocRect ScrollToRect; while (pCurrentItem != NULL) { KernelBitmap* CurrentBitmap = pCurrentItem->GetDisplayedKernelBitmap(); if (CurrentBitmap == TheMsg->pNewBitmap) { pCurrentItem->SetSelected(TRUE); HaveSelected = TRUE; pCurrentItem->GetFormatRect(&ScrollToRect); break; } // Get the next one in the list pCurrentItem = (SGDisplayKernelBitmap *) pCurrentItem->GetNext(); } // Try and scroll to the selected item, if we have one if (HaveSelected) { BOOL ScrollToBottom = TRUE; ScrollToShow(&ScrollToRect, ScrollToBottom); } } // Was not present before 20/12/96, safest to have it present as this action // will lose the selection. SelectionHasChanged(); } } } if (MESSAGE_IS_A(Message, CommonAttrsChangedMsg)) { if (!AmShaded) // If we're open & active, set listbox selection SetSelectionFromDocument(); } return(SuperGallery::Message(Message)); }

BOOL BitmapSGallery::PreContextMenu (  void   )  [virtual]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/97 Returns: TRUE for success Reimplemented from SuperGallery. Definition at line 3017 of file sgbitmap.cpp. { #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present // As we are just about to invoke UI, check that the plug-in manager has its list // of available plug-ins otherwise, go and get it now as we are just about to need it. // Must do it now before even the hint of a context menu is started as the context // menus stack the automatic menu id and then restore it after they are destroyed. // This is bad if our main menu ids are in this range! PlugInManager* pManager = GetApplication()->GetPlugInManager(); if (pManager) pManager->CheckHaveDetailsOnPlugIns(); #endif // PHOTOSHOPPLUGINS return(TRUE); }

BOOL BitmapSGallery::PreCreate (  void   )  [protected, virtual]

The BitmapSGallery PreCreate handler. This overrides the base class PreCreate function. It is called at the very end of the SuperGallery::Create method, after the window has been created. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Returns: TRUE if the Gallery initialised successfully FALSE if it should not be opened due to a failure to initialise Reimplemented from SuperGallery. Definition at line 1756 of file sgbitmap.cpp. { // If there isn't already one, create a DisplayTree if (DisplayTree == NULL) { DisplayTree = new SGDisplayRootScroll(this); // New root node, with a scrollbar if (DisplayTree == NULL) return(FALSE); } // Next, call CreateNewSubtree to scan all the available documents and build a // display list for each of them. Document *ParentDoc = (Document *) GetApplication()->Documents.GetTail(); while (ParentDoc != NULL) { SGDisplayNode *Ptr = DisplayTree->FindSubtree(this, ParentDoc, NULL); CreateNewSubtree(ParentDoc, (SGDisplayGroup *) Ptr); ParentDoc = (Document *) GetApplication()->Documents.GetPrev(ParentDoc); } // We're opening the window, so we fold all groups except that for the Selected document SGDisplayGroup *Group = (SGDisplayGroup *) DisplayTree->GetChild(); while (Group != NULL) { // Set the group's folded state, but don't bother trying to redraw, because we know // that the window is not currently visible, and that we are doing this to multiple groups. Group->SetFoldedState((Group->GetParentDocument() != Document::GetSelected()), FALSE); Group = (SGDisplayGroup *) Group->GetNext(); } return(TRUE); }

void BitmapSGallery::SelectionHasChanged (  void   )  [virtual]

To inform the gallery that the selection has changed in some way. The base gallery class will do the following things:. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 MonoOn If the selection is not exactly one item, the following standard buttons are shaded: Apply, Redefine, Edit If the selection is greater than 1 item, the New button will shade If the selection is zero items, then the Delete button will shade MonoOff Notes: If this default action is unsuitable, derived galleries may override it. If they add their own special buttons, they may need to override this method to ensure that their buttons also behave correctly on sel change. This method is called after creation of the window (immediately after the PostCreate upcall) to ensure the window state is correct Reimplemented from SuperGallery. Definition at line 2299 of file sgbitmap.cpp. { if (DisplayTree == NULL || AmShaded || !IsVisible()) return; INT32 Count = DisplayTree->GetSelectedItemCount(); EnableGadget(_R(IDC_BMPGAL_CREATE), (Count == 1)); EnableGadget(_R(IDC_BMPGAL_FILL), (Count == 1)); EnableGadget(_R(IDC_BMPGAL_TEXTURE), (Count == 1)); EnableGadget(_R(IDC_BMPGAL_XPE_EDIT), (Count == 1)); EnableGadget(_R(IDC_BMPGAL_TRACE), (Count == 1)); // EnableGadget(_R(IDC_BMPGAL_EFFECTS), (Count == 1)); #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present EnableGadget(_R(IDC_BMPGAL_PLUGINS), (Count == 1)); #endif EnableGadget(_R(IDC_BMPGAL_BACKGROUND), (Count == 1)); // Now that we handle multiple images we enable as long as there is a selection EnableGadget(_R(IDC_BMPGAL_SAVE), (Count > 0)); EnableGadget(_R(IDC_BMPGAL_PROPS),(Count > 0)); //#if _DEBUG // Now that we handle multiple images we enable as long as there is a selection EnableGadget(_R(IDC_BMPGAL_PREVIEW), (Count > 0)); //#endif if (Count == 1 && GetSelectedBitmap()->ActualBitmap == OILBitmap::Default) { EnableGadget(_R(IDC_GALLERY_DELETE), FALSE); } else { EnableGadget(_R(IDC_GALLERY_DELETE), (Count > 0)); } EnableGadget(_R(IDC_GALLERY_MENU), TRUE); }

BOOL BitmapSGallery::SetBmpInfo (  BmpDlgParam *  Param  )  [protected]

Stores info, retrieved from the Bitmap Properties Dialog, in an OILBitmap. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/96 Parameters: Param  - Allows the transfer of data to and from the bitmap poperties dialog. [INPUTS] -  [OUTPUTS] Returns: TRUE if Successful, FALSE otherwise. See also: - Definition at line 3880 of file sgbitmap.cpp. { ERROR2IF(Param == NULL,FALSE,"Param is NULL"); // The user has entrered OK, so go through the list of selected bitmaps and set their Delay\Restore fields. UINT32 ListSize = 0; KernelBitmap** pList = NULL; Document* WorkDoc = Document::GetSelected(); if (!GetSelectedBitmaps(&pList, &ListSize)) return FALSE; if(Param->GetAreDelayValuesSame()) { UINT32 ListCounter = ListSize; while (ListCounter>0) { KernelBitmap* pKernelBitmap = pList[--ListCounter]; if (pKernelBitmap != NULL) { pKernelBitmap->SetDelay(Param->GetAnimDelay()); } } } if (Param->GetSameRestoreType()) { UINT32 ListCounter = ListSize; while (ListCounter>0) { KernelBitmap* pKernelBitmap = pList[--ListCounter]; if(pKernelBitmap != NULL) { OILBitmap* pOILBitmap = pKernelBitmap->GetActualBitmap(); if (pOILBitmap != NULL) { pOILBitmap->SetAnimationRestoreType(Param->GetRestoreType()); } } } } // Andy Hills, 09-10-00 // Record changes to the 'smooth when scaled up' tickbox if (Param->GetAreInterpolationValuesSame()) { UINT32 ListCounter = ListSize; while (ListCounter>0) { KernelBitmap* pKernelBitmap = pList[--ListCounter]; if(pKernelBitmap != NULL) { OILBitmap* pOILBitmap = pKernelBitmap->GetActualBitmap(); if (pOILBitmap != NULL) { // change the interpolation setting of each selected bitmap pOILBitmap->SetInterpolation(Param->GetInterpolation()); // invalidate all uses of this bitmap, so that the screen is updated correctly if (WorkDoc != NULL) { pOILBitmap->InvalidateAllReferences(WorkDoc); } } } } } if (pList != NULL) CCFree(pList); return TRUE; }

void BitmapSGallery::SetSelectionFromDocument (  BOOL  AlwaysScroll = FALSE  )  [protected]

Sets the bitmap gallery listbox selection state based upon the currently selected object(s) in the document. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/96 (copied from ColourGallery) Parameters: AlwaysScroll  - TRUE if you always want to autoscroll, regardless of the [INPUTS] preference setting. (This is used when opening the gallery, as there is no point in not auto-scrolling somewhere useful) Scope: private Definition at line 1807 of file sgbitmap.cpp. { if (DisplayTree == NULL || !IsVisible()) return; SGDisplayGroup *DocGroup = DisplayTree->FindSubtree(this, Document::GetSelected(), NULL); SelectItems(FALSE); // Clear the current selection // This needs to be a preference if we ever make this gallery show the // currently selected bitmaps. BOOL AutoScrollSelection = FALSE; DocRect ScrollToRect; BOOL HaveSelected = FALSE; BOOL ScrollToBottom = FALSE; // TRUE if it is more important that the bottom of // ScrollToRect, rather than the top, is visible if (DocGroup != NULL) ForceGroupFolded(DocGroup, FALSE); // Ensure group is unfolded ReformatNow(TRUE); // Ensure the tree format information is up to date if (AutoScrollSelection || AlwaysScroll) { if (AlwaysScroll && !HaveSelected && DocGroup != NULL) { // We didn't select anything in the gallery. In that case, scroll to the top // of the document display DocRect TempRect; //DocGroup->GetFormatRect(&TempRect); DocGroup->GetChildArea(&ScrollToRect); //ScrollToRect = ScrollToRect.Union(TempRect); HaveSelected = TRUE; ScrollToBottom = FALSE; } if (HaveSelected) ScrollToShow(&ScrollToRect, ScrollToBottom); } // scroll to make seln visible on screen SelectionHasChanged(); // Update for the new selection }

---

Member Data Documentation

BOOL BitmapSGallery::IgnoreBmpListChange = FALSE [static]

Definition at line 377 of file sgbitmap.h.

---

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

• Kernel/sgbitmap.h (r1785/r1664)
• Kernel/sgbitmap.cpp (r1785/r1664)

---