OpGrabFrame Class Reference

Performs an operation to grab the selected frame layer and preview it. More...

#include <frameops.h>

Inheritance diagram for OpGrabFrame:

List of all members.

Public Member Functions
	OpGrabFrame ()
	Constructor.
	~OpGrabFrame ()
	Destructor.
virtual void	Do (OpDescriptor *pOpDesc)
	Tries to grab the selected animation frame (i.e. layer).
virtual void	DoWithParam (OpDescriptor *pOpDesc, OpParam *Param)
	Regenerate the bitmap associated with the active frame layer.
Static Public Member Functions
static BOOL	Init ()
	OpGrabFrame initialiser method.
static void	DeInit ()
	De-Initialises OpGrabFrame.
static OpState	GetState (String_256 *, OpDescriptor *)
	For finding the OpGrabFrame's state.
Protected Member Functions
virtual BOOL	StartGrab ()
	Tries to set up useful items prior to doing the grab.
virtual KernelBitmap *	GrabFrame ()
	Tries to grab the currently selected frame/layer into a bitmap.
virtual KernelBitmap *	GrabTheFrame ()
	Tries to grab the currently selected frame/layer into a bitmap. Same as GrabFrame but assumes that the filter to do the grab, m_pBitmapFilter, is already present.
virtual BOOL	EndGrab ()
	Tries to clean up after doing the grab.
virtual BOOL	GetFileNameFromUser ()
	Gives the operation chance to get the filename from the user. In this baseclass version we do nothing as we preview a single frame and so have no need of a filename.
virtual BOOL	PreviewAnimation ()
	Tries to preview the frames that have been grabbed. Uses the stored animation details in m_ExportParams.
virtual BOOL	SaveOrShowTheAnimation (PreviewDialog *pPreviewDialog, BitmapExportParam *pExportParam)
	Tries to actually do the preview operation required. In this case we just start up the preview dialog box, if not already open, to show the frames that have been grabbed. Uses the stored animation details in m_ExportParams.
BOOL	SetFullBitmapList (BOOL SetFlagState=FALSE)
BOOL	SetSingleBitmapInList ()
BOOL	SetBitmapToListTail ()
BOOL	CheckIfSingleBitmap (Layer *pLayer, KernelBitmap **ppBitmap)
	If the Preview Dialog is open and we regenerate a single frame, this function allows us to update our Bitmap list in the Preview Dialog. If the Preview Dialog is open and we regenerate a single frame, this function allows us to add that Bitmap to the head of the preview dialog bitmap list. If the Preview Dialog is open and we regenerate the frames in the animation, this function allows us to update our Bitmap list in the Preview Dialog. For finding out if there is a single bitmap on the layer which is stored in a NodeBitmap at a 1:1 scale and is 8bpp or less and the palette matches the present options. This palette testing is now done after this If it passes all these tests, then set pBitmap to be that bitmap and return True. Also note in the layer that this bitmap can possibly be used to specify this layer. We can only say for sure when we have checked that its palette matches the current animation options.
BOOL	CheckAllForSingleBitmaps (Spread *pSpread, GrabFrameFilter *pBitmapFilter)
	For going through all the frames and seeing if there is a single bitmap on the frame/layer which is stored in a NodeBitmap at a 1:1 scale and is 8bpp or less and the palette matches the present options. We use the grab frame filter as this is derived off GIF filter and this must already cope with this when loading animations so that it can set the animation options accordingly.
virtual BitmapPreviewData *	GetBitmapPreviewData ()
virtual BOOL	RememberTheSelection ()
	Tries to remember the current selection state so that we can put it back at the end of the operation. Don't error if it fails as the loss of the selection is no great hardship when memory is tight!
virtual BOOL	PutBackTheSelection ()
	Tries to put back the remembered selection state at the start of the operation.
Protected Attributes
SelectionState *	m_pSelState
GIFAnimationExportParam	m_ExportParams
GrabFrameFilter *	m_pBitmapFilter
Document *	m_pDocument
Spread *	m_pSpread
Layer *	m_pLayer
DocView *	m_pView
LPLOGPALETTE	m_pBrowserPalette
Static Protected Attributes
static BitmapPreviewData *	m_pBitmapData = NULL
Private Member Functions
	CC_DECLARE_DYNCREATE (OpGrabFrame)

---

Detailed Description

Performs an operation to grab the selected frame layer and preview it.

Author:

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

Date:

22/4/97

See also:

-

Definition at line 535 of file frameops.h.

---

Constructor & Destructor Documentation

OpGrabFrame::OpGrabFrame (   )

Constructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Definition at line 1841 of file frameops.cpp. { m_pDocument = NULL; m_pSpread = NULL; m_pLayer = NULL; m_pView = NULL; m_pBitmapFilter = NULL; m_pSelState = NULL; //m_pBitmapData = NULL; m_pBrowserPalette = NULL; }

OpGrabFrame::~OpGrabFrame (   )

Destructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Definition at line 1866 of file frameops.cpp. { if (m_pBitmapFilter != NULL) { delete m_pBitmapFilter; m_pBitmapFilter = NULL; } if (m_pSelState != NULL) { delete m_pSelState; m_pSelState = NULL; } /* if (m_pBitmapData != NULL) { delete m_pBitmapData; m_pBitmapData = NULL; } */ if (m_pBrowserPalette != NULL) { CCFree(m_pBrowserPalette); m_pBrowserPalette = NULL; } }

---

Member Function Documentation

OpGrabFrame::CC_DECLARE_DYNCREATE (  OpGrabFrame   )  [private]

BOOL OpGrabFrame::CheckAllForSingleBitmaps (  Spread *  pSpread, GrabFrameFilter *  pBitmapFilter )  [protected]

For going through all the frames and seeing if there is a single bitmap on the frame/layer which is stored in a NodeBitmap at a 1:1 scale and is 8bpp or less and the palette matches the present options. We use the grab frame filter as this is derived off GIF filter and this must already cope with this when loading animations so that it can set the animation options accordingly. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/97 Parameters: pLayer  - the layer we need to check [INPUTS] pBitmapFilter - a grab frame filter we can use Returns: True if worked correctly, False otherwise. Definition at line 2851 of file frameops.cpp. { ERROR2IF(pSpread == NULL, FALSE,"CheckIfSingleBitmap bad Spread pointer"); ERROR2IF(pBitmapFilter == NULL, FALSE,"CheckIfSingleBitmap bad GrabFrameFilter pointer"); // So we can do the optimised palette case, we must go though all the // layers/frames and see if there is a single bitmap present. We don't worry // about the palette on this first pass. We just set up the referenced bitmap // to be the single bitmap if it passes all the tests. KernelBitmap * pBitmap = NULL; BOOL Found = FALSE; BOOL SolidSet = FALSE; BOOL OverlaySet = FALSE; BOOL OverlayedBitmapSet = FALSE; Layer* pCurrentLayer = pSpread->FindFirstFrameLayer(); Layer* pNextLayer = NULL; Layer* pPrevFrameLayer = NULL; while (pCurrentLayer != NULL) { // Move to the next bitmap in the animation pNextLayer = pCurrentLayer->FindNextFrameLayer(); // This is just as a double check if (pCurrentLayer->IsPseudoFrame()) { Found = CheckIfSingleBitmap(pCurrentLayer, &pBitmap); // If the solid flag is set on anything but the last layer then note this // as dangerous if (pCurrentLayer->IsSolid() && pNextLayer != NULL) SolidSet = TRUE; if (pCurrentLayer->IsOverlay()) { // If overlay is set then we can allow it if the previous bitmap has a restore // type of overlay as this may be an animation that we have saved out // and then loaded in. If a diff has happened then overlay will be set. // We can only ever allow this if the layers consist of all bitmaps as // otherwise the layer may be overlaying a vector layer and hence be wrong. KernelBitmap * pPrevBitmap = NULL; if (pPrevFrameLayer) pPrevBitmap = pPrevFrameLayer->GetReferencedBitmap(); // Check that we have a single reuseable bitmap on this layer plus one of the previous if (pPrevBitmap != NULL && pBitmap != NULL) { GIFDisposalMethod restore = pPrevBitmap->GetAnimationRestoreType(); // Do we include GDM_NONE? Not for now. if (restore != GDM_LEAVE) { // We cannot use the bitmap so set the reference to NULL pCurrentLayer->SetReferencedBitmap(NULL); OverlaySet = TRUE; } else OverlayedBitmapSet = TRUE; } else if (pPrevFrameLayer != NULL) { // If overlay set on the first frame then ignore // We cannot use the bitmap so set the reference to NULL pCurrentLayer->SetReferencedBitmap(NULL); OverlaySet = TRUE; } } } // Move to the next bitmap in the animation pPrevFrameLayer = pCurrentLayer; pCurrentLayer = pNextLayer; } // Find out about the palettes that the bitmaps have // Our filter has a useful function for this UINT32 ReqNumberOfColours = m_ExportParams.GetNumColsInPalette(); BOOL SamePalettes = FALSE; BOOL OurBrowserPalette = FALSE; BOOL AllHaveBitmaps = FALSE; BOOL AllWithinCount = FALSE; UINT32 NumberOfColours = ReqNumberOfColours; pBitmapFilter->CheckSingleBitmapsOnSpread(pSpread, &SamePalettes, &OurBrowserPalette, &AllHaveBitmaps, &AllWithinCount, &NumberOfColours); PALETTE_COLOURS Palette = m_ExportParams.GetPaletteCols(); WEB_PALETTE WebPalette = m_ExportParams.GetPalette(); BOOL OptionsOk = FALSE; // If OverlaySet is true then we have found an overlay situation which we cannot cope with and // so will have set the referenced bitmap to null. if (OverlaySet && AllHaveBitmaps) AllHaveBitmaps = FALSE; // If solid is set on any of the frames then it is too dangerous to reuse any single bitmaps // We can only allow overlay, if all layers are single bitmaps and the bitmap concerned is // of type GDM_LEAVE. Otherwise, it is too dangerous. BOOL BitmapOverlayOk = TRUE; if (OverlayedBitmapSet && !AllHaveBitmaps) BitmapOverlayOk = FALSE; if (!SolidSet && BitmapOverlayOk) { // Check from the most fussy option to the least fussy option if (Palette == PALCOL_BROWSER && WebPalette == PAL_GLOBAL && OurBrowserPalette) { OptionsOk = TRUE; //TRACEUSER( "Neville", _T("Global browser, palettes ok\n")); } else if (Palette == PALCOL_OPTIMIZED && WebPalette == PAL_GLOBAL && SamePalettes && AllHaveBitmaps && NumberOfColours <= ReqNumberOfColours) { OptionsOk = TRUE; //TRACEUSER( "Neville", _T("Global opt, palettes ok\n")); // Force the global optimised palette to be null for now pBitmapFilter->SetGlobalOptimisedPalette(NULL); } else if (Palette == PALCOL_OPTIMIZED && WebPalette == PAL_LOCAL && AllWithinCount) { // Saving local palette so any palette ok but must be within the count OptionsOk = TRUE; //TRACEUSER( "Neville", _T("Local Opt, palettes ok\n")); } } // Now we need to go through the layers again and ratify our check pCurrentLayer = pSpread->FindFirstFrameLayer(); pBitmap = NULL; while (pCurrentLayer != NULL) { // This is just as a double check if (pCurrentLayer->IsPseudoFrame()) { pBitmap = pCurrentLayer->GetReferencedBitmap(); if (OptionsOk && pBitmap) { // We can use the bitmap instead of generating one // So make sure that the generated bitmap is clean out pCurrentLayer->SetGeneratedBitmap(NULL); // And ensure that the bitmap has the layer's delay pBitmap->SetDelay(pCurrentLayer->GetFrameDelay()); // If we are in if (Palette == PALCOL_OPTIMIZED && WebPalette == PAL_GLOBAL) { // If we haven't set up the global optimised palette then do so now // Pull it from the first bitmap that we find LPLOGPALETTE pOptPal = pBitmapFilter->GetGlobalOptimisedPalette(); if (pOptPal == NULL) { pOptPal = DIBUtil::CopyBitmapPaletteIntoLogPalette(pBitmap); // Something went a bit wrong if (pOptPal == NULL) return FALSE; pBitmapFilter->SetGlobalOptimisedPalette(pOptPal); } } } else { // We cannot use the bitmap so set the reference to NULL pCurrentLayer->SetReferencedBitmap(NULL); } } // Move to the next bitmap in the animation pCurrentLayer = pCurrentLayer->FindNextFrameLayer(); } return TRUE; }

BOOL OpGrabFrame::CheckIfSingleBitmap (  Layer *  pLayer, KernelBitmap **  ppBitmap )  [protected]

If the Preview Dialog is open and we regenerate a single frame, this function allows us to update our Bitmap list in the Preview Dialog. If the Preview Dialog is open and we regenerate a single frame, this function allows us to add that Bitmap to the head of the preview dialog bitmap list. If the Preview Dialog is open and we regenerate the frames in the animation, this function allows us to update our Bitmap list in the Preview Dialog. For finding out if there is a single bitmap on the layer which is stored in a NodeBitmap at a 1:1 scale and is 8bpp or less and the palette matches the present options. This palette testing is now done after this If it passes all these tests, then set pBitmap to be that bitmap and return True. Also note in the layer that this bitmap can possibly be used to specify this layer. We can only say for sure when we have checked that its palette matches the current animation options. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/97 Parameters: pLayer  - the layer we need to check [INPUTS] The  bitmap to use for this frame [OUTPUTS] Returns: True if found a single bitmap on the frame/layer. False otherwise. See also: CheckAllForSingleBitmaps; Definition at line 2637 of file frameops.cpp. { ERROR2IF(pLayer == NULL, FALSE,"CheckIfSingleBitmap bad layer pointer"); ERROR2IF(ppBitmap == NULL, FALSE,"CheckIfSingleBitmap bad bitmap pointer"); // Get some of the current export options DocRect BoundingRect = m_ExportParams.GetAnimationBoundingRect(); ERROR3IF(BoundingRect.IsEmpty(),"Bounding rect not set up"); // PALETTE_COLOURS Palette = m_ExportParams.GetPaletteCols(); // WEB_PALETTE WebPalette = m_ExportParams.GetPalette(); KernelBitmap * pBitmap = NULL; BOOL Scaled1to1 = FALSE; BOOL PaletteOk = FALSE; BOOL InsideBoundingRect = TRUE; BOOL FullFirstFrame = TRUE; UINT32 Bpp = 0; INT32 NodeCount = 0; NodeBitmap *pNodeBmp = NULL; // check if we are the first animation frame, if so then we the bitmap must be the same // size as the animation bounding rect. Otherwise, the first frame will not be the size // of the animation which highlights a bug in MS IE 3.0 Layer * pPreviousFrame = pLayer->FindPrevFrameLayer(); Node * pNode = pLayer->FindFirstChild(); while (pNode != NULL) { // If the node renders something on the screen then we count it as this will mean that // the single bitmap does not fully define the layer. // It ignores attributes, hidden nodes, etc - nodes that don't render anything themselves. if (pNode->IsBounded()) NodeCount++; // We need to note any NodeBitmap nodes if (pNode->IS_KIND_OF(NodeBitmap) && NodeCount == 1) { // Convert the node to a nodebitmap so we can get at the useful NodeBitmap // related data pNodeBmp = (NodeBitmap *)pNode; // Get the size and position of the node bitmap DocRect rect = pNodeBmp->GetBoundingRect(TRUE, FALSE); // If we have no previous frame then check that the first frame is the // size of the animation if (pPreviousFrame == NULL) { DocRect AniBoundingRect = m_ExportParams.GetAnimationBoundingRect(); ERROR3IF(AniBoundingRect.IsEmpty(),"CheckIfSingleBitmap Animation bounding rect not set up!"); // REMEMBER account for rounding errors const INT32 delta = 50; if ( (AniBoundingRect.lo.x >= (rect.lo.x - delta)) && (AniBoundingRect.lo.x <= (rect.lo.x + delta)) && (AniBoundingRect.hi.x >= (rect.hi.x - delta)) && (AniBoundingRect.hi.x <= (rect.hi.x + delta)) && (AniBoundingRect.lo.y >= (rect.lo.y - delta)) && (AniBoundingRect.lo.y <= (rect.lo.y + delta)) && (AniBoundingRect.hi.y >= (rect.hi.y - delta)) && (AniBoundingRect.hi.y <= (rect.hi.y + delta)) ) { FullFirstFrame = TRUE; } else { FullFirstFrame = FALSE; } } // Get the bitmap stored inside the node, if any pBitmap = pNodeBmp->GetBitmap(); if (pBitmap) { // Get the width/height of the bitmap in millipoints INT32 BmpWidth = pBitmap->GetRecommendedWidth(); INT32 BmpHeight = pBitmap->GetRecommendedHeight(); // Get the Width of the Bitmap in Millipoints INT32 Width = INT32(pNodeBmp->Parallel[0].Distance(pNodeBmp->Parallel[1])); INT32 Height = INT32(pNodeBmp->Parallel[1].Distance(pNodeBmp->Parallel[2])); // REMEMBER account for rounding errors and the orientation being the other // way round const INT32 delta = 2; if ((Width >= BmpWidth - delta && Width <= BmpWidth + delta && Height >= BmpHeight - delta && Height <= BmpHeight + delta) || (Height >= BmpWidth - delta && Height <= BmpWidth + delta && Width >= BmpHeight - delta && Width <= BmpHeight + delta) ) Scaled1to1 = TRUE; Bpp = pBitmap->GetBPP(); // If the bitmap is 8bpp of less then assume this is ok for now // We will check the palette in a second pass if (Bpp <= 8) { PaletteOk = TRUE; } /* // We cannot cope with GLOBAL OPTIMISED palettes at present as we // would need to wait until the palette was generated before we could // check. if (Palette == PALCOL_OPTIMIZED && WebPalette == PAL_LOCAL) { // Saving local palette so any palette ok PaletteOk = TRUE; } else if (Palette == PALCOL_BROWSER && WebPalette == PAL_GLOBAL) { // Check if we have a browser palette on this bitmap //PaletteOk = pBitmap->IsBrowserPalette(); // Old way of testing. Too lenient as all it does it check that the palette // has the correct colours in it, not that the palette will be the same one // that we are going to output as the browser palette // Obviously, browser palettes can only happen on 8bpp bitmaps if (Bpp == 8) { // First of all, if we haven't already got our palette that we check against // then construct it. if (m_pBrowserPalette == NULL) { UINT32 PaletteSize = UINT32(pow(2,Bpp)); m_pBrowserPalette = DIBUtil::AllocateLogPalette(PaletteSize); if (m_pBrowserPalette != NULL) { // Now force it into a browser compatible state BOOL AvoidSystemColours = TRUE; PaletteManager::MakePaletteBrowserCompatible(m_pBrowserPalette, AvoidSystemColours); } } INT32 TransColour = -1; pBitmap->GetTransparencyIndex(&TransColour); if (m_pBrowserPalette != NULL) { PaletteOk = pBitmap->ArePalettesTheSame(m_pBrowserPalette, TransColour); } else { ERROR3("Couldn't allocate browser palette"); PaletteOk = FALSE; } } else PaletteOk = FALSE; } } */ if (Scaled1to1 && PaletteOk && !rect.IsEmpty() && !BoundingRect.IsEmpty()) { // Work out the position of the bitmap relative to the top left hand // corner of the bounding rectangle in terms of pixels and put this // in the bitmap MILLIPOINT LeftOffsetMP = rect.lo.x - BoundingRect.lo.x; MILLIPOINT TopOffsetMP = BoundingRect.hi.y - rect.hi.y; if (LeftOffsetMP >= 0 && TopOffsetMP >= 0) { const UINT32 dpi = 96; UINT32 LeftOffset = LeftOffsetMP * dpi/72000; UINT32 TopOffset = TopOffsetMP * dpi/72000; pBitmap->SetLeftOffset(LeftOffset); pBitmap->SetTopOffset(TopOffset); InsideBoundingRect = TRUE; } } } } pNode = pNode->FindNext(); } // If all these checks are TRUE then return the bitmap as the source of the frame if (pBitmap != NULL && Scaled1to1 && Bpp <= 8 && NodeCount == 1 && PaletteOk && InsideBoundingRect && FullFirstFrame) { if (ppBitmap) *ppBitmap = pBitmap; // Make the layer remember this bitmap // Remember this bitmap as the reference one pLayer->SetReferencedBitmap(pBitmap); //TRACEUSER( "Neville", _T("Using single bitmap\n")); return TRUE; } // Ensure that we have no reference saved pLayer->SetReferencedBitmap(NULL); return FALSE; }

void OpGrabFrame::DeInit (  void   )  [static]

De-Initialises OpGrabFrame. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/97 Definition at line 1571 of file frameops.cpp. { // Deinit our static preview bitmap data pointer if allocated // This should clean up any temp files that we have used if (m_pBitmapData != NULL) { delete m_pBitmapData; m_pBitmapData = NULL; } // Give the browser preview chance to clean up its temp file useage OpBrowserPreview::RemoveTempFile(); }

void OpGrabFrame::Do (  OpDescriptor *  pOpDesc  )  [virtual]

Tries to grab the selected animation frame (i.e. layer). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Parameters: OpDescriptor  (unused) [INPUTS] -  [OUTPUTS] Returns: - This Op can be invoked under a number of circumstances:- 1. When the preview dialog is open. Dissplay the bitmap corresponding to the selected frame layer. If the selected frame layer is not in the Preview list (i.e has not been generated) then generate the bitmap and add it to the list of bitmaps which be will included in the Preview. 2. When the preview dialog is closed. In this case we need to generate the bitmap corresponding to the selected Frame layer. Reimplemented from Operation. Reimplemented in OpGrabAllFrames. Definition at line 1914 of file frameops.cpp. { DoWithParam(pOpDesc, NULL); return; }

void OpGrabFrame::DoWithParam (  OpDescriptor *  pOpDesc, OpParam *  pParam )  [virtual]

Regenerate the bitmap associated with the active frame layer. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> (From Neville code.) Date: 21/05/97 Parameters: OpDescriptor  (unused) [INPUTS] pParam - NULL - means grab the active frame Param1 = pLayer - means grab the specified layer -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 1936 of file frameops.cpp. { // ERROR3IF(pParam == NULL, "OpGrabFrame::DoWithParam - NULL Param passed in"); // Get useful data and set up items before starting the grab process if (!StartGrab()) { // We failed to grab the frame FailAndExecute(); End(); return; } // If a parameter has been supplied then this should be a layer pointer, which we // should then use to grab the frame // Otherwise, we assume we must grab the active frame (StartGrab sets m_pLayer to the active layer) if (pParam != NULL) { // recover the layer pointer that has been specified Layer* pLayer = (Layer *) (void *) pParam->Param1; if (pLayer) { ERROR3IF(!pLayer->IS_KIND_OF(Layer), "OpParam passed is not a Layer"); // Note the layer we are expected to grab in our class variable m_pLayer = pLayer; // Set up the visibility of the other layers using this layer // as the new temporary and acting active layer FrameSGallery::FixOtherLayersFromActive(m_pLayer); } } // Are we trying to grab a hidden frame? if (m_pLayer->IsHiddenFrame()) { // yes, tell the user InformError(_R(IDS_FRAMEISHIDDEN)); //ERROR3IF(m_pLayer->IsHiddenFrame(),"OpGrabFrame::DoWithParam Frame is hidden"); // and then fail FailAndExecute(); End(); return; } // If required, allow the op to get a filename from the user. // This also allows them access to the options via the button on the save dialog box. // This is why we must do this first rather than after we have generated the frames. if (!GetFileNameFromUser()) { // We failed to grab the frame FailAndExecute(); End(); return; } // Get our static pointer to the Preview Dialog. PreviewDialog* pPreviewDlg = PreviewDialog::GetPreviewDialog(); // If the preview dialog is already open, find the selected frame layer. if (pPreviewDlg) pPreviewDlg->StopPreviewing(); // Go and do the work to grab the frame KernelBitmap* pBitmap = GrabFrame(); if (pBitmap == NULL) { // We failed to grab the frame. // Try and put back the selection that we recorded at the start PutBackTheSelection(); FailAndExecute(); End(); return; } // If we have grabbed the non-active layer then make sure the active layer // is set up as current Layer *pActiveLayer = m_pSpread->FindActiveLayer(); if (pActiveLayer && m_pLayer != pActiveLayer) FrameSGallery::FixOtherLayersFromActive(pActiveLayer); // Clean up after the grabbing process. if (!EndGrab()) { // We failed to clean up after grabbing the frame. FailAndExecute(); End(); return; } // Add this bitmap and layer pairing to our export list if (!m_ExportParams.AddLayerAndBitmap(m_pLayer, pBitmap)) { FailAndExecute(); End(); return; } // Open the preview dialog, and display the selected frame. if(!PreviewAnimation()) { // We failed to preview the bitmap FailAndExecute(); End(); return; } // Finish the operation End(); return; }

BOOL OpGrabFrame::EndGrab (   )  [protected, virtual]

Tries to clean up after doing the grab. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Parameters: [INPUTS]  Returns: True if worked ok, False otherwise Definition at line 2376 of file frameops.cpp. { // Try and put back the selection that we recorded at the start PutBackTheSelection(); // Make sure that the new selection is up to date //Range * pSelRange = GetApplication()->FindSelection(); /* if (pSelRange == NULL || !DoInvalidateNodesRegions(*pSelRange, TRUE)) { // We failed to invalidate the region return FALSE; } */ /* // Recover the active layer again and make sure that it is being shown correctly. ERROR2IF(m_pSpread == NULL,FALSE,"bad spread in EndGrab()"); Layer *pLayer = m_pSpread->FindActiveLayer(); ERROR2IF(pLayer == NULL,"No active layer in EndGrab()") if (pLayer) { FrameSGallery::FixOtherLayersFromActive(pLayer); } */ return TRUE; }

virtual BitmapPreviewData* OpGrabFrame::GetBitmapPreviewData (   )  [inline, protected, virtual]

Definition at line 572 of file frameops.h. { return m_pBitmapData; }

BOOL OpGrabFrame::GetFileNameFromUser (   )  [protected, virtual]

Gives the operation chance to get the filename from the user. In this baseclass version we do nothing as we preview a single frame and so have no need of a filename. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/97 Returns: True if worked ok, False otherwise Reimplemented in OpSaveAnimatedGIF, and OpBrowserPreview. Definition at line 2414 of file frameops.cpp. { // Baseclass version, do nothing return TRUE; }

OpState OpGrabFrame::GetState (  String_256 *  pUIDescription, OpDescriptor *  pOpDesc )  [static]

For finding the OpGrabFrame's state. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Parameters: Name  of the OpDescriptor being queried [INPUTS] The  string to show to the user [OUTPUTS] Returns: The state of the OpGrabFrame operation Errors: - See also: - Reimplemented in OpSaveAnimatedGIF. Definition at line 1600 of file frameops.cpp. { //The frame movement controls on the GIF animation bar now work on frames only. OpState OpSt; #ifdef WEBSTER String_256 DisableReason; // Is there a selected spread? Spread * pSpread = Document::GetSelectedSpread(); if (pSpread) { // yes, so check if there is an active layer Layer * pLayer = pSpread->FindActiveLayer(); if (pLayer) { // Ensure that we have some visible objects on the specified layer to render // Could use a range but easier just to check if there are visible objects on the page DocRect VisibleRect = pSpread->GetPageVisibleBounds(); BOOL Empty = VisibleRect.IsEmpty(); // If this frame has nothing visible on it then check if there are renderable objects // on any other frames in the animation. if (Empty) { // Cannot assume that all the frame layers are actually frame layers so // go through all those that might be frame layers. Layer * pFrame = pSpread->FindFirstLayer(); while (pFrame && Empty) { if (pFrame->IsPseudoFrame() && pFrame->HasLayerGotRenderableChildren()) Empty = FALSE; pFrame = pFrame->FindNextLayer(); } } if (pOpDesc && pOpDesc->Token != String(OPTOKEN_FRAME_GRABFRAME) && !Empty) { // Cannot assume that all the frame layers are actually frame layers so // go through all those that might be frame layers. Layer * pFrame = pSpread->FindFirstLayer(); BOOL AllHidden = TRUE; while (pFrame && AllHidden) { if (pFrame->IsPseudoFrame() && !pFrame->IsHiddenFrame()) AllHidden = FALSE; pFrame = pFrame->FindNextLayer(); } if (AllHidden) { OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_ALLFRAMESAREHIDDEN)); if (pUIDescription) *pUIDescription = DisableReason; } else { // Yes, so we are allowed to grab the frame or all the frames OpSt.Greyed = FALSE; } } else if (pOpDesc && pOpDesc->Token == String(OPTOKEN_FRAME_GRABFRAME) && pLayer->IsHiddenFrame()) { // If we are the grab frame op then check that the current layer is not // hidden. If so then disallow OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_FRAMEISHIDDEN)); if (pUIDescription) *pUIDescription = DisableReason; } else if (!Empty) { // Yes, so we are allowed to grab the frame or all the frames OpSt.Greyed = FALSE; } else { OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_NO_VISIBLE_OBJECTS)); if (pUIDescription) *pUIDescription = DisableReason; } } else { // No, so we are greyed OpSt.Greyed = TRUE; } } else { // No selected spread, so we are greyed OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_NO_DOC)); if (pUIDescription) *pUIDescription = DisableReason; } #else // Flag to determine the document mode. BOOL FrameMode = FALSE; // Get a ptr to the selected spread Spread* pSpread = Document::GetSelectedSpread(); // Ensure a valid spread ptr. if(pSpread) { // Are there any frame layers? Layer* pFrameLayer = pSpread->FindFirstFrameLayer(); //If a frame layer exists, then this is an animation doc. if (pFrameLayer) FrameMode = TRUE; } if(FrameMode) { String_256 DisableReason; if (pSpread) { // yes, so check if there is an active layer Layer * pLayer = pSpread->FindActiveLayer(); if (pLayer) { // Ensure that we have some visible objects on the specified layer to render // Could use a range but easier just to check if there are visible objects on the page DocRect VisibleRect = pSpread->GetPageVisibleBounds(); BOOL Empty = VisibleRect.IsEmpty(); // If this frame has nothing visible on it then check if there are renderable objects // on any other frames in the animation. if (Empty) { // Cannot assume that all the frame layers are actually frame layers so // go through all those that might be frame layers. Layer * pFrame = pSpread->FindFirstLayer(); while (pFrame && Empty) { if (pFrame->IsPseudoFrame() && pFrame->HasLayerGotRenderableChildren()) Empty = FALSE; pFrame = pFrame->FindNextLayer(); } } if (pOpDesc && pOpDesc->Token != String(OPTOKEN_FRAME_GRABFRAME) && !Empty) { // Cannot assume that all the frame layers are actually frame layers so // go through all those that might be frame layers. Layer * pFrame = pSpread->FindFirstLayer(); BOOL AllHidden = TRUE; while (pFrame && AllHidden) { if (pFrame->IsPseudoFrame() && !pFrame->IsHiddenFrame()) AllHidden = FALSE; pFrame = pFrame->FindNextLayer(); } if (AllHidden) { OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_ALLFRAMESAREHIDDEN)); if (pUIDescription) *pUIDescription = DisableReason; } else { // Yes, so we are allowed to grab the frame or all the frames OpSt.Greyed = FALSE; } } else if (pOpDesc && pOpDesc->Token == String(OPTOKEN_FRAME_GRABFRAME) && pLayer->IsHiddenFrame()) { // If we are the grab frame op then check that the current layer is not // hidden. If so then disallow OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_FRAMEISHIDDEN)); if (pUIDescription) *pUIDescription = DisableReason; } else if (!Empty) { // Yes, so we are allowed to grab the frame or all the frames OpSt.Greyed = FALSE; } else { OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_NO_VISIBLE_OBJECTS)); if (pUIDescription) *pUIDescription = DisableReason; } } else { // No, so we are greyed OpSt.Greyed = TRUE; } } else { // No selected spread, so we are greyed OpSt.Greyed = TRUE; // Load reason why operation is disabled DisableReason = String_256(_R(IDS_NO_DOC)); if (pUIDescription) *pUIDescription = DisableReason; } } else { // The document is layer based, so we are greyed. OpSt.Greyed = TRUE; *pUIDescription = String_256 (_R(IDS_NO_FRAMES)); } #endif return OpSt; }

KernelBitmap * OpGrabFrame::GrabFrame (   )  [protected, virtual]

Tries to grab the currently selected frame/layer into a bitmap. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Parameters: [INPUTS]  Returns: KernelBitmap if worked ok, NULL otherwise Definition at line 2204 of file frameops.cpp. { ERROR2IF(m_pDocument == NULL,FALSE,"GrabFrame bad document pointer"); ERROR2IF(m_pSpread == NULL,FALSE,"GrabFrame bad spread pointer"); ERROR2IF(m_pLayer == NULL,FALSE,"GrabFrame bad layer pointer"); ERROR2IF(m_pView == NULL,FALSE,"GrabFrame bad view pointer"); // Create a special Bitmap filter, that creates a bitmap // and puts it in the tree ERROR3IF(m_pBitmapFilter != NULL,"Already have a pBitmapFilter!"); m_pBitmapFilter = new GrabFrameFilter(); if (m_pBitmapFilter == NULL) { return NULL; } // Get the filter to work out the new rectangle m_pBitmapFilter->SetUpClippingRectangleForExport(m_pSpread, DRAWING); DocRect NewBoundingRect = m_pBitmapFilter->GetClipRect(); // Save away the new bounding rectangle m_pSpread->SetAnimationBoundingRect(NewBoundingRect); m_ExportParams.SetAnimationBoundingRect(NewBoundingRect); // Save away the quality that this was grabbed at Quality NewQuality = m_pView->RenderQuality; m_pSpread->SetAnimationQuality(NewQuality); // Check all the layers to see if they contain a single bitmap which we can use // instead of generating one. // This will mark all valid single bitmaps using the reference in the layer if (!CheckAllForSingleBitmaps(m_pSpread, m_pBitmapFilter)) { delete m_pBitmapFilter; m_pBitmapFilter = NULL; return NULL; } // Check if we are grabbing a changed background layer frame, if it is then // we will then clear the edited bit on this. Once this happens then if the // user grabs all frames then the dependent frames wont be updated. if (m_pLayer->IsEdited() && m_pLayer->IsSolid()) { // Mark all frames above this as edited until we reach the last frame // OR we hit a solid/background layer. Layer * pFrame = m_pLayer->FindNextFrameLayer(); while (pFrame != NULL && !pFrame->IsSolid()) { // Mark that frame as edited pFrame->SetEdited(TRUE); pFrame = pFrame->FindNextFrameLayer(); } } // Check to see if we have a single bitmap on the layer which is stored // in a NodeBitmap at a 1:1 scale and is 8bpp or less and the palette matches // the present options. // If it passes all these tests, then set pBitmapToCreate to be that bitmap. // Otherwise, we will need to go and convert the current frame into a bitmap KernelBitmap* pBitmapToCreate = NULL; //if (!CheckIfSingleBitmap(m_pLayer, &pBitmapToCreate)) // If there is a referenced bitmap then we can use this instead of generating one pBitmapToCreate = m_pLayer->GetReferencedBitmap(); if (pBitmapToCreate == NULL) { // Grab the frame // As this will affect us during grabbing, we should force it into the known // non-interferring state BOOL CurrentVisEdState = Layer::ActiveLayerVisibleAndEditable; Layer::ActiveLayerVisibleAndEditable = FALSE; // The all visible flag will also do this for us. Document* pDoc = m_pSpread->FindParentDocument(); BOOL CurrentAllVisibleState = FALSE; if (pDoc != NULL) { CurrentAllVisibleState = pDoc->IsAllVisible(); pDoc->SetAllVisible(FALSE); } // Go and convert the frame into its bitmap form pBitmapToCreate = GrabTheFrame(); // Put back the active layer's visibilty and selection Layer::ActiveLayerVisibleAndEditable = CurrentVisEdState; // Put back the all visible state if (pDoc != NULL) pDoc->SetAllVisible(CurrentAllVisibleState); } // Note the capture quality that the frame was captured at but only if we worked correctly if (pBitmapToCreate) m_pLayer->SetCaptureQuality(NewQuality); // remove the filter as we have no more use for it delete m_pBitmapFilter; m_pBitmapFilter = NULL; // Clear the edited flag on the layer m_pLayer->SetEdited(FALSE); #ifdef _DEBUG // Tell the frame gallery to update its display of the frame BROADCAST_TO_ALL(LayerMsg(m_pLayer, LayerMsg::REDRAW_LAYER)); #endif // return the bitmap to the caller return pBitmapToCreate; }

KernelBitmap * OpGrabFrame::GrabTheFrame (   )  [protected, virtual]

Tries to grab the currently selected frame/layer into a bitmap. Same as GrabFrame but assumes that the filter to do the grab, m_pBitmapFilter, is already present. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/6/97 Parameters: [INPUTS]  Returns: KernelBitmap if worked ok, NULL otherwise Definition at line 2327 of file frameops.cpp. { ERROR2IF(m_pDocument == NULL,FALSE,"GrabFrame bad document pointer"); ERROR2IF(m_pLayer == NULL,FALSE,"GrabFrame bad layer pointer"); ERROR2IF(m_pBitmapFilter == NULL,FALSE,"GrabFrame m_pBitmapFilter pointer"); // Tell it about the layer that is being captured // This supplies the name of the bitmap and the export parameters m_pBitmapFilter->SetLayerBeingCaptured(m_pLayer); KernelBitmap* pBitmapToCreate = NULL; if (!m_pBitmapFilter->DoCreateBitmap(this, m_pDocument, &pBitmapToCreate) || pBitmapToCreate == NULL) { return NULL; } // Copy across the delay from the layer (Andy 5/1/01) DWORD delay = m_pLayer->GetFrameDelay(); pBitmapToCreate->SetDelay(delay); // Make the layer remember this bitmap as the one that was generated if (!m_pLayer->SetGeneratedBitmap(pBitmapToCreate)) { ERROR3("Couldn't add bitmap to layer!"); if (pBitmapToCreate) delete pBitmapToCreate; return NULL; } // DO NOT unset the edited flag. This version is used in GrabAllFrames and we need the // edited flags present until we have finished grabbing so that we can work out dependent // layers. // return the bitmap to the caller return pBitmapToCreate; }

BOOL OpGrabFrame::Init (  void   )  [static]

OpGrabFrame initialiser method. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/6/97 Returns: TRUE if the operation could be successfully initialised FALSE if no more memory could be allocated Errors: ERROR will be called if there was insufficient memory to allocate the operation. Reimplemented from SimpleCCObject. Definition at line 1435 of file frameops.cpp. { BOOL ok = FALSE; // start of non-undoable operations ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_FRAMEPROPERTIES), // String resource ID CC_RUNTIME_CLASS(OpFrameProperties), // Runtime class OPTOKEN_FRAME_PROPERTIES, // Token string OpFrameProperties::GetState, // GetState function 0, // help ID _R(IDBBL_FRAMEPROPERTIES), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_FRAMEPROPERTIES), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); if(ok) ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_ANIMATIONPROPERTIES), // String resource ID CC_RUNTIME_CLASS(OpAnimationProperties), // Runtime class OPTOKEN_FRAME_ANIPROPERTIES, // Token string OpAnimationProperties::GetState, // GetState function 0, // help ID _R(IDBBL_ANIMATIONPROPERTIES), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_ANIMATIONPROPERTIES), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); if(ok) ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_GRABFRAME), // String resource ID CC_RUNTIME_CLASS(OpGrabFrame), // Runtime class OPTOKEN_FRAME_GRABFRAME, // Token string OpGrabFrame::GetState, // GetState function _R(IDH_Command_Preview_All_Frames), // help ID _R(IDBBL_GRABFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_GRABFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); if(ok) ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_GRABALLFRAMES), // String resource ID CC_RUNTIME_CLASS(OpGrabAllFrames), // Runtime class OPTOKEN_FRAME_GRABALLFRAMES, // Token string OpGrabAllFrames::GetState, // GetState function _R(IDH_Command_Preview_All_Frames), // help ID _R(IDBBL_GRABALLFRAMES), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_GRABALLFRAMES), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); if(ok) ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_FRAME_SAVEANIMATEDGIF), // String resource ID CC_RUNTIME_CLASS(OpSaveAnimatedGIF), // Runtime class OPTOKEN_SAVEANIMATEDGIF, // Token string OpSaveAnimatedGIF::GetState, // GetState function 0, // help ID _R(IDBBL_SAVEANIMATEDGIF), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_SAVEANIMATEDGIF), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); if(ok) ok = RegisterOpDescriptor( 0, // Tool ID _R(IDS_BROWSERPREVIEW), // String resource ID CC_RUNTIME_CLASS(OpBrowserPreview), // Runtime class OPTOKEN_FRAME_BROWSERPREVIEW, // Token string OpBrowserPreview::GetState, // GetState function _R(IDH_Command_Preview_Animation_in_Browser), // help ID _R(IDBBL_BROWSERPREVIEW), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_GOTOBROWSER), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // No vertical counterpart 0, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ); // end of non-undoable operations if(ok) ok = PreviewInBrowserTab::Declare(); return ok; }

BOOL OpGrabFrame::PreviewAnimation (   )  [protected, virtual]

Tries to preview the frames that have been grabbed. Uses the stored animation details in m_ExportParams. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Returns: True if worked ok, False otherwise Definition at line 2432 of file frameops.cpp. { // Copy all the current animation parameters from the spread into our export // params. m_ExportParams.SetSpreadAnimPropertiesParam(m_pSpread->GetSpreadAnimPropertiesParam()); // See if there is a currently open preview dialog box PreviewDialog * pPreviewDialog = PreviewDialog::GetPreviewDialog(); // Check that we have a list of bitmaps to preview. If not then complain bitterly. // Hidden frames allow us to get this far. if (m_ExportParams.GetBitmapCount() == 0) { // If the preview dialog is open then force it into an idle state if (pPreviewDialog != NULL) pPreviewDialog->SetDialogToIdleState(); // tell the user about the problems InformError(_R(IDS_NOFRAMESTOPREVIEW)); return FALSE; } // If the preview dialog is currently open, pass it the list of bitmaps. // We must do this on all types of preview e.g. save, as we will have stopped // the animation before previewing and so we need to ensure that the preview // dialog box is restored to a known state. if (pPreviewDialog != NULL) { // Pass the preview dialog box the new list of bitmaps pPreviewDialog->SetBitmapList(&m_ExportParams); PreviewDialog::ToggleViaBitmapGallery (FALSE); //pPreviewDialog->ToggleViaBitmapGallery (FALSE); pPreviewDialog->SetPlayAnimation(TRUE); // Call the dialog box so that it sets up the necessary states pPreviewDialog->ReInitDialog(); } // This does the actually job in hand, e.g. preview, save, preview in browser BOOL ok = SaveOrShowTheAnimation(pPreviewDialog, &m_ExportParams); return ok; }

BOOL OpGrabFrame::PutBackTheSelection (   )  [protected, virtual]

Tries to put back the remembered selection state at the start of the operation. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/6/97 Returns: True if worked ok, False otherwise Definition at line 2176 of file frameops.cpp. { if (m_pSelState == NULL) return FALSE; BOOL RestoreSelBlobs = TRUE; //FALSE; BOOL RemoveBlobs = FALSE; //TRUE; // Restores the recorded selected state m_pSelState->Restore(RestoreSelBlobs, RemoveBlobs); delete m_pSelState; m_pSelState = NULL; return TRUE; }

BOOL OpGrabFrame::RememberTheSelection (   )  [protected, virtual]

Tries to remember the current selection state so that we can put it back at the end of the operation. Don't error if it fails as the loss of the selection is no great hardship when memory is tight! Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/6/97 Returns: True if worked ok, False otherwise Definition at line 2143 of file frameops.cpp. { // Create a SelectionState object m_pSelState = new SelectionState(); if (m_pSelState == NULL) { return FALSE; // Failure } // We have managed to create a SelectionState instance, now lets try and // record the current selections if (!m_pSelState->Record()) // We failed to allocate enough memory to store the selection state { // There was insufficient memory to record the selections delete m_pSelState; // Delete the selection state m_pSelState = NULL; return FALSE; } return TRUE; }

BOOL OpGrabFrame::SaveOrShowTheAnimation (  PreviewDialog *  pPreviewDialog, BitmapExportParam *  pExportParam )  [protected, virtual]

Tries to actually do the preview operation required. In this case we just start up the preview dialog box, if not already open, to show the frames that have been grabbed. Uses the stored animation details in m_ExportParams. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/97 Parameters: pPreviewDialog  the preview dialog box, if open [INPUTS] pExportParam the export param which we will use Returns: True if worked ok, False otherwise Reimplemented in OpSaveAnimatedGIF, and OpBrowserPreview. Definition at line 2493 of file frameops.cpp. { // Only boot up the preview dialog box if it is not already on display // If it is already on display then we will have already dealt with it if (pPreviewDialog == NULL) { // Invoke the preview operation OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_PREVIEWDIALOG); if (pOpDesc) { PreviewDialog::ToggleViaBitmapGallery (FALSE); pOpDesc->Invoke(&m_ExportParams); pPreviewDialog = PreviewDialog::GetPreviewDialog(); //pPreviewDialog->ToggleViaBitmapGallery (FALSE); } } return TRUE; }

BOOL OpGrabFrame::SetBitmapToListTail (   )  [protected]

BOOL OpGrabFrame::SetFullBitmapList (  BOOL  SetFlagState = FALSE  )  [protected]

BOOL OpGrabFrame::SetSingleBitmapInList (   )  [protected]

BOOL OpGrabFrame::StartGrab (   )  [protected, virtual]

Tries to set up useful items prior to doing the grab. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Parameters: [INPUTS]  Returns: True if worked ok, False otherwise Definition at line 2060 of file frameops.cpp. { // Is there a selected Document? m_pDocument = Document::GetSelected(); if (m_pDocument == NULL) { ERROR3("Called OpGrabFrame with no selected document!"); return FALSE; } // Is there a selected spread? m_pSpread = Document::GetSelectedSpread(); if (m_pSpread == NULL) { ERROR3("Called OpGrabFrame with no selected spread!"); return FALSE; } // Is there a selected view? m_pView = DocView::GetSelected(); if (m_pView == NULL) { ERROR3("Called OpGrabFrame with no selected view!"); return FALSE; } // Check that all visible layers are actually frame layers FrameSGallery::EnsureFrameLayerIntegrity(m_pSpread); // yes, so check if there is an active layer and try to grab it m_pLayer = m_pSpread->FindActiveLayer(); if (m_pLayer == NULL) { ERROR3("Called OpGrabFrame with no active layer!"); return FALSE; } // Find all objects on this spread from the specified layer, // selected or unselected, and get the bounding them. // Range Control parameters are:- // Include selected nodes - we want TRUE. // Include Unselected nodes - we want TRUE. // Cross layers - we want TRUE // Ignore locked layers - we want FALSE so that we include locked layers. // IsRenderable if set then calls NeedsToRender - we want TRUE // Ignore invisible layers - we want FALSE so that we don't include invisible layers. //Range SearchRange(m_pLayer, NULL, RangeControl(TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)); // We need to invalidate the region /* if (!DoInvalidateNodesRegions(SearchRange, TRUE)) { return FALSE; } */ /* if (!DoStartSelOp(FALSE,FALSE)) // Try to record the selection state , don't render the blobs though { return FALSE; }*/ // Remember the selection so that we can put it back at the end of the operation RememberTheSelection(); // Copy all the current animation parameters from the spread into our export // params. m_ExportParams.SetSpreadAnimPropertiesParam(m_pSpread->GetSpreadAnimPropertiesParam()); return TRUE; }

---

Member Data Documentation

GIFAnimationExportParam OpGrabFrame::m_ExportParams [protected]

Definition at line 585 of file frameops.h.

BitmapPreviewData * OpGrabFrame::m_pBitmapData = NULL [static, protected]

End of OpAnimationProperties Definition at line 594 of file frameops.h.

GrabFrameFilter* OpGrabFrame::m_pBitmapFilter [protected]

Definition at line 587 of file frameops.h.

LPLOGPALETTE OpGrabFrame::m_pBrowserPalette [protected]

Definition at line 596 of file frameops.h.

Document* OpGrabFrame::m_pDocument [protected]

Definition at line 589 of file frameops.h.

Layer* OpGrabFrame::m_pLayer [protected]

Definition at line 591 of file frameops.h.

SelectionState* OpGrabFrame::m_pSelState [protected]

Definition at line 580 of file frameops.h.

Spread* OpGrabFrame::m_pSpread [protected]

Definition at line 590 of file frameops.h.

DocView* OpGrabFrame::m_pView [protected]

Definition at line 592 of file frameops.h.

---

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

• Kernel/frameops.h (r1785/r1282)
• Kernel/frameops.cpp (r1785/r1282)

---