BaseBitmapFilter Class Reference

Base class for bitmap filters. (Currently export only). Inherited classes tend to be in the OIL layer. The base class fails on both imports & exports, so you only need to override the half that you implement. More...

#include <bitfilt.h>

Inheritance diagram for BaseBitmapFilter:

List of all members.

Public Member Functions
	BaseBitmapFilter ()
	Constructor for an BaseBitmapFilter object. The object should be initialised before use. Base class version.
	~BaseBitmapFilter ()
	Destructor for an BaseBitmapFilter object.
virtual BOOL	Init ()
	Declares a preference that allows you to clear memory in delete().
virtual BOOL	IsDefaultDocRequired (const TCHAR *pcszPathName)
	Works out if opening a file of this type requires a default document to be loaded. If the file format supplies the document then return FALSE otherwise return TRUE. An example would be opening a bitmap file. This has no document defined in the file format and so we need to laod the default document before importing the bitmap into this file. In this baseclass version return FALSE and hence assume that the filters that need to will override this function to return TRUE.
virtual FilterType	GetFilterType () const
BOOL	DoImport (SelOperation *Op, CCLexFile *, Document *DestDoc, BOOL AutoChosen=FALSE, ImportPosition *Pos=NULL, KernelBitmap **ppImportedBitmap=NULL, DocCoord *pPosTranslate=NULL, String_256 *=NULL)
	Read bitmap data from a file. This is the same for all bitmap filters; the ImportBitmap() function should be over-ridden for actual bitmap import filters.
virtual BOOL	DoExport (Operation *, CCLexFile *, PathName *, Document *, BOOL)
	Exports the current selection as a bitmap, via the virtual fns of the inherited class. Do not override unless really necessary.
virtual BOOL	DoExportBitmap (Operation *, CCLexFile *, PathName *, KernelBitmap *)
	Exports the specified bitmap straight out to file with none of the rendering that DoExport does. Uses the virtual fns of the inherited class. Do not override unless really necessary.
virtual BOOL	DoExportBitmaps (Operation *, CCLexFile *, PathName *, BitmapExportParam *)
	Exports the bitmaps specified by the BitmapExportParam object to a multi- image capable filter. It works creating a special document containing a single NodeBitmap It then sets this document to use each bitmap in turn and calls DoExport to actually export it.
virtual BOOL	DoExportWithOptions (Operation *, CCLexFile *, PathName *, Document *, BitmapExportOptions *, DocRect *=NULL)
	Exports the document by using the export options passed as parameter, rather then invoking an options dialog box to obtain them.
virtual BOOL	DoExportBitmapWithOptions (Operation *, CCLexFile *, PathName *, KernelBitmap *, BitmapExportOptions *)
	Exports the specified bitmap straight out to file with none of the rendering that DoExport does. Uses the virtual fns of the inherited class. Do not override unless really necessary. Similar to DoExportBitmap in the base class, but uses the passed options, rather then invoking a dialog to get ones.
virtual BOOL	DoExportHelper (Operation *pOp, CCLexFile *pFile, PathName *pPath, Document *pDoc)
	Exports the document by using the export options passed as parameter, rather then invoking an options dialog box to obtain them.
CCLexFile *	GetImportFile ()
virtual BOOL	ImportBitmap (CCLexFile *, KernelBitmap **)
BOOL	ImportBitmap (CCLexFile *, KernelBitmap **, const UINT32 nBitmapToRead)
	Imports the nBitmapToRead'th bitmap from the given file. This may be used to import a file either via the menu or from the EPS filters.
virtual BOOL	ReadFromFile (OILBitmap *pOilBitmap)
	Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats.
virtual BOOL	ReadFromFile (OILBitmap *pOilBitmap, BaseCamelotFilter *pFilter, CCLexFile *pFile, BOOL IsCompressed)
	Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record. IsCompressed is only used for BMP/BMPZIP type bitmaps at present. Assumes: pFile has already been opened up for reading pFilter has been set up for reading the data e.g. progress bar.
void	SetPreviewBitmap (BOOL)
	Allows you to set the state of this flag. Always set it back to FALSE after the export as the filter hangs around, ready for the next export.
virtual BOOL	ExportVisibleLayersOnly ()
	Determines if the filter wants to export only visible layers. In the base bitmap filters class version the default action will be to export only those layers which are visible.
UINT32	GetImportMsgID ()
	Used to get the message id to be used during export. Virtual, so that multi-stage importers can change the message.
virtual UINT32	GetExportMsgID ()
	Used to get the message id to be used during export. Virtual, so that two stage exporters can change the message.
virtual BOOL	ShouldReuseExistingBitmaps ()
BOOL	SetExportOptions (BitmapExportOptions *pOptions)
	To allow that f!?$g MakeBitmapFilter have its wicked way.
BOOL	SetUpExportOptions (BitmapExportOptions **ppExportOptions, BOOL OnlyDefaults=FALSE)
	Displays the export options dialog for this bitmap filter. This allows export options to be obtained by somebody else then the filter.
BOOL	SetUpExportBitmapOptions (BitmapExportOptions **ppExportOptions, KernelBitmap *pBitmap, BOOL OnlyDefaults=FALSE)
	Displays the export options dialog for this bitmap filter. This allows export options to be obtained by somebody else then the filter.
virtual BOOL	IsSecondPassRequired ()
	Determines if the a second rendering pass is required or not.
virtual BOOL	GenerateOptimisedPalette (Spread *pSpread, BitmapExportOptions *pOptions, BOOL SnapToBrowserPalette)
	Generates an optimised palette to use during export.
virtual BOOL	GenerateOptimisedPalette (Spread *pSpread, UINT32 Depth, double DPI, BOOL SnapToBrowserPalette, UINT32 NumColsInPalette, BOOL UsePrimaryCols)
	Generates an optimised palette to use during export.
virtual BOOL	IsFormatLossy () const
	Provides information to the BaseBitmapFilter so that it knows whether or not to provide a BitmapSource to prevent progressive degradation of the bitmap when exported via the new file format. Notes: Derived classes should override this function for their particular implementation.
virtual BitmapSource *	CreateBitmapSource (OFFSET Size) const
	The PrepareToImport() function calls this member to create a BitmapSource for lossy file formats. The BaseBitmapFilter implementation returns NULL. Derived classes with lossy formats should override this function to provide a subclassed BitmapSource.
virtual void	ExportHTMLTag (PathName *ppthToUse)
virtual BitmapExportOptions *	CreateExportOptions () const
	Allows derived classes to override this function to provide their own class derived from BitmapExportOptions containing filter specific information. Notes: This should never be called.
BitmapExportOptions *	GetBitmapExportOptions () const
	Support function to obtain BitmapExportOptions.
virtual BOOL	GetExportOptions (BitmapExportOptions *pOptions)
	Allows the user to be prompted to get export information which should be set in the given BitmapExportOptions.
virtual void	PostGetExportOptions (BitmapExportOptions *pOptions)
virtual BOOL	SetUpClippingRectangleForExport (Spread *pSpread, SelectionType Selection)
	Sets up the class variable ClipRect to be the clipping rectangle to be used during export. See Also: PrepareToExport().
virtual BOOL	WriteBitmapToFile (KernelBitmap *pKernelBitmap, BaseCamelotFilter *pFilter, CCLexFile *pFile, INT32 Compression)
virtual BOOL	SaveExportBitmapsToFile (CCLexFile *pFile, PathName *pPath, BitmapExportParam *pParam, BOOL DontShowFileName=FALSE)
	Exports the bitmaps specified by the BitmapExportParam object to a multi- image capable filter. Each of the bitmaps will be saved to file using the settings specified. This is the baseclass version and so is usually overriden.
virtual BOOL	IsThisBppOk (UINT32 Bpp)
	Check if this Bitmap filter can cope with saving at this Bpp/Colour depth.
virtual BOOL	ExportRenderNodes (RenderRegion *pRegion, ExportDC *pDC, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE, BOOL ShowProgress=TRUE)
	Actually export the nodes to the given render region showing a progress bar as we go. Assumes everything has been set up by ExportRender. Overrides the baseclass version so that we can render in strips. Ignores the setting of ShowProgress as we must be in charge of the progress bar in this version.
virtual BOOL	GetRenderBottomToTop ()
	Find out which way we need to render.
DocRect	GetClipRect () const
BOOL	ExportImagemap (Operation *, PathName *, Document *)
virtual BOOL	CanDoImportDPI ()
virtual void	SetImportDPI (DPI ImportDPI)
Static Public Member Functions
static BOOL	InitBaseClass ()
	Initialises any static member variables for the base bitmap filter class.
static BOOL	GeneratingOptimisedPalette ()
	Find out if we are currently generating an optimised palette or not.
static KernelBitmap *	GetExportBitmap ()
static DocRect	GetSizeOfDrawing (Spread *pSpread=NULL)
	Works out the size of the rectangle encompassing the drawing. Code also used to work out the pixel size in the bitmap export options dialog box.
static DocRect	GetSizeOfSpread (Spread *pSpread)
	Works out the size of the rectangle encompassing the spread. Code also used to work out the pixel size in the bitmap export options dialog box.
static BOOL	GetSizeOfBitmap (INT32 *PixelWidth, INT32 *PixelHeight)
	Works out the size of the bitmap in the bitmap export options dialog box.
static void	CallPixelAlignedFiddle (DocRect *r)
static BOOL	GetZoomOnImport ()
static void	SetZoomOnImport (BOOL fFlag)
static BOOL	GetWarnedZoomOnImport ()
static void	SetWarnedZoomOnImport (BOOL fFlag)
Static Public Attributes
static const INT32	MinPelsPerMeter = 1000
static const INT32	MinExportSize = 10
static INT32	m_NumberOfPaletteEntries = 0
Protected Member Functions
BOOL	ExportBitmap (Operation *pOp, CCLexFile *pFile, PathName *pPath, Document *pDoc)
virtual BOOL	PrepareToImport ()
	Prepare to import bitmap data using this filter. This sets up the filter to a sensible state for reading.
virtual void	CleanUpAfterImport ()
	Cleans up the memory allocated by BaseBitmapFilter::PrepareToImport() - used when the import process ends, either normally or abnormally.
BOOL	PrepareBitmapSource ()
	The PrepareToImport() function calls this member to create a BitmapSource for lossy file formats, and a CCLexFile to work with it.
virtual OFFSET	GetDataStartOffset () const
	Provides information to the BaseBitmapFilter, so that it knows where to start any required BitmapSource. It will only be useful to derived classes that deal with a lossy file format. Notes: The default implementation returns zero, assuming there is no useless garbage before any actual header. Derived classes should override this for any special case.
virtual BitmapImportOptions *	GetImportOptions ()
	To allow a filter to offer the user a choice over what gets imported. Derived BaseBitmapFilter classes should also derive a new BitmapImportOptions class and return a new copy on the heap with the user options in it. BaseBitmapFilter will delete the BitmapImportOptions class when no longer needed. At present used by PhotoCD filter to get image to import.
virtual BOOL	ProcessImportOptions ()
	Validates the options returned by GetImportOptions Sets m_pImportOptions if OK Shouldn't really be overridden.
virtual BOOL	CreateBitmapName (const CCLexFile *pDiskFile, const KernelBitmap *pBitmap, const UINT32 nBitmapNumber)
	Sets the name of the given bitmap to that of the form "filename - number.ext" or "filename.ext" depending on whether we have assumed there to be more than one image in the imported file. Used by ImportBitmap to supply this name and avoid bizarre file names when re-exporting.
UINT32	GetBitmapNumber () const
	On entry to the filter this member function returns the number of the desired bitmap in the file. Once the import is complete, either SetBitmapNumber is called with an argument of the next bitmap that can be read or SetLastBitmap is called indicating there are no more to read. Scope: protected.
BOOL	SetLastBitmap ()
	When the bitmap filter has no more bitmaps to read from its file it should call this member function. Scope: protected.
BOOL	SetBitmapNumber (const UINT32 nBitmapToRead)
	Once a filter has read a bitmap it should call this member function with the number of the next bitmap that can be read. If there are none, SetLastBitmap() should be called instead. Scope: protected.
BOOL	AreBitmapsToRead () const
	The BaseBitmapFilter uses this to determine whether or not it should try to read another bitmap from the file. Scope: protected.
virtual BOOL	IncProgressBarCount (UINT32 n)
	Func to incrementing the progress bar count. If there is a progress bar available, it is updated by this call. Scope: Protected.
void	SetTotalProgressBarCount (UINT32 n)
	Func to set total the progress bar count. If there is a progress bar available, it is updated by this call. Scope: Protected.
void	ForceBackgroundRedrawOff (DocView *)
	Forces background redraw off in the specified view, so we render all the objects in one pass. Use RestoreBackgroundRedrawState to restore the state.
void	RestoreBackgroundRedrawState (DocView *)
	Restores the background redraw state in the specified view, to the state before we called BaseBitmapFilter::ForceBackgroundRedrawOff.
void	ForceAntialiasingFull (DocView *)
	Forces Antialiasing to be full in the specified view. Use RestoreViewQuality to restore the quality. Used when generating preview bitmaps, which should always be in full anti- aliasing mode.
void	ForceAntialiasingOff (DocView *)
	Forces Antialiasing off in the specified view. Use RestoreViewQuality to restore the quality.
void	RestoreViewQuality (DocView *)
	Restores the view quality to the state before we called ForceAntialiasingOff.
virtual BOOL	PrepareToExport (Spread *pSpread, UINT32 Depth, double DPI, SelectionType, UINT32 Dither=XARADITHER_ORDERED_GREY)
virtual void	CleanUpAfterExport ()
	Cleans up the memory allocated by BaseBitmapFilter::PrepareToImport() - used when the import process ends, either normally or abnormally. Override if extra things are required.
virtual BOOL	DoExportDoc (Operation *, CCLexFile *, PathName *, Document *, UINT32, double, const SelectionType &, BOOL UseExistingPalette=FALSE)
virtual UINT32	GetNumReservedColours ()
	Override this to leave spaces in the palette. eg the GIF filter reserves an index for the transparency mask colour.
virtual BOOL	WriteToFile (BOOL End)
	Writes out the bitmap to a file. Inherited classes override this to write in different file formats. AtEnd is ignored now and should always be set to TRUE.
virtual BOOL	EndWriteToFile ()
	Cleans up after writing the bitmap data out to a file. Inherited classes override this to write in different file formats.
virtual BOOL	WriteBitmapToFile (KernelBitmap *pKernelBitmap, double Dpi)
	Physically put the bitmap into the disk. Inherited classes override this to write in different file formats.
virtual BOOL	WriteFileHeader (void)
	To write out the file specific header data.
virtual BOOL	WritePreFrame (void)
	To write out any frame specific info before the image.
virtual BOOL	WritePostOptimisedPalette (void)
	Called after the optimised palette has been generated but before the export of the bitmap.
virtual BOOL	WritePreSecondPass (void)
	Called before the second pass of a two pass export so the filter can reset itself.
virtual BOOL	WriteFrame (void)
	To write out the image itself This base class version actually calls the WriteToFile() function so that derived classes do not have to implement any of the multi-image stuff.
virtual BOOL	WritePostFrame (void)
	To write out any frame specific info after the image.
virtual BOOL	WriteFileEnd (void)
	To write out the file specific data at the end of the file This base class version calls EndWriteToFile() so that derived classes do not have to implement the multi-image stuff.
virtual void	AlterPaletteContents (LPLOGPALETTE pPalette)
LPBITMAPINFO	GetBitmapInfo () const
BOOL	GetCurrentStripInfo (ADDR *ppBits, BMP_SIZE *pWidth, BMP_SIZE *pHeight, BMP_DEPTH *pDepth) const
CCLexFile *	GetExportFile () const
	Support function to obtain file to export in WriteBitmapToFile.
virtual BOOL	SetExportHint (Document *pDoc)
BOOL	InsertBitmapOnNewLayer (SelOperation *pOp, Spread *pSpread, NodeBitmap *pNodeBitmap, Layer **ppNewLayer)
	When loading in multiple bitmaps then each bitmap should be inserted onto a new layer. The first bitmap is inserted as the last child on the active layer. Each subsequent bitmap is loaded onto a new layer after this. The routine returns the new layer so that this can be used next time as the insertion point.
virtual BOOL	AddOffsetFromBitmap (DocCoord *pOffset)
	When loading in a bitmap, the bitmap definition may contain an offset. We need to add this to the offset that we are given so that the bitmap is loaded at the correct position. This baseclass version does nothing.
virtual BOOL	SetFlagsFromBitmap (Layer *pLayer, KernelBitmap *pBitmap, UINT32 nBitmapToRead)
	When loading in multiple bitmaps and placing them on new layers, we should give the filter an opportunity to set the layer flags from the bitmap. In the case of a GIF filter this would allow it to set the solid and overlay flags. This baseclass version does nothing.
virtual BOOL	SetAnimationPropertiesFromLoaded (Spread *pSpread)
	When loading in multiple bitmaps and placing them on new layers, we should give the filter an opportunity after all the bitmaps have been loaded, to go and look at the bitmaps and set the animation properties accordingly. In the case of a GIF filter this would allow it to set the dithering to none and the palette to something closer to what has been loaded. This baseclass version does nothing.
UINT32	GetSizeOfExport ()
void	SetSizeOfExport (UINT32 NewVal)
BMP_SIZE	GetPixelWidth () const
	Support function to obtain bitmap info.
BOOL	SetPixelWidth (const BMP_SIZE &Width)
	Support function to obtain bitmap info See Also: GetExportHeight().
BMP_SIZE	GetPixelHeight () const
	Support function to obtain bitmap info.
BOOL	SetPixelHeight (const BMP_SIZE &Height)
	Support function to obtain bitmap info See Also: GetExportHeight().
void	SetDepthToRender (const BMP_DEPTH &Depth)
BMP_DEPTH	GetRenderDepth () const
BOOL	WarnIfIncompatible ()
	Checks for things that can't be represented using the current options E.g. non-mix transparencies in Alpha channel bitmap.
Static Protected Member Functions
static LPLOGPALETTE	Create8bppPalette ()
	Creates an 8bpp palette used when generating an 8bpp bitmap Centralises common code previously found in BMP, GIF & PNG filters.
Protected Attributes
BOOL	IsPreviewBitmap
BitmapImportOptions *	m_pImportOptions
BOOL	RenderInStrips
BOOL	RenderBottomToTop
BOOL	BadExportRender
UINT32	FilterNameID
UINT32	FilterInfoID
UINT32	ExportingMsgID
CCLexFile *	InputFile
KernelBitmap *	pNewBitmap
BOOL	BackgroundRedrawState
BOOL	BackgroundRedrawStateSet
Quality	ViewQuality
BOOL	ViewQualitySet
DocRect	ClipRect
Spread *	pSpread
UINT32	PaletteType
UINT32	PreviewDither
UINT32	PreviewPalette
LPLOGPALETTE	m_pOptimisedPalette2
Static Protected Attributes
static BOOL	WrittenHeader = FALSE
static UINT32	OurNumNodes = 0
static UINT32	SizeOfExport = 100
static CCLexFile *	OutputFile = NULL
static GRenderBitmap *	ExportRegion = NULL
static KernelBitmap *	pExportBitmap = NULL
static LPLOGPALETTE	pOptimisedPalette = NULL
static BOOL	WeAreGeneratingOptPalette = FALSE
static LPLOGPALETTE	m_pBrowserPalette = NULL
static BOOL	s_fZoomOnImport = 9999
static BOOL	s_fWarnedZoomOnImport = 9999
Private Member Functions
	CC_DECLARE_DYNAMIC (BaseBitmapFilter)
ImagemapFilter *	GetImagemapFilter ()
	Gets a pointer to the imagemap filter.
Private Attributes
UINT32	m_ProgressBarCount
UINT32	m_TotalProgressBarCount
Progress *	m_pProgress
String_64	m_ProgressBarMessage
INT32	m_nBitmapToRead
BitmapSource *	m_pBitmapSource
BitmapExportOptions *	m_pExportOptions
BMP_SIZE	m_PixelWidth
BMP_SIZE	m_PixelHeight
BMP_DEPTH	m_RenderDepth
Static Private Attributes
static DPI	m_DefaultExportDPI = 96.0

---

Detailed Description

Base class for bitmap filters. (Currently export only). Inherited classes tend to be in the OIL layer. The base class fails on both imports & exports, so you only need to override the half that you implement.

Author:

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

Date:

22/8/94

Definition at line 164 of file bitfilt.h.

---

Constructor & Destructor Documentation

BaseBitmapFilter::BaseBitmapFilter (   )

Constructor for an BaseBitmapFilter object. The object should be initialised before use. Base class version. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 See also: BaseBitmapFilter::Init Definition at line 219 of file bitfilt.cpp. { OutputFile = NULL; ExportRegion = NULL; pNewBitmap = NULL; InputFile = NULL; BackgroundRedrawState = FALSE; BackgroundRedrawStateSet = FALSE; ViewQualitySet = FALSE; IsPreviewBitmap = FALSE; pExportBitmap = NULL; pSpread = NULL; m_pImportOptions = NULL; m_pExportOptions = NULL; pOptimisedPalette = NULL; WrittenHeader = FALSE;// Have we done the first strip yet RenderInStrips = TRUE; // Should we render in strips or not RenderBottomToTop = TRUE; // control over which way we render BadExportRender = FALSE;// whether the export rendering has gone ok or not SizeOfExport = 100; // defined progress bar size. OurNumNodes = 0; // our copy of the number of nodes being exported PaletteType = PAL_OPTIMISED; //Should these lines be in or out - Martin 14/04/97 PreviewDither = XARADITHER_ERROR_DIFFUSION; PreviewPalette = PAL_OPTIMISED; WeAreGeneratingOptPalette = FALSE; ClipRect.MakeEmpty(); m_pOptimisedPalette2 = NULL; m_pExportOptions = NULL; }

BaseBitmapFilter::~BaseBitmapFilter (   )

Destructor for an BaseBitmapFilter object. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 Definition at line 268 of file bitfilt.cpp. { // Clear up some dynamically allocated memory if (m_pOptimisedPalette2) { CCFree(m_pOptimisedPalette2); m_pOptimisedPalette2 = 0; } if (m_pBrowserPalette) { CCFree(m_pBrowserPalette); m_pBrowserPalette = 0; } delete m_pImportOptions; m_pImportOptions = 0; // delete m_pExportOptions; m_pExportOptions = 0; }

---

Member Function Documentation

BOOL BaseBitmapFilter::AddOffsetFromBitmap (  DocCoord *  pOffset  )  [protected, virtual]

When loading in a bitmap, the bitmap definition may contain an offset. We need to add this to the offset that we are given so that the bitmap is loaded at the correct position. This baseclass version does nothing. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/97 Parameters: pOffset  the present offset in the bitmap [INPUTS] Returns: TRUE if was ok, FALSE otherwise. Reimplemented in TI_GIFFilter. Definition at line 1246 of file bitfilt.cpp. { // Do nothing return TRUE; }

void BaseBitmapFilter::AlterPaletteContents (  LPLOGPALETTE  pPalette  )  [protected, virtual]

Reimplemented in BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4500 of file bitfilt.cpp. { return; }

BOOL BaseBitmapFilter::AreBitmapsToRead (   )  const [protected]

The BaseBitmapFilter uses this to determine whether or not it should try to read another bitmap from the file. Scope: protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 11/06/96 Parameters: -  [INPUTS] Returns: TRUE if there are bitmaps in the set OK FALSE otherwise See also: GetBitmapNumber(), SetBitmapNumber(), SetLastBitmap() Definition at line 1634 of file bitfilt.cpp. { return (m_nBitmapToRead != -1); }

void BaseBitmapFilter::CallPixelAlignedFiddle (  DocRect *  r  )  [static]

Definition at line 5180 of file bitfilt.cpp. { PixelAlignedFiddle( r ); }

virtual BOOL BaseBitmapFilter::CanDoImportDPI (   )  [inline, virtual]

Reimplemented in ImageMagickFilter. Definition at line 308 of file bitfilt.h. { return FALSE; }

BaseBitmapFilter::CC_DECLARE_DYNAMIC (  BaseBitmapFilter   )  [private]

void BaseBitmapFilter::CleanUpAfterExport (   )  [protected, virtual]

Cleans up the memory allocated by BaseBitmapFilter::PrepareToImport() - used when the import process ends, either normally or abnormally. Override if extra things are required. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 See also: BaseBitmapFilter::PrepareToImport; BaseBitmapFilter::DoImport Scope: Private Reimplemented in JPEGExportFilter, MakeBitmapFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 2342 of file bitfilt.cpp. { #ifdef DO_EXPORT // Get rid of our dynamic objects if (OutputFile) { OutputFile = NULL; } DocView *View = DocView::GetCurrent(); if (View) { if( ViewQualitySet ) { // Only need to do this if the view quality has been set but not restored. RestoreViewQuality(View); } } if (ExportRegion) { // If we have create the export region then delete it delete ExportRegion; ExportRegion = NULL; // Must try and set our background rendering state back to the default DocView *View = DocView::GetCurrent(); if (View) { // Force background back to its entry state RestoreBackgroundRedrawState(View); } } if (pOptimisedPalette) { CCFree( pOptimisedPalette ); pOptimisedPalette = NULL; } #endif }

void BaseBitmapFilter::CleanUpAfterImport (   )  [protected, virtual]

Cleans up the memory allocated by BaseBitmapFilter::PrepareToImport() - used when the import process ends, either normally or abnormally. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 See also: BaseBitmapFilter::PrepareToImport; BaseBitmapFilter::DoImport Scope: Private Definition at line 579 of file bitfilt.cpp. { TheDocument = NULL; //WEBSTER-Martin-02/01/97 #ifndef WEBSTER #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // Reset the filter type used by the Accusoft filters so that it can cache the // filter type correctly and so only call the Accusoft DLL on the first filter // rather than on all filters. AccusoftFilters::ResetFilterType(); #endif #endif //WEBSTER }

LPLOGPALETTE BaseBitmapFilter::Create8bppPalette (   )  [static, protected]

Creates an 8bpp palette used when generating an 8bpp bitmap Centralises common code previously found in BMP, GIF & PNG filters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/97 Returns: A pointer to a 8bpp palette The palette returned is created using CCMalloc(). The caller should use CCFree() to discard the returned palette object when no longer needed. Introduced for WEBSTER - markn 8/2/97. Made static so that the Accusoft filter can use it Notes: Definition at line 4826 of file bitfilt.cpp. { /* LPLOGPALETTE lpPalette = NULL; GDrawContext *GDC = GRenderRegion::GetDrawContext(); if (GDC != NULL) { // This should return a palette plus tell it what dithering we require // 0 = dither, not 0 for no dithering. LPLOGPALETTE lpGavPalette = GDC->SelectPalette( 0 ); if (lpGavPalette != NULL) { const size_t TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 ); lpPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (lpPalette != NULL) { // Take a copy of that palette memcpy( lpPalette, lpGavPalette, TotalPal ); // Always make 'browser' palette instead of 'standard' palette // - Harrison 8/10/97 PaletteManager::MakePaletteBrowserCompatible(lpPalette,TRUE); } } } ERROR3IF(lpPalette == NULL, "Didnt get a palette"); // The section of code below is used when the user has deleted 1 or more colours, and then // clicked on 'Preview'. // Have to change the palette here before it is used to decide which palette colours // match each pixel in the image. if( ( BmapPrevDlg::GetNumberOfDeletedColours() ) && ( BmapPrevDlg::m_bUseExistingPalette ) ) { BOOL Deleted = FALSE; INT32 NewIndex = -1; INT32 Popularity = 0; // Go through the palette in BmapPrevDlg. for( INT32 PaletteIndex = 0; PaletteIndex < ( lpPalette->palNumEntries ); PaletteIndex++ ) { // Has this colour been deleted by the user? Deleted = BmapPrevDlg::IsThisColourDeleted( PaletteIndex ); if( Deleted ) { // If this colour has been deleted, then we need to get its // original palette order. NewIndex = BmapPrevDlg::GetOriginalPaletteOrder( PaletteIndex ); // Set flags to 255 to tell the system that this colour is not // to be used in generating the exported image. lpPalette->palPalEntry[NewIndex].peFlags = 255; } else { // Not deleted, but is the popularity of this colour = 0? Popularity = BmapPrevDlg::GetPopularityValueForColour( PaletteIndex ); if( Popularity <= 0 ) { NewIndex = BmapPrevDlg::GetOriginalPaletteOrder( PaletteIndex ); lpPalette->palPalEntry[NewIndex].peFlags = 255; } } } } ExtendedPalette LockedColoursInformation; if( BmapPrevDlg::GotLockedColours() && lpPalette) { // Copy all the locked colours information over. LockedColoursInformation = BmapPrevDlg::m_LockedColoursPalette; ExtendedPalette LockedColoursInformation2 = BmapPrevDlg::m_LockedColoursPalette2; // Go through all the locked colours that we have for( INT32 i = 0; i < LockedColoursInformation.NumberOfColours; i++ ) { // Make sure that we are not exceeding the number of colours in the current palette. if( i >= ( lpPalette->palNumEntries ) ) continue; // We want to find the nearest colour in the current palette to this locked colour. double SmallestDistance = 0.0; BOOL FirstDistanceCalc = TRUE; INT32 ClosestColourIndex = 0; // Some variables needed below INT32 Red1, Green1, Blue1; INT32 Red2, Green2, Blue2; double RedDistance, GreenDistance, BlueDistance; double Distance; INT32 LockedIndex = LockedColoursInformation.Data[ i ].ExtraInformation; Red1 = LockedColoursInformation2.Data[ LockedIndex ].Red; Green1 = LockedColoursInformation2.Data[ LockedIndex ].Green; Blue1 = LockedColoursInformation2.Data[ LockedIndex ].Blue; // Go through all the colours in the current palette. for( INT32 j = 0; j < lpPalette->palNumEntries; j++ ) { // The components of the palette colour we are looking at. Red2 = lpPalette->palPalEntry[j].peRed; Green2 = lpPalette->palPalEntry[j].peGreen; Blue2 = lpPalette->palPalEntry[j].peBlue; // Calculate the distance between each of the colour components // ( Actually the square of this value - this does not matter since we // are not interested in the absolute values, only relative ones ). RedDistance = pow( double( Red1 - Red2 ), 2 ); GreenDistance = pow( double( Green1 - Green2 ), 2 ); BlueDistance = pow( double( Blue1 - Blue2 ), 2 ); // The overall distance. Distance = ( INT32 )( RedDistance + GreenDistance + BlueDistance ); if( FirstDistanceCalc ) { // First time around, so 'Distance' must be closest yet // However, there may be an occasion where this colour is already being used by one of // the existing locked colours. In this case, we just want to completely ignore this // colour, and carry on with the next loop BOOL BeingUsed = FALSE; for( INT32 Index = 0; Index < i; Index++ ) { if( LockedColoursInformation.Data[ Index ].ExtraInformation == j ) BeingUsed = TRUE; } // If it is being used, don't do anything. if( !BeingUsed ) { FirstDistanceCalc = FALSE; SmallestDistance = Distance; ClosestColourIndex = j; } } else if( Distance <= SmallestDistance ) { // Smallest distance so far? if so remember the distance & index // Do this only if this index is not being used by another locked colour // already. To do this, have to look through the currently assigned locked // colour indices. If this index is being used, then just do nothing. BOOL BeingUsed = FALSE; for( INT32 Index = 0; Index < i; Index++ ) { if( LockedColoursInformation.Data[ Index ].ExtraInformation == j ) BeingUsed = TRUE; } if( !BeingUsed ) { SmallestDistance = Distance; ClosestColourIndex = j; } } } // Put the colour index into the locked colour palette INT32 Information = LockedColoursInformation.Data[ i ].ExtraInformation; // Update the palette which holds the original values of the locked colours. INT32 r = BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Red; INT32 g = BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Green; INT32 b = BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Blue; BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Red = BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Red; BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Green = BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Green; BmapPrevDlg::m_LockedColoursPalette2.Data[ ClosestColourIndex ].Blue = BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Blue; BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Red = r; BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Green = g; BmapPrevDlg::m_LockedColoursPalette2.Data[ Information ].Blue = b; BmapPrevDlg::m_LockedColoursPalette.Data[ i ].ExtraInformation = ClosestColourIndex; LockedColoursInformation = BmapPrevDlg::m_LockedColoursPalette; } } return lpPalette; */ return NULL; }

BOOL BaseBitmapFilter::CreateBitmapName (  const CCLexFile *  pDiskFile, const KernelBitmap *  pBitmap, const UINT32  nBitmapNumber )  [protected, virtual]

Sets the name of the given bitmap to that of the form "filename - number.ext" or "filename.ext" depending on whether we have assumed there to be more than one image in the imported file. Used by ImportBitmap to supply this name and avoid bizarre file names when re-exporting. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 18/06/96 Parameters: pDiskFile  : file from which the bitmap was extracted [INPUTS] pBitmap : the bitmap itself nBitmapNumber : the number of the bitmap in the file -  [OUTPUTS] Returns: TRUE if name set OK, FALSE if failed. Errors: ERROR2 for invalid arguments ERROR3 if pDiskFile is not a kind of CCDiskFile Notes: Suppose we should really set the names after when we know that there actually are multiple bitmaps Definition at line 1469 of file bitfilt.cpp. { ERROR2IF(pDiskFile == NULL, FALSE, "pDiskFile - invalid"); ERROR2IF(pBitmap == NULL, FALSE, "pBitmap - invalid"); PathName Path = pDiskFile->GetPathName(); if (!Path.IsValid()) { TRACE( _T("Invalid file path in BaseBitmapFilter::CreateBitmapName\n") ); return FALSE; } String_256 Str; if ((nBitmapNumber > 1) || AreBitmapsToRead()) { // give it a number ? String_256 shortName = Path.GetFileName(FALSE); // without extension String_16 index; Convert::LongToString(INT32(nBitmapNumber), &index); Str.MakeMsg(_R(IDS_BITMAP_NAME), (TCHAR*)shortName, (TCHAR*)index); Path.SetFileName(Str); } Str = Path.GetFileName(TRUE); // with extension pBitmap->ActualBitmap->SetName(Str); return TRUE; }

BitmapSource * BaseBitmapFilter::CreateBitmapSource (  OFFSET  Size  )  const [virtual]

The PrepareToImport() function calls this member to create a BitmapSource for lossy file formats. The BaseBitmapFilter implementation returns NULL. Derived classes with lossy formats should override this function to provide a subclassed BitmapSource. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 21/08/96 Parameters: Size,:  The required size of the BitmapSource [INPUTS] Returns: A pointer to a new BitmapSource See also: IsFormatLossy() Scope: protected Reimplemented in JPEGImportFilter. Definition at line 464 of file bitfilt.cpp. { return NULL; }

BitmapExportOptions * BaseBitmapFilter::CreateExportOptions (   )  const [virtual]

Allows derived classes to override this function to provide their own class derived from BitmapExportOptions containing filter specific information. Notes: This should never be called. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: A pointer to a new BitmapExportOptions class Reimplemented in JPEGExportFilter, MakeBitmapFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4797 of file bitfilt.cpp. { TRACE( _T("BaseBitmapFilter::CreateExportOptions() called\n")); BitmapExportOptions* pOptions = new BitmapExportOptions(_R(IDD_EXPORTBMPOPTS), FilterType(FilterID), &FilterName); return pOptions; }

BOOL BaseBitmapFilter::DoExport (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, Document *  pDoc, BOOL  ShowOptions )  [virtual]

Exports the current selection as a bitmap, via the virtual fns of the inherited class. Do not override unless really necessary. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 22/8/94 Parameters: pOp  - the operation that started the export off [INPUTS] pDiskFile - the file to put the exported data into pPath - the pathname of the file to be exported to pDoc - the document to export Returns: TRUE if worked, FALSE if failed. See also: GetExportOptions; PrepareToExport; ExportRenderNodes; CleanUpAfterExport; Reimplemented from Filter. Reimplemented in PreviewFilterBMP, PreviewFilterGIF, PreviewFilterJPEG, PreviewFilterPNG, and ThumbnailFilterPNG. Definition at line 2422 of file bitfilt.cpp. { // The success / failure flag. BOOL ok = TRUE; // smfix put back more or less this should be only used by the preview filters #ifdef DO_EXPORT // Dreamweaver integration. // BOOL bDesignNotesSelectedValue = FALSE; ERROR2IF(pOp == NULL, FALSE,"BaseBitmapFilter::DoExport no export operation"); ERROR2IF(pFile == NULL, FALSE,"BaseBitmapFilter::DoExport no file to export to"); ERROR2IF(pPath == NULL, FALSE,"BaseBitmapFilter::DoExport no export pathname"); ERROR2IF(pDoc == NULL, FALSE,"BaseBitmapFilter::DoExport no document to export"); // Set the bitmap pointer to null just in case, usually only used by DoExportBitmap pExportBitmap = NULL; // Get pointer to the spread to export. PORTNOTE("spread", "Multi-spread warning!") pSpread = GetFirstSpread(pDoc); ERROR2IF(pSpread == NULL, FALSE,"BaseCamelotFilter::DoExport no spread to export"); // We must now check if there is a selection present so that we can set up whether the // user gets the choice of exporting the selection, drawing or spread if there is a // selection present OR just a choice between the spread or drawing if no selection is // present. // If have a caret selected in a text story then the selection will be almost zero so // trap this case as well. ClipRect = GetApplication ()->FindSelection ()->GetBoundingRect(TRUE); SelectionType Selection = DRAWING; // Determine the selection type. if ( !IsPreviewBitmap && !ClipRect.IsEmpty() && ClipRect.Width() >= MinExportSize && ClipRect.Height() >= MinExportSize ) { Selection = SELECTION; // Something is selected, so use this. } else // The selection is either too small to export, or the clipping rectangle is empty. { // Work out the size of the rectangle encompassing the drawing (visible layers only). ClipRect = GetSizeOfDrawing(pSpread); // Check that that cliprect is ok, if not then set the spread as the export type. if ( ClipRect.IsEmpty() || ClipRect.Width() < MinExportSize || ClipRect.Height() < MinExportSize ) Selection = SPREAD; } // If there is no selection then warn the user that exporting the current spread may // take a lot of disc space, but only if this is not a Preview Bitmap. if ((!IsPreviewBitmap) && (Selection == SPREAD)) { // Warn the user that there is no selection = large export ErrorInfo Info; Info.ErrorMsg = _R(IDT_BMPEXP_NOSELECTION); Info.Button[0] = _R(IDB_EXPQUERY_EXPORT); Info.Button[1] = _R(IDB_EXPQUERY_DONTEXPORT); if ((ResourceID)(AskQuestion(&Info)) == _R(IDB_EXPQUERY_DONTEXPORT)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel ok = FALSE; } } // Mark H 18/12/00 // From here on, I`ve tidied up the code so that this function is responsible for it`s // own Bitmap Export Options pointer and not reliant on the member variable. This fixes //a 1.5MB!!! memory leak on exiting of the program! // Create a new Bitmap Export Options pointer for the current filter BitmapExportOptions* pExportOptions = CreateExportOptions(); // Try to create the export options. if (ok && pExportOptions) { pExportOptions->RetrieveDefaults(); pExportOptions->SetSelectionType(Selection); pExportOptions->SetBackgroundTransparency(FALSE); } else ok = FALSE; //Graham W 3/7/97: Tell the preview dialog what the path to save out to is BmapPrevDlg::m_pthExport=*pPath; if(ok) ok = GetExportOptions(pExportOptions); // This pointer is used to call the ExportBitmap function. If the filetype has changed, // then it will be set-up to be invoked from the new type. BaseBitmapFilter *pFilter = this; // Write out the bitmap. if (ok) { if (!pFilter->DoExportWithOptions(pOp, pFile, pPath, pDoc, pExportOptions)) { // Export failed, therefore no valid export options. Error::SetError(_R(IDN_USER_CANCELLED),0); } } // Clear up the existing bitmap options. if(pExportOptions) { delete pExportOptions; pExportOptions = NULL; } #endif return ok; }

BOOL BaseBitmapFilter::DoExportBitmap (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, KernelBitmap *  pBitmap )  [virtual]

Exports the specified bitmap straight out to file with none of the rendering that DoExport does. Uses the virtual fns of the inherited class. Do not override unless really necessary. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/95 Parameters: [INPUTS]  Returns: TRUE if worked, FALSE if failed. Definition at line 2662 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null bitmap pointer specified"); // Note this pointer for later use pExportBitmap = pBitmap; // Note this ptr for use in JPEG export. JPEGExportOptions::SetKernelBitmap(pBitmap); // Get a pointer to the actual bitmap so that we can get some details from it. OILBitmap *pOilBitmap = pBitmap->ActualBitmap; ERROR2IF(pOilBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null oil bitmap pointer"); // Create a record of information about the export m_pExportOptions = CreateExportOptions(); if (m_pExportOptions == NULL) { return FALSE; } // Get the default settings GetBitmapExportOptions()->RetrieveDefaults(); // Specify to the user what the export options for depth etc are going to be GetBitmapExportOptions()->SetSelectionType(ABITMAP); // Get the details from the specified bitmap BitmapInfo BmInfo; pOilBitmap->GetInfo(&BmInfo); GetBitmapExportOptions()->SetDepth(BmInfo.PixelDepth); // get the bitmaps bpp // Should really save the dpi when we load the file itself rather than doing // all this conversion with possible rounding errors. // Use the original size that has been calculated in the info header UINT32 PixWidth = BmInfo.PixelWidth; // UINT32 PixHeight = BmInfo.PixelHeight; MILLIPOINT RecWidth = BmInfo.RecommendedWidth; // MILLIPOINT RecHeight = BmInfo.RecommendedHeight; if (PixWidth > 0) { GetBitmapExportOptions()->SetDPI((PixWidth * 72000.0)/(double)RecWidth); } // WEBSTER - markn 5/2/97 // If the bitmap has a transparent colour index, store it in the options object // -1 means no transparent colour INT32 TransIndex = -1; if (!pBitmap->GetTransparencyIndex(&TransIndex)) TransIndex = -1; GetBitmapExportOptions()->SetTransparencyIndex(TransIndex); BOOL ok = TRUE; /* It used to call the export options dlg here - but why bother just export as is BOOL ok = GetExportOptions(GetBitmapExportOptions()); if (!ok) { delete m_pExportOptions; m_pExportOptions = 0; Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel return FALSE; // if cancelled } if (GetBitmapExportOptions()->HasTempFile()) { // the export options preview dialog has produced a temp file, so just rename that // get the temp file name PathName TempPath = GetBitmapExportOptions()->GetPathName(); String_256 FinalName = pPath->GetPath(); String_256 TempName = TempPath.GetPath(); if (pFile->isOpen()) pFile->close(); // delete the empty file, if one was created FileUtil::DeleteFile(pPath); // try to rename the file if (_trename(TempName, FinalName) != 0) ok = FALSE; else ok = TRUE; } else */ { // Used to open the file up before starting DoExport. But this meant a cancel on the export // options dialog had filled the file, if it was already present. So now up up here if // not open already. In the PreviewBitmap case the file will already be open. if (!pFile->isOpen()) { if (pFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { ok = OpenExportFile((CCDiskFile*) pFile, pPath); if (!ok) return FALSE; } else { TRACEUSER( "JustinF", _T("Tried to open non-CCDiskFile in BaseBitmapFilter::DoExportBitmap\n") ); return FALSE; } } // Make a note of the Disk file we are to use OutputFile = pFile; // We do not use an export region so specify null. ExportRegion = NULL; // Actually write to the file, showing progress hourglass as we go ok = WriteBitmapToFile(pBitmap, GetBitmapExportOptions()->GetDPI()); if (ok) WriteFileEnd(); } // All done - deallocate dynamic objects, stop the progress display/hourglass // and return success. (Also closes file). CleanUpAfterExport(); // we created these here so we should delete them delete m_pExportOptions; m_pExportOptions = NULL; return ok; #else return FALSE; #endif }

BOOL BaseBitmapFilter::DoExportBitmaps (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, BitmapExportParam *  pParam )  [virtual]

Exports the bitmaps specified by the BitmapExportParam object to a multi- image capable filter. It works creating a special document containing a single NodeBitmap It then sets this document to use each bitmap in turn and calls DoExport to actually export it. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 11/6/96 Parameters: [INPUTS]  Returns: TRUE if worked, FALSE if failed. Definition at line 2817 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pOp == NULL || pFile == NULL || pPath == NULL, FALSE,"NULL Parameters"); ERROR2IF(pParam == NULL,FALSE,"BaseBitmapFilter::DoExportBitmaps null BitmapExportParam specified"); // Create an object so we can ask the user for some options if (m_pExportOptions) delete m_pExportOptions; m_pExportOptions = CreateExportOptions(); if (m_pExportOptions == NULL) return FALSE; // Get the first bitmap pointer KernelBitmap* pBitmap = pParam->GetBitmap(0); ERROR2IF(pBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmaps has no bitmaps to export"); pExportBitmap = pBitmap; // Get a pointer to the actual bitmap so that we can get some details from it. OILBitmap *pOilBitmap = pBitmap->ActualBitmap; ERROR2IF(pOilBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmaps null oil bitmap pointer"); // Specify to the user what the export options for depth etc are going to be GetBitmapExportOptions()->SetSelectionType(SOMEBITMAPS); GetBitmapExportOptions()->SetBitmapExportParam(pParam); // Get the defaults from the first bitmap BitmapInfo BmInfo; pOilBitmap->GetInfo(&BmInfo); GetBitmapExportOptions()->SetDepth(BmInfo.PixelDepth); // get the bitmaps bpp // Calculate the millipoint size from the pixel size assuming 96 dpi double DPI = 96.0; MILLIPOINT RecWidth = (MILLIPOINT) ((((double)BmInfo.PixelWidth * 72000.0) / DPI) + 0.5); MILLIPOINT RecHeight = (MILLIPOINT) ((((double)BmInfo.PixelHeight * 72000.0) / DPI) + 0.5); // Create a Coord for GetExportOptions GetBitmapExportOptions()->SetOutputSize(RecWidth, RecHeight); BOOL ok = GetExportOptions(GetBitmapExportOptions()); if (!ok) { delete m_pExportOptions; m_pExportOptions = NULL; Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel return FALSE; // if cancelled } // Used to open the file up before starting DoExport. But this meant a cancel on the export // options dialog had filled the file, if it was already present. So now up up here if // not open already. In the PreviewBitmap case the file will already be open. if (!pFile->isOpen()) { if (pFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { ok = OpenExportFile((CCDiskFile*) pFile, pPath); if (!ok) return FALSE; } else { TRACEUSER( "JustinF", _T("Tried to open non-CCDiskFile in BaseBitmapFilter::DoExportBitmaps\n") ); return FALSE; } } // Make a note of the Disk file we are to use OutputFile = pFile; // Make sure the Region pointer is NULL for the time being ExportRegion = NULL; // TODO: Rampant change to Selection GetBitmapExportOptions()->SetSelectionType(DRAWING); // Output the file header if (!WriteFileHeader()) { CleanUpAfterExport(); return(FALSE); } // Remember the current document as we are just about to use a new document and // then delete it. Of course, systems like the bitmap system may just decide to // change current document just to screw things up. Put back before the end as the // EndOp will broadcast a message causing controls to update which require current // document to get the units list correctly. Document *pOldCurrent = Document::GetCurrent(); // Create a document for the export BitmapExportDocument* pDoc = new BitmapExportDocument; if (pDoc != NULL) { if (!pDoc->Init(pBitmap, DocRect(0, 0, GetBitmapExportOptions()->GetOutputSize().x, GetBitmapExportOptions()->GetOutputSize().y))) { TRACEUSER( "Gerry", _T("BitmapExportDocument::Init() failed\n") ); delete pDoc; pDoc = NULL; CleanUpAfterExport(); if (pOldCurrent != NULL) pOldCurrent->SetCurrent(); return(FALSE); } // Get pointer to the spread to export. PORTNOTE("spread", "Multi-spread warning!") pSpread = GetFirstSpread(pDoc); UINT32 BitmapCount = pParam->GetBitmapCount(); for (UINT32 Index = 0; ok && (Index < BitmapCount); Index++) { // Get the bitmap pointer pBitmap = pParam->GetBitmap(Index); // We have to render the bitmap so... // Update the BitmapExportDocument pDoc->SetBitmap(pBitmap); // Export the document // If it fails then break out of the image loop ok = DoExportDoc( pOp, pFile, pPath, pDoc, GetRenderDepth(), GetBitmapExportOptions()->GetDPI(), GetBitmapExportOptions()->GetSelectionType()); if (ExportRegion != NULL) { delete ExportRegion; ExportRegion = NULL; } if (pOptimisedPalette != NULL) { CCFree( pOptimisedPalette ); pOptimisedPalette = NULL; } } delete pDoc; pDoc = NULL; } // Write any end of file stuff if (ok) ok = WriteFileEnd(); // All done - deallocate dynamic objects, stop the progress display/hourglass // and return success. (Also closes file). CleanUpAfterExport(); // Ensure that we return CurrentDoc to its original value // Leave QuickShape tool with item selected before exporting animated gif from bitmap // gallery. Convert/Unit system blows up as using current doc! if (pOldCurrent != NULL) pOldCurrent->SetCurrent(); return ok; #endif return FALSE; }

BOOL BaseBitmapFilter::DoExportBitmapWithOptions (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, KernelBitmap *  pBitmap, BitmapExportOptions *  pOptions )  [virtual]

Exports the specified bitmap straight out to file with none of the rendering that DoExport does. Uses the virtual fns of the inherited class. Do not override unless really necessary. Similar to DoExportBitmap in the base class, but uses the passed options, rather then invoking a dialog to get ones. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 25/7/97 Parameters: [INPUTS]  Returns: TRUE if worked, FALSE if failed. Reimplemented in JPEGExportFilter. Definition at line 3467 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null bitmap pointer specified"); if (pOptions == NULL) { // Create a record of information about the export SetUpExportBitmapOptions(&pOptions, pBitmap, TRUE); if (pOptions == NULL) return FALSE; } // remember the old export options BitmapExportOptions *pOldOptions = GetBitmapExportOptions(); if (pOldOptions != NULL) pOldOptions->RetrieveDefaults(); // set the new ones SetExportOptions(pOptions); pOptions->SetAsDefaults(); // Make a note of the Disk file we are to use OutputFile = pFile; // Note this pointer for later use pExportBitmap = pBitmap; // Note this ptr for use in JPEG export. JPEGExportOptions::SetKernelBitmap(pBitmap); // Get a pointer to the actual bitmap so that we can get some details from it. OILBitmap *pOilBitmap = pBitmap->ActualBitmap; ERROR2IF(pOilBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null oil bitmap pointer"); // Get the details from the specified bitmap BitmapInfo BmInfo; pOilBitmap->GetInfo(&BmInfo); GetBitmapExportOptions()->SetDepth(BmInfo.PixelDepth); // get the bitmaps bpp // Should really save the dpi when we load the file itself rather than doing // all this conversion with possible rounding errors. // Use the original size that has been calculated in the info header UINT32 PixWidth = BmInfo.PixelWidth; // UINT32 PixHeight = BmInfo.PixelHeight; MILLIPOINT RecWidth = BmInfo.RecommendedWidth; // MILLIPOINT RecHeight = BmInfo.RecommendedHeight; if (PixWidth > 0) { //DPI = Mul32Div32( PixWidth, 72000, RecWidth ); GetBitmapExportOptions()->SetDPI((PixWidth * 72000.0)/(double)RecWidth); } BOOL ok = TRUE; // Used to open the file up before starting DoExport. But this meant a cancel on the export // options dialog had filled the file, if it was already present. So now up up here if // not open already. In the PreviewBitmap case the file will already be open. if (!pFile->isOpen()) { if (pFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { ok = OpenExportFile((CCDiskFile*) pFile, pPath); if (!ok) return FALSE; } else { TRACEUSER( "JustinF", _T("Tried to open non-CCDiskFile in BaseBitmapFilter::DoExportBitmap\n") ); return FALSE; } } // Make a note of the Disk file we are to use OutputFile = pFile; // We do not use an export region so specify null. ExportRegion = NULL; // Actually write to the file, showing progress hourglass as we go ok = WriteBitmapToFile(pBitmap, GetBitmapExportOptions()->GetDPI()); if (ok) WriteFileEnd(); // All done - deallocate dynamic objects, stop the progress display/hourglass // and return success. (Also closes file). CleanUpAfterExport(); // restore the old export options if (pOldOptions != NULL) { SetExportOptions(pOldOptions); pOldOptions->SetAsDefaults(); } // restore the file OutputFile = pFile; return ok; #else return FALSE; #endif }

BOOL BaseBitmapFilter::DoExportDoc (  Operation *  , CCLexFile *  , PathName *  , Document *  , UINT32  , double  , const SelectionType &  , BOOL  UseExistingPalette = FALSE )  [protected, virtual]

Definition at line 2560 of file bitfilt.cpp. { #ifdef DO_EXPORT if (!WritePreFrame()) return(FALSE); /* // Only try to do the exact palette if we are using an 8 bit optimised palette if( ( PaletteType == 1 ) && ( GetBitmapExportOptions()->GetDepth() == 8 ) ) GRenderOptPalette::UseOldPalette = FALSE; else GRenderOptPalette::UseOldPalette = TRUE; */ // Set up device context and render region for this export. // This will show a progress hourglass for the objects being rendered // This will now also write the data out to file via our ExportRenderNodes function if (!PrepareToExport(pSpread, RenderDepth, DPI, Selection)) { return FALSE; } // SMFIX // this is where we will build up the palette from the export options IF the one // that is already in the export options is NOT valid // the fn bellow export render needs the palette to be valid // m_pExportOptions->CreateValidPalette(); // this call sets this palette in the lower reaches of the code from the palette held in the export options // AlterPaletteContents(m_pExportOptions->GetLogicalPalette()); // Export the data to the file ensuring we render in strips, if required. RenderInStrips = TRUE; if (!ExportRender(ExportRegion)) { // SMFIX - Make sure we reset the StripStart as it could stuff up further operations. m__StripStart = 0; return FALSE; } //SMFIX was calling AlterPaletteContents( lpPalette ); on a palette that it built here // Ask the filter if it requires a second pass export render. This might be used for // say preparing a mask for transparency or something. Used by the GIF filter for this // purpose. /* if (IsSecondPassRequired()) { WritePreSecondPass(); // Set up device context and render region for this export. // This will show a progress hourglass for the objects being rendered // This will now also write the data out to file via our ExportRenderNodes function if (!PrepareToExport(pSpread, RenderDepth, DPI, Selection)) { return FALSE; } // Export the data to the file esnuring we render in strips, if required. RenderInStrips = TRUE; if (!ExportRender(ExportRegion)) { return FALSE; } } */ if (!WritePostFrame()) { // SMFIX - Make sure we reset the StripStart as it could stuff up further operations. m__StripStart = 0; return FALSE; } // SMFIX - Make sure we reset the StripStart as it could stuff up further operations. m__StripStart = 0; #endif return TRUE; }

BOOL BaseBitmapFilter::DoExportHelper (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, Document *  pDoc )  [virtual]

Exports the document by using the export options passed as parameter, rather then invoking an options dialog box to obtain them. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (from Stefan) Date: 24/03/2004 Parameters: pOp  - the operation that started the export off [INPUTS] pFile - the file to put the exported data into pPath - the pathname of the file to be exported to pDoc - the document to export Returns: TRUE if worked, FALSE if failed. Definition at line 3254 of file bitfilt.cpp. { // Used to open the file up before starting DoExport. But this meant a cancel on the export // options dialog had filled the file, if it was already present. So now up up here if // not open already. In the PreviewBitmap case the file will already be open. if ( !pFile->isOpen() && pFile->IsKindOf ( CC_RUNTIME_CLASS ( CCDiskFile ) ) && !OpenExportFile ( static_cast<CCDiskFile*> ( pFile ), pPath) ) { return FALSE; } WrittenHeader = 0; SetDepthToRender(32); // set the palette type which might get changed during the preview if (m_pExportOptions->IS_KIND_OF(BMPExportOptions)) { PaletteType = ((BMPExportOptions *)m_pExportOptions)->GetPalette() ? 1 : 0; // 1 for an optimised palette BMPFilter::SetDefaultExportDPI(m_pExportOptions->GetDPI()); BMPFilter::SetDefaultExportDepth(m_pExportOptions->GetDepth()); PORTNOTE("filter", "Removed use fo GIFFilter") #ifndef EXCLUDE_FROM_XARALX // Need to set the dither for the accusoft filter here, otherwise the dither // changes by the user will not have any effect AccusoftFilters::SetDitherToUse(m_pExportOptions->GetDither()); #endif } else if (m_pExportOptions->IS_KIND_OF(MaskedFilterExportOptions)) { PaletteType = ((MaskedFilterExportOptions *)m_pExportOptions)->GetPalette() ? 1 : 0;// 1 for an optimised palette } // set the render depth, which might change during the preview switch (m_pExportOptions->GetFilterType()) { PORTNOTE("filter", "Removed use fo GIFFilter") #ifndef EXCLUDE_FROM_XARALX case TI_GIF: if (m_pExportOptions->GetDepth() > 8) m_pExportOptions->SetDepth(8); SetDepthToRender(m_pExportOptions->GetDepth()); break; #endif case JPEG: SetDepthToRender(24); break; default: SetDepthToRender(m_pExportOptions->GetDepth()); break; } //Mark Howitt, 24/10/97. Reset the FilterType variable as Importing uses this for something else! PORTNOTE("filter", "Removed use of AccusoftFilters") #if !defined(EXCLUDE_FROM_XARALX) && !defined(WEBSTER) // Andy Hills, 21-12-00 // Warning: bodge alert! // At this stage, AccusoftFilters::FilterType may contain a useful value. // E.g. 9 for TIFF_LZW. This means that AccusoftFilters can make a special // case for exporting TIFFs, and export using CTIFFWriter instead of // calling Snowbound. // For whatever reason, the following line of code replaced this value with // m_pExportOptions->m_FilterID, which since the rewrite of the export dlg // contains the value 0. // This bodge ensures that we don't overwrite AccusoftFilters::FilterType // with 0. if (m_pExportOptions->GetFilterType() != 0) AccusoftFilters::SetFilterType(m_pExportOptions->GetFilterType()); #endif // Make a note of the Disk file we are to use OutputFile = pFile; // Actually export the document BOOL ok = WriteFileHeader(); // Do we want to use the existing palette, or generate a new one? The // value of BmapPrevDlg::m_bUseExistingPalette determines whether or // not one is needed to be generated, so no need to use any switch // logic. if ( ok ) { ok = DoExportDoc( pOp, pFile, pPath, pDoc, GetRenderDepth (), m_pExportOptions->GetDPI (), m_pExportOptions->GetSelectionType (), BmapPrevDlg::m_bUseExistingPalette ); } ok &= WriteFileEnd(); // pOptimised memory freed here. CleanUpAfterExport(); return ok; }

BOOL BaseBitmapFilter::DoExportWithOptions (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, Document *  pDoc, BitmapExportOptions *  pOptions, DocRect *  pRect = NULL )  [virtual]

Exports the document by using the export options passed as parameter, rather then invoking an options dialog box to obtain them. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/97 Parameters: pOp  - the operation that started the export off [INPUTS] pFile - the file to put the exported data into pPath - the pathname of the file to be exported to pDoc - the document to export pOptions - the bitmap export options to use when exporting. The options are deleted after the export, so if you want to keep them make a copy first. Returns: TRUE if worked, FALSE if failed. Definition at line 3130 of file bitfilt.cpp. { ERROR2IF(pOp == NULL, FALSE,"BaseBitmapFilter::DoExport no export operation"); ERROR2IF(pFile == NULL, FALSE,"BaseBitmapFilter::DoExport no file to export to"); ERROR2IF(pPath == NULL, FALSE,"BaseBitmapFilter::DoExport no export pathname"); ERROR2IF(pDoc == NULL, FALSE,"BaseBitmapFilter::DoExport no document to export"); // Have any valid export options been passed in? if (pOptions == NULL) { // Create a record of information about the export. SetUpExportOptions(&m_pExportOptions, TRUE); if (m_pExportOptions == NULL) return FALSE; } else { // Copy the existing export options. //m_pExportOptions = pOptions->MakeCopy (); m_pExportOptions = pOptions; // rather point at the options passed in } // set up the pSpread PORTNOTE("spread", "Multi-spread warning!") pSpread = GetFirstSpread(pDoc); // deal with no selection SelRange* pSelection = GetApplication()->FindSelection(); // deal with exporting no selection as the drawing if (pRect == NULL && pSelection->Count() == 0 && (m_pExportOptions->GetSelectionType() == SELECTION)) m_pExportOptions->SetSelectionType(DRAWING); if (pRect != NULL) // Force the cliping rect for the image to be the one passed in // and not just defined by the selection! sjk { ClipRect = *pRect; } else { // reassign the clipping rectangle to the selection's bounding rect SetUpClippingRectangleForExport(pSpread, m_pExportOptions->GetSelectionType()); // Set the page limits to drawing if thats whats requested if (pSpread && m_pExportOptions->IsClipToPage() ) { Page *pPage = pSpread->FindFirstPageInSpread(); if (pPage) ClipRect = pPage->GetPageRect(); } // to use SJK's new fiddle the rect to maintain the antialiasing // as seen on screen call the function bellow // If you want it to work like it did in CX2 comment the line out if( m_pExportOptions->GetAntiAliasing() == MAINTAIN_SCREEN_AA ) PixelAlignedFiddle(&ClipRect); } BOOL ok = TRUE; // Always export the whole thing into one composite file ok = DoExportHelper(pOp, pFile, pPath, pDoc); if (!IsPreviewBitmap && m_pExportOptions->CanExportSeparateLayers()) { // We need to export each layer as a separate file Layer* pLayer = pSpread->FindFirstLayer(); while (ok && pLayer!=NULL) { if (pLayer->IsVisible() && !pLayer->IsGuide() && pLayer->HasLayerGotRenderableChildren() ) { SetSoleLayer(pLayer); PathName pathLayer = pLayer->MakeExportLayerName(*pPath); CCLexFile* pLayerFile = new CCDiskFile(pathLayer, ios::in | ios::out | ios::binary | ios::trunc); if (ok) ok = DoExportHelper(pOp, pLayerFile, &pathLayer, pDoc); delete pLayerFile; SetSoleLayer(NULL); } pLayer = pLayer->FindNextLayer(); } } // Delete the newly created export options ONLY if we did create them if (pOptions == NULL) { delete m_pExportOptions; m_pExportOptions = NULL; } // Restore the file. OutputFile = pFile; return ok; }

BOOL BaseBitmapFilter::DoImport (  SelOperation *  Op, CCLexFile *  pFile, Document *  DestDoc, BOOL  AutoChosen = FALSE, ImportPosition *  Pos = NULL, KernelBitmap **  ppImportedBitmap = NULL, DocCoord *  pPosTranslate = NULL, String_256 *  URL = NULL )  [virtual]

Read bitmap data from a file. This is the same for all bitmap filters; the ImportBitmap() function should be over-ridden for actual bitmap import filters. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 Parameters: Op  - pointer to the operation that this input process is associated with. [INPUTS] pFile - The file that we should load the bitmap from DestDoc - The Document object which should hold the data read in from the bitmap. ImportPosition - ppImportedBitmap - Used to set the bitmap background pPosTranslate - specify the position of the bitmap on the screen Returns: TRUE if the input operation worked ok, FALSE if not. Errors: Fails (returns FALSE) if the document structure is incorrect, or if there is a problem with the bitmap. Reimplemented from Filter. Definition at line 698 of file bitfilt.cpp. { ERROR2IF(Op == NULL, FALSE, "BaseBitmapFilter::DoImport NULL operation supplied"); ERROR2IF(pFile == NULL, FALSE, "BaseBitmapFilter::DoImport NULL diskfile supplied"); ERROR2IF(DestDoc == NULL, FALSE, "BaseBitmapFilter::DoImport NULL doc supplied"); // Make a note of the disk file we are given InputFile = pFile; // Set up the class variable which is used by the bitmap system to determine which document // to load the bitmap into. Added 24/9/96 as opening a PhotoCD causes the selection to change! // Removing the photocd import dialog box causes the selection to be put into an existing doc // rather than a new one. TheDocument = DestDoc; if (ProcessImportOptions() == FALSE) return FALSE; Spread *pSpread = NULL; DocCoord Origin; //So first find the current view DocView* pDocView=DocView::GetCurrent(); if (Pos == NULL) { // For now, position Draw objects on 1st page of spread 1 //Graham 30/6/97: We now position imported bitmaps in the top left of the view ERROR2IF(pDocView==NULL, FALSE, "BaseBitmapFilter::DoImport - no current view"); //And get the centre coordinate Origin=pDocView->GetTopLeftCoord(); // Find the first spread in that document. pSpread = TheDocument->FindFirstSpread (); } else { pSpread = Pos->pSpread; Origin = Pos->Position; } // If we use the PhotoCD import then current/selected doc/spread MAY be wrong. So force it again. // Must ensure the selected spread is in the destination document as otherwise we will insert the // object AFTER the insertion node and hence in an illegal position. Document::SetSelectedViewAndSpread(DestDoc, DocView::GetCurrent(), pSpread); // Let's get ready if (!PrepareToImport()) return FALSE; UINT32 nBitmapToRead = 0; Layer* pNewLayer = NULL; Layer* pNewActiveLayer = NULL; do // for every bitmap in the file { KernelBitmap* pKernelBmp = NULL; ++nBitmapToRead; // Import that bitmap, if first bitmap then nBitmapToRead will be set to 1 BOOL Success = ImportBitmap(pFile, &pKernelBmp, nBitmapToRead); if (!Success) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } // Did not work - report this to the caller. return FALSE; } // If the caller wants to handle the imported bitmap, then set the return pointer up, // otherwise, we handle the bitmap by inserting a NodeBitmap into the document if (ppImportedBitmap != NULL && pPosTranslate == NULL) *ppImportedBitmap = pKernelBmp; else { // Get a new NodeBitmap object to import into. NodeBitmap *pNodeBitmap = new NodeBitmap; if ((pNodeBitmap == NULL) || (!pNodeBitmap->SetUpPath(12,12))) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } if (pNodeBitmap != NULL) delete pNodeBitmap; return FALSE; } pNodeBitmap->GetBitmapRef()->Attach(pKernelBmp, DestDoc); //GetDocument()); if (pNodeBitmap->GetBitmap() != pKernelBmp) { // It didn't use the bitmap we gave it, so we can delete it delete pKernelBmp; } //And if the caller wants a pointer to the kernel bitmap, give them one... if (ppImportedBitmap) { *ppImportedBitmap=pNodeBitmap->GetBitmap(); } // Import worked - try to add the bitmap object into the tree. // First, set the rectangle to the right size for the bitmap... BitmapInfo Info; pNodeBitmap->GetBitmap()->ActualBitmap->GetInfo(&Info); const INT32 HPixelSize = ( pDocView->GetPixelWidth() + 0.5 ).MakeLong(); // Size of output pixel in millipoints const INT32 VPixelSize = ( pDocView->GetPixelHeight() + 0.5 ).MakeLong();// Size of output pixel in millipoints DocRect BoundsRect; BoundsRect.lo = Origin; // Make sure that this is snapped to a pixel grid BoundsRect.lo.x = GridLock(BoundsRect.lo.x, HPixelSize); BoundsRect.lo.y = GridLock(BoundsRect.lo.y, VPixelSize); // And now add in the rest of the bounds BoundsRect.hi.x = BoundsRect.lo.x + Info.RecommendedWidth; BoundsRect.hi.y = BoundsRect.lo.y + Info.RecommendedHeight; BoundsRect.hi.x = GridLock(BoundsRect.hi.x, HPixelSize); BoundsRect.hi.y = GridLock(BoundsRect.hi.y, VPixelSize); // And set this in our bitmap node pNodeBitmap->CreateShape(BoundsRect); // Make sure that there is a layer to put the bitmap onto if (!MakeSureLayerExists(DestDoc)) { // There is no layer and one could not be made, so we will have to fail delete pNodeBitmap; if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return FALSE; } // Set the default attrs // This MUST be done before the NodeBitmap is Inserted into the tree if (!pNodeBitmap->ApplyDefaultBitmapAttrs(Op)) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return FALSE; } // Insert the node, but don't invalidate its region // If we are the only bitmap then just add it as the first child of the active layer // Could use Filter::ImportWithLayers to determine if we use layers or not BOOL Fail = FALSE; BOOL SingleBitmap = !AreBitmapsToRead() && nBitmapToRead <= 1; //Graham 30/5/97 //If we're importing an animated bitmap as part of an //HTML document PORTNOTE("filters","Removed HTMLFilter usage") if( !SingleBitmap #ifndef EXCLUDE_FROM_XARALX && HTMLFilter::ImportingHTML #endif ) { //Then turn the "all layers visible" flag on in the document DestDoc->SetMultilayer(TRUE); DestDoc->SetAllVisible(TRUE); } if (SingleBitmap || !Filter::ImportBitmapsOntoLayers) { // This inserts the node as the last child of the active layer if (!Op->DoInsertNewNode(pNodeBitmap, pSpread, FALSE)) { Fail = TRUE; // It didn't work - delete the sub-tree we just created, and report error. pNodeBitmap->CascadeDelete(); // Of course, Cascade delete does not actually delete the node itself, so now do that delete pNodeBitmap; pNodeBitmap = NULL; } } else { // We are not the only bitmap in the loading process so for each bitmap try and create // a new layer and put the new bitmap there. // The first layer should be added after the active layer. // We could do this but this means that when multiple animations are being loaded you // end up with the first frames close together rather than the two animations being // separate. if (!InsertBitmapOnNewLayer(Op, pSpread, pNodeBitmap, &pNewLayer)) { Fail = TRUE; // It didn't work - delete the sub-tree we just created, and report error. pNodeBitmap->CascadeDelete(); // Of course, Cascade delete does not actually delete the node itself, so now do that delete pNodeBitmap; pNodeBitmap = NULL; } // Remember the layer we used for the first bitmap so that we can make it active if (nBitmapToRead == 1) pNewActiveLayer = pNewLayer; // Let the filter set things up from the bitmap on the layer // GIF filter can use disposal method to set overlay and solid flags KernelBitmap * pBitmap = pNodeBitmap->GetBitmap(); SetFlagsFromBitmap(pNewLayer, pBitmap, nBitmapToRead); } // If we noted a failure then handle it now if (Fail) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return FALSE; } // and move it to the correct location if we need to... DocCoord Offset(0,0); if (GetDragAndDropTranslation(Pos, BoundsRect, &Offset)) { // See if the bitmap contained an offset and if it did add it in // Baseclass defaults to 0,0 offset AddOffsetFromBitmap(&Offset); Offset.x = GridLock(Offset.x, HPixelSize); Offset.y = GridLock(Offset.y, VPixelSize); // Build the matrix and transform the bitmap to the correct place Trans2DMatrix Xlate(Offset.x, Offset.y); pNodeBitmap->Transform(Xlate); } else { // No drag and drop - bitmap is currently positioned so its bottom left hand // corner is at the top left of the page - translate it down by its height so // that the top left corner of the bitmap is aligned to the top left corner // of the page. // Do we have an additional translation to apply? if (pPosTranslate != NULL) { Offset.x = pPosTranslate->x; Offset.y = pPosTranslate->y; } // See if the bitmap contained an offset as well and if it did add it in // Baseclass defaults to 0,0 offset AddOffsetFromBitmap(&Offset); Offset.x = GridLock(Offset.x, HPixelSize); Offset.y = GridLock(Offset.y, VPixelSize); Trans2DMatrix Xlate(Offset.x, -(Info.RecommendedHeight) + Offset.y); pNodeBitmap->Transform(Xlate); } // Invalidate the region Success = Op->DoInvalidateNodeRegion(pNodeBitmap, TRUE, FALSE); if (!Success) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return FALSE; // hmmm.... } DocRect docrectBounds = pNodeBitmap->GetBoundingRect(); DocRect docrectView = pDocView->GetDocViewRect( pSpread ); pSpread->DocCoordToSpreadCoord( &docrectView ); if( ( docrectBounds.lo.x < docrectView.lo.x || docrectBounds.lo.y < docrectView.lo.y || docrectBounds.hi.x > docrectView.hi.x || docrectBounds.hi.y > docrectView.hi.y ) && s_fZoomOnImport ) { // Calculate bounding rect of view plus new photo and then make sure that edges in // in both axes grow by same amount. We make use of the fact that zoom code only allows // zooming in both axes by the same amount, so we don't need to make sure that growth in // both axes is by the same percentage. docrectBounds = docrectBounds.Union( docrectView ); if( docrectView.lo.x - docrectBounds.lo.x > docrectBounds.hi.x - docrectView.hi.x ) docrectBounds.hi.x = docrectView.hi.x + docrectView.lo.x - docrectBounds.lo.x; else docrectBounds.lo.x = docrectView.lo.x - docrectBounds.hi.x + docrectView.hi.x; if( docrectView.lo.y - docrectBounds.lo.y > docrectBounds.hi.y - docrectView.hi.y ) docrectBounds.hi.y = docrectView.hi.y + docrectView.lo.y - docrectBounds.lo.y; else docrectBounds.lo.y = docrectView.lo.y - docrectBounds.hi.y + docrectView.hi.y; OpZoomFitRectDescriptor* pOpDesc = (OpZoomFitRectDescriptor*)OpDescriptor::FindOpDescriptor( OPTOKEN_ZOOMRECT ); if( NULL != pOpDesc ) { pOpDesc->SetZoomRect( docrectBounds ); pOpDesc->Invoke(); } if( !s_fWarnedZoomOnImport ) { ErrorInfo Info; memset( &Info, 0, sizeof(Info) ); Info.ErrorMsg = _R(IDS_ZOOM_ON_IMAGE_IMPORT); Info.Button[0] = _R(IDS_OK); Info.Button[1] = _R(IDS_DONT_SHOW_AGAIN); Info.OK = 1; if( _R(IDS_DONT_SHOW_AGAIN) == UINT32(InformMessage( &Info )) ) s_fWarnedZoomOnImport = TRUE; } } } } while (AreBitmapsToRead()); // If we have loaded bitmaps onto layers and hence requested a new active layer then set // it now. // Graham 1/8/97: If we are importing an animated GIF as part of an HTML page, we don't // change the active layer, because this may result in subsequent bitmaps in the HTML // page being imported on the wrong layer. PORTNOTE("filters","Removed HTMLFilter usage") if( pNewActiveLayer #ifndef EXCLUDE_FROM_XARALX && !HTMLFilter::ImportingHTML #endif ) { // If the old active layer is blank and has nothing on it, then delete it Layer * pActiveLayer = pSpread->FindActiveLayer(); if (pActiveLayer) { // Scans the layer for children that render something on the screen. // It ignores attributes, hidden nodes, etc - nodes that don't render anything themselves. Node* pNode = pActiveLayer->FindFirstChild(); BOOL ChildFound = FALSE; while (pNode != NULL && !ChildFound) { ChildFound = pNode->IsBounded(); pNode = pNode->FindNext(); } // Hide the old active layer if (!ChildFound) Op->DoHideNode(pActiveLayer, TRUE); } // Check that all visible layers are actually frame layers as we have // created some new frame layers for each of the bitmaps. PORTNOTE("dialog","Removed FrameSGallery usage") #ifndef EXCLUDE_FROM_XARALX FrameSGallery::MakeActiveLayer(pNewActiveLayer); #endif BROADCAST_TO_ALL( LayerMsg( pNewActiveLayer, LayerMsg::UPDATE_ACTIVE_LAYER ) ); // Try and fix up the animation properties according to the bitmaps that have been loaded in SetAnimationPropertiesFromLoaded(pSpread); } // Ensure Sel Bounds are correct after translation GetApplication()->UpdateSelection(); if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } // All ok return TRUE; }

BOOL BaseBitmapFilter::EndWriteToFile (  void   )  [protected, virtual]

Cleans up after writing the bitmap data out to a file. Inherited classes override this to write in different file formats. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/95 Parameters: -  [INPUTS] Returns: TRUE if worked, FALSE if failed. Reimplemented in JPEGExportFilter, MakeBitmapFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4125 of file bitfilt.cpp. { ENSURE(FALSE, "Base class bitmap filter EndWriteToFile called"); return FALSE; }

BOOL BaseBitmapFilter::ExportBitmap (  Operation *  pOp, CCLexFile *  pFile, PathName *  pPath, Document *  pDoc )  [protected]

void BaseBitmapFilter::ExportHTMLTag (  PathName *  ppthToUse  )  [virtual]

But* Colin's comments say that it's at the filter author's discretion whether to use a BitmapExportOptions object or not. So, it seems we shouldn't throw an error if we can't find a BitmapExportOptions object. So if we can't find a BFO object, we don't throw an error - we simply don't export. Definition at line 5125 of file bitfilt.cpp. { //Check our parameter if (ppthToUse==NULL) { ERROR2RAW("BaseCamelotFilter::ExportHTMLTag - NULL parameter"); return; } //First get the name of the file we are exporting to String_256 strFileName=ppthToUse->GetFileName(TRUE); //Now, do we have sensible bitmap export dimensions? ERROR3IF(m_PixelWidth<=0 || m_PixelHeight<=0, "Width and Height are both 0 in BaseBitmapFilter::ExportHTMLTag"); //And if they make sense if (m_PixelWidth>0 && m_PixelHeight>0) { //Then export a tag based on that width and height String_256 strTag; strTag.MakeMsg(_R(IDS_BITMAPFILTER_HTMLTAG), &strFileName, m_PixelWidth, m_PixelHeight); //And put that string on the clipboard PORTNOTE("clipboard","Removed InternalClipboard usage") #ifndef EXCLUDE_FROM_XARALX InternalClipboard::CopyText(strTag); #endif } }

BOOL BaseBitmapFilter::ExportImagemap (  Operation *  , PathName *  , Document *  )

Definition at line 5019 of file bitfilt.cpp. { //Check our parameters ERROR2IF(pOp == NULL, FALSE,"BaseBitmapFilter::ExportImagemap no export operation"); ERROR2IF(pPath == NULL, FALSE,"BaseBitmapFilter::ExportImagemap no export pathname"); ERROR2IF(pDoc == NULL, FALSE,"BaseBitmapFilter::DoExport no document to export"); //First, let's find the imagemap filter ImagemapFilter* pImagemapFilter=GetImagemapFilter(); //And if we haven't found it, throw an error //Note that it is entirely possible that a future (modular) build might //not have an Imagemap filter, but for the moment it's worrying ERROR2IF(pImagemapFilter==NULL, FALSE, "OK. Own up. Who nicked the Imagemap filter?"); //Create a file to export to CCDiskFile ImagemapFile(1024, FALSE, TRUE); //Now we need to set up some Imagemap Filter Options //We base these on the last set of ImagemapFilterOptions that the user exported //with, so get those options from the ImagemapFilter ImagemapFilterOptions ifoToSet=pImagemapFilter->GetFilterOptions(); // Check we are exporting an imagemap either to a file or to the clipboard if (!(ifoToSet.m_fFile || ifoToSet.m_fClipboard)) return TRUE; // Successfully done as requested (not exported an image map) if (!GetBitmapExportOptions()) return FALSE; // can't export image map with out export options //Set the DPI from our bitmap options ifoToSet.m_dDPI=GetBitmapExportOptions()->GetDPI(); //And set the selection type ifoToSet.m_stExportArea=GetBitmapExportOptions()->GetSelectionType(); // Use the path set previously in the image map options -- Jonathan 6/12/2000 //And give the filter a pointer to our export file ifoToSet.m_pfileFile=&ImagemapFile; // tell the filter where the graphic is that it is describing ifoToSet.m_GraphicPath = *pPath; //Then set our new options back into the imagemap filter pImagemapFilter->SetFilterOptions(ifoToSet); //And tell the filter to export the file BOOL ok= pImagemapFilter->PrepareAndWriteData(pDoc); //Then close the file if it's still open if (ImagemapFile.isOpen()) ImagemapFile.close(); //And return return ok; }

BOOL BaseBitmapFilter::ExportRenderNodes (  RenderRegion *  pRegion, ExportDC *  pDC, BOOL  VisibleLayersOnly = FALSE, BOOL  CheckSelected = FALSE, BOOL  ShowProgress = TRUE )  [virtual]

Actually export the nodes to the given render region showing a progress bar as we go. Assumes everything has been set up by ExportRender. Overrides the baseclass version so that we can render in strips. Ignores the setting of ShowProgress as we must be in charge of the progress bar in this version. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/95 Parameters: pRegion  - the render region to export to. [INPUTS] pDc - device context to use VisibleLayersOnly - use visible layers or not ShowProgress - TRUE then start up a progress bar or FALSE assume the caller has done it. Returns: TRUE if the export process completed successfully, FALSE if an error occured. See also: ExportRender Reimplemented from Filter. Definition at line 3633 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pRegion==NULL,FALSE,"BaseBitmapFilter::ExportRender null render region supplied"); // Set up the Accusoft variables used for its redenring loop and call back form of the // do next strip. This is just in case we are going to change from using the Bitmap // filter to using the Accusoft filters as we are saving in a format which the Bitmap // filters do not understand. //WEBSTER-Martin-03/01/97 PORTNOTE("ExportAccusoft", "Removed use fo Accusoft filters") #ifndef EXCLUDE_FROM_XARALX AccusoftFilters::SetRenderVariables(this, pRegion, pDC, VisibleLayersOnly, CheckSelected); #endif // Set the bad rendering flag to its default value BadExportRender = FALSE; BOOL ok = TRUE; DocRect rClipRect = pRegion->GetRegionRect(); BitmapExportOptions * pExportOptions = GetBitmapExportOptions(); BOOL DidASwap = FALSE; // Check our class variable to see if we should render in strips or not // We do this so that things like the GIF filters 1bpp masked rendering can turn the // rendering in strips off. Should be on by default. if (RenderInStrips) { OurNumNodes = GetNumNodes(); //UINT32 OurUpdateEvery = UpdateEvery; // We have a useful function in the GRenderBitmap class which tells us the number // of strips we are going to render with. GRenderBitmap *pGRenderBitmap = (GRenderBitmap*)pRegion; INT32 NumberOfStrips = pGRenderBitmap->GetNumBands(); if (NumberOfStrips <= 0) NumberOfStrips = 1; TRACEUSER( "Gerry", _T("Number of bands is %d\n"), NumberOfStrips); TRACEUSER( "Gerry", _T("Number of nodes is %d\n"), OurNumNodes); // We need the progress bar to just move up once rather than for every strip // plus include the number of lines in the export bitmap so that we can show // a progress bar for this part of the export. // First, get the size of the bitmap we are going to export INT32 HeightInPixels = pGRenderBitmap->GetFullRegionHeight(); TRACEUSER( "Gerry", _T("Full region height in pixels is %d\n"), HeightInPixels ); SizeOfExport = OurNumNodes * NumberOfStrips; SetNumNodes(SizeOfExport); BitmapExportOptions* pOptions = GetBitmapExportOptions(); // Start a progress update going // Extend it by the pixel height of the export String_64 ExportMessage(GetExportMsgID()); ExportMessage = GetExportProgressString(OutputFile, GetExportMsgID()); BeginSlowJob(200, FALSE, &ExportMessage); TRACEUSER( "Gerry", _T("Size of progress bar = %d\n"), SizeOfExport + HeightInPixels ); // Reset this back to zero so that when we update the progress bar in WriteToFile // we can work out the current point reached on the progress bar SizeOfExport = 0; ProgressOffset = 0; m__StripStart = 0; // Find out which way we want to render by asking the filters BOOL BottomToTop = GetRenderBottomToTop(); pGRenderBitmap->SetRenderBottomToTop(BottomToTop); // SMFIX this is where we will generate a new optimal palette if we need to BOOL CreatingPalette = !pExportOptions->IsPaletteValid() && pExportOptions->GetDepth() <= 8; if (CreatingPalette) { if (!pExportOptions->CreatePaletteOptimiser()) { // we didn't create an optimiser as we already have a good one // use it to create the palette NOW! without the stats gathering part as are stats are still valid pExportOptions->CreateValidPalette(); // let the optimiser fill in the palette in the export options AlterPaletteContents(pExportOptions->GetLogicalPalette()); CreatingPalette = FALSE; } } else if(pExportOptions->GetDepth() <= 8) { // this call sets this palette in the lower reaches of the code from the palette held in the export options AlterPaletteContents(pExportOptions->GetLogicalPalette()); } if (pExportOptions->IsCMYK()) { // If we are doing a CMYK export then we need to do a really cunning 4-pass render TRACEUSER( "Gerry", _T("BaseBitmapFilter::ExportRenderNodes starting CMYK export\n") ); // We need to save away the current ColourPlate and restore it afterwards // This may be problematic as the render region has already been created at this point // and also, the view will redraw when the ColourPlate is changed View* pView = pRegion->GetRenderView(); ColourPlate* pCurPlate = pView->GetColourPlate(); if (pCurPlate) { pCurPlate = new ColourPlate(*pCurPlate); // Make a copy of it } else { pCurPlate = new ColourPlate; // Make a default pCurPlate->SetMonochrome(NULL, FALSE); // Set to non-mono } // Get the first strip ready for action ok = pRegion->SetFirstBand(); if (!ok) { BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } UINT32 nBandsCompleted = 0; // Now render all the other strips, if there are any, until we have completed // the entire region. do { // Make sure this gets set back to the correct value before doing any rendering pGRenderBitmap->SetDoBitmapConversion(TRUE); // Set up a destination bitmap of the strip size at 32 bpp // We must somehow get the size of the bitmap here before // it has actually been allocated in StartRender WinRect BitmapRect = ((GRenderRegion*)pGRenderBitmap)->CalculateWinRect(pGRenderBitmap->GetClipRect()); TRACEUSER( "Gerry", _T("CMYK bitmap is (%d, %d)\n"), BitmapRect.GetWidth(), BitmapRect.GetHeight() ); LPBYTE pCMYKBits = NULL; LPBITMAPINFO pCMYKInfo = AllocDIB(BitmapRect.GetWidth(), BitmapRect.GetHeight(), 32, &pCMYKBits); memset(pCMYKBits, 0, BitmapRect.GetWidth() * BitmapRect.GetHeight() * sizeof(DWORD)); // Loop around the four plates for (UINT32 PlateType = COLOURPLATE_CYAN; PlateType <= COLOURPLATE_KEY; PlateType += 1) { // Set the relevant ColourPlate on the View ColourPlate* pPlate = new ColourPlate((ColourPlateType)PlateType, TRUE, FALSE); pView->SetColourPlate(pPlate, FALSE); delete pPlate; // This will cause a new ColourContext to be got from the view pRegion->ResetColourContext(); // Call the base class version to do the actual node exporting // We have started the progress bar so tell it not to ok = Filter::ExportRenderNodes(pRegion, pDC, VisibleLayersOnly, CheckSelected, FALSE); // If a problem happened then get out quick. // Assume function has stopped the rendering. if (!ok) { if (pView) { pView->SetColourPlate(pCurPlate); delete pCurPlate; } BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } LPBITMAPINFO pRenderInfo = NULL; LPBYTE pRenderData = NULL; pGRenderBitmap->GetBitmapData(&pRenderInfo, &pRenderData, FALSE); TRACEUSER( "Gerry", _T("Strip bitmap for plate %d is (%d, %d)\n"), PlateType, pRenderInfo->bmiHeader.biWidth, pRenderInfo->bmiHeader.biHeight); BYTE* pSrcBits = pRenderData; UINT32 NumPixels = pRenderInfo->bmiHeader.biWidth * pRenderInfo->bmiHeader.biHeight; BYTE* pDestBits = ((BYTE*)pCMYKBits) + PlateType - COLOURPLATE_CYAN; // Pointer arithmetic for (UINT32 Pixel = 0; Pixel < NumPixels; Pixel++) { *pDestBits = (255 - pSrcBits[0]) * (255 - pSrcBits[3]) / 255; pDestBits += 4; pSrcBits += 4; } } // Update our size of export variable SizeOfExport += OurNumNodes; // Update the filters stored progress offset value ProgressOffset += OurNumNodes; TRACEUSER( "Gerry", _T("BaseBitmapFilter::RenderNextStrip ProgressOffset = %d\n"), ProgressOffset); // Now we need to get WriteFrame to output the composited bitmap // The easiest way to do this will be to replace the bitmap in the render region // with the composited one and just call WriteFrame as normal DWORD* pSrcBits = (DWORD*)pGRenderBitmap->Get32BitRGBQuadData(); UINT32 NumPixels = pGRenderBitmap->GetSizeOfRGBQuadData(); memcpy(pSrcBits, pCMYKBits, NumPixels * sizeof(DWORD)); // We need to stop GetBitmapData from doing another conversion when reading the CMYK data pGRenderBitmap->SetDoBitmapConversion(FALSE); // Free the temp bitmap FreeDIB(pCMYKInfo, pCMYKBits); // Save that data out to file, this should update SizeOfExport with the // current strip size // Note: it will also render all the remaining strips ok = WriteFrame(); // If a problem happened then get out quick. if (!ok) { if (pView) { pView->SetColourPlate(pCurPlate); delete pCurPlate; } BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } // Advance the progress bar UINT32 nProgress = UINT32((double(nBandsCompleted) / double(NumberOfStrips)) * 200.0); TRACEUSER( "Gerry", _T("nProgress = %d\n"), nProgress); if ( !ContinueSlowJob (nProgress) ) { // Error; close down and exit nicely. // Must set an error otherwise we will get the dreaded reporting error // when none set message. // If no error message ID set in this filter then use default // Andy, 13-12-00 // N.B. At the moment, things go pear-shaped if we press ESC during export. // e.g. subsequent presses of 'preview' do not generate a preview. // However it wasn't exactly well behaved before, e.g. sometimes gave // internal error 'Failed to create an intermediate bitmap pointer!', or // access violated if the user clicked 'background transparency' after a // cancelled export. if (pView) { pView->SetColourPlate(pCurPlate); delete pCurPlate; } if ( StopExportMsgID == 0 ) Error::SetError ( _R(IDW_CANCELEXPORT) ); else Error::SetError ( StopExportMsgID ); pRegion->StopRender (); if ( ShowProgress ) EndSlowJob (); return FALSE; } nBandsCompleted ++; // Check if there are any more bands } while (pRegion->GetNextBand()); if (pView) { pView->SetColourPlate(pCurPlate); delete pCurPlate; } } else { for (INT32 loop = 0; loop < 2; loop++) // never do this more than twice once for the palette and once to write it out to file { TRACEUSER( "Gerry", _T("BaseBitmapFilter::ExportRenderNodes loop = %d\n"), loop); if (!CreatingPalette && pExportOptions->GetDepth() <= 8) { DidASwap = pExportOptions->SwapEditedColoursInLogicalPalette(); AlterPaletteContents(pExportOptions->GetLogicalPalette()); } // Get the first strip ready for action ok = pRegion->SetFirstBand(); if (!ok) { BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } UINT32 nBandsCompleted = 0; // Now render all the other strips, if there are any, until we have completed // the entire region. do { // Call the base class version to do the actual node exporting // We have started the progress bar so tell it not to ok = Filter::ExportRenderNodes(pRegion, pDC, VisibleLayersOnly, CheckSelected, FALSE); // If a problem happened then get out quick. // Assume function has stopped the rendering. if (!ok) { BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } if (!CreatingPalette) { // Update our size of export variable SizeOfExport += OurNumNodes; // Update the filters stored progress offset value ProgressOffset += OurNumNodes; TRACEUSER( "Gerry", _T("BaseBitmapFilter::RenderNextStrip ProgressOffset = %d\n"),ProgressOffset); } // Save that data out to file, this should update SizeOfExport with the // current strip size if (CreatingPalette) { // calc the stats for an optimised palette pExportOptions->GatherPaletteStats( ((GRenderRegion * )pRegion)->Get32BitRGBQuadData(), ((GRenderRegion * )pRegion)->GetSizeOfRGBQuadData()); } else ok = WriteFrame(); // If a problem happened then get out quick. if (!ok) { BadExportRender = TRUE; // flag that something has gone wrong EndWriteToFile(); EndSlowJob(); return FALSE; } // Advance the progress bar UINT32 nProgress; // if this image doesn't need a palette, scale the progress value to // the full length of the bar if (!CreatingPalette && loop==0) nProgress = UINT32((double(nBandsCompleted) / double(NumberOfStrips)) * 200.0); // otherwise, scale the progress value to half the length of the bar // (as this rendering loop will occur twice) else nProgress = UINT32((double(nBandsCompleted) / double(NumberOfStrips)) * 100.0 + double(loop)*100.0); TRACEUSER( "Gerry", _T("nProgress = %d\n"), nProgress); if ( !ContinueSlowJob (nProgress) ) { // Error; close down and exit nicely. // Must set an error otherwise we will get the dreaded reporting error // when none set message. // If no error message ID set in this filter then use default // Andy, 13-12-00 // N.B. At the moment, things go pear-shaped if we press ESC during export. // e.g. subsequent presses of 'preview' do not generate a preview. // However it wasn't exactly well behaved before, e.g. sometimes gave // internal error 'Failed to create an intermediate bitmap pointer!', or // access violated if the user clicked 'background transparency' after a // cancelled export. if ( StopExportMsgID == 0 ) Error::SetError ( _R(IDW_CANCELEXPORT) ); else Error::SetError ( StopExportMsgID ); pRegion->StopRender (); if ( ShowProgress ) EndSlowJob (); return FALSE; } nBandsCompleted ++; // Check if there are any more bands } while (pRegion->GetNextBand()); if (CreatingPalette) { CreatingPalette = FALSE; // let the optimiser fill in the palette in the export options pExportOptions->CreateValidPalette(); // set this as the palette being used in output dib AlterPaletteContents(pExportOptions->GetLogicalPalette()); // Reset the clip region to what it was when we started this pRegion->SetClipRect(rClipRect); } else break; // leave this for loop now } } if (DidASwap) { pOptions->SwapEditedColoursInLogicalPalette(); AlterPaletteContents(pOptions->GetLogicalPalette()); } // Close down progress display // Do it before ending as then the TI GIF filter can show a progress bar on // its possible masked rendering for transparency and export of the GIF data // which happens in the EndWriteToFile. EndSlowJob(); } else { // Call the base class version to do the actual node exporting // Use the pass in version to say whether we need to start the progress bar or not. // Assume that we are the GIF filter renderer and so do not try and output the data // at all. We will ensure as this might be dangerous. PORTNOTE("filter", "Removed use of GIFFilter") #ifndef EXCLUDE_FROM_XARALX ERROR3IF(!(this->IS_KIND_OF(TI_GIFFilter)) && !(this->IS_KIND_OF(PNGFilter)), "BaseBitmapFilter::ExportRenderNodes rendering in strips off"); #else ERROR3IF(!(this->IS_KIND_OF(PNGFilter)), "BaseBitmapFilter::ExportRenderNodes rendering in strips off"); #endif ok = Filter::ExportRenderNodes(pRegion, pDC, VisibleLayersOnly, CheckSelected, ShowProgress); // SMFIX optimise the palette in the no strip based manner BOOL CreatingPalette = !pExportOptions->IsPaletteValid(); if (CreatingPalette) { // create a palette optimiser (or retrieve a valid one) if (pExportOptions->CreatePaletteOptimiser()) { // we need to gather stats as we have made a virgin new optimiser pExportOptions->GatherPaletteStats( ((GRenderRegion * )pRegion)->Get32BitRGBQuadData(), ((GRenderRegion * )pRegion)->GetSizeOfRGBQuadData()); } // let the optimiser fill in the palette in the export options pExportOptions->CreateValidPalette(); // let the optimiser fill in the palette in the export options AlterPaletteContents(pExportOptions->GetLogicalPalette()); } /* // SMFIX if(pRegion->m_DoCompression) { BITMAPINFO* pBMPInfo = NULL; BYTE* pBMPData = NULL; ((GRenderBitmap*)pRegion)->GetBitmapData(&pBMPInfo,&pBMPData); ((GRenderBitmap*)pRegion)->GetDrawContext()->ConvertBitmap(&pBMPInfo->bmiHeader,pBMPData,&pBMPInfo->bmiHeader,pBMPData,0); }*/ } // return outcome to caller return ok; #else return FALSE; #endif }

BOOL BaseBitmapFilter::ExportVisibleLayersOnly (   )  [virtual]

Determines if the filter wants to export only visible layers. In the base bitmap filters class version the default action will be to export only those layers which are visible. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/02/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if this filter wants to exclude invisible layers and so export only visible items Or False if want to export everything. See also: Filter::ExportRender; Reimplemented from Filter. Reimplemented in GrabFrameFilter. Definition at line 356 of file bitfilt.cpp. { // only include all layer that are visible in this bitmap export return TRUE; }

void BaseBitmapFilter::ForceAntialiasingFull (  DocView *  pView  )  [protected]

Forces Antialiasing to be full in the specified view. Use RestoreViewQuality to restore the quality. Used when generating preview bitmaps, which should always be in full anti- aliasing mode. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/96 Parameters: pView,pointer  to the View to change [INPUTS] Returns: - Errors: - See also: BaseBitmapFilter::RestoreViewQuality Scope: Protected Definition at line 2283 of file bitfilt.cpp. { ERROR3IF(pView == NULL, "NULL pointer passed into BaseBitmapFilter::ForceAntialiasingFull"); if (pView == NULL) return; // We don't need to do anything if the view quality is already not Antialiased if (!ViewQualitySet && pView->RenderQuality.GetAntialiasQuality() < Quality::FullAntialias) { ViewQuality = pView->RenderQuality; ViewQualitySet = TRUE; // So we don't do this more than once pView->RenderQuality.SetQuality(QUALITY_MAX); } }

void BaseBitmapFilter::ForceAntialiasingOff (  DocView *  pView  )  [protected]

Forces Antialiasing off in the specified view. Use RestoreViewQuality to restore the quality. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Parameters: pView,pointer  to the View to change [INPUTS] Returns: - Errors: - See also: BaseBitmapFilter::RestoreViewQuality Scope: Protected Definition at line 2249 of file bitfilt.cpp. { ERROR3IF(pView == NULL, "NULL pointer passed into BaseBitmapFilter::ForceAntialiasingOff"); if (pView == NULL) return; // We don't need to do anything if the view quality is already not Antialiased if (!ViewQualitySet && pView->RenderQuality.GetAntialiasQuality() >= Quality::FullAntialias) { ViewQuality = pView->RenderQuality; ViewQualitySet = TRUE; // So we don't do this more than once pView->RenderQuality.SetQuality(QUALITY_DEFAULT); } }

void BaseBitmapFilter::ForceBackgroundRedrawOff (  DocView *  pView  )  [protected]

Forces background redraw off in the specified view, so we render all the objects in one pass. Use RestoreBackgroundRedrawState to restore the state. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Parameters: pView,pointer  to the View to change [INPUTS] Returns: - Errors: - See also: BaseBitmapFilter::RestoreBackgroundRedrawState Scope: Protected Definition at line 2187 of file bitfilt.cpp. { ERROR3IF(pView == NULL, "NULL pointer passed into BaseBitmapFilter::ForceBackgroundRedrawOff"); if (pView == NULL) return; // We wan't to make sure we only remember the old state once ... if (!BackgroundRedrawStateSet) { BackgroundRedrawState = pView->GetForeBackMode(); BackgroundRedrawStateSet = TRUE; // So we don't do this more than once } pView->SetForeBackMode(FALSE); }

BOOL BaseBitmapFilter::GenerateOptimisedPalette (  Spread *  pSpread, UINT32  Depth, double  DPI, BOOL  SnapToBrowserPalette, UINT32  NumColsInPalette, BOOL  UsePrimaryCols )  [virtual]

Generates an optimised palette to use during export. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: pSpread  = ptr to spread [INPUTS] Depth = The BPP of the bitmap DPI = the dpi of the bitmap NumColsInPalette = prefered number of cols in palette (0 = select maximum allowed) (only applies when Depth == 8) UsePrimaryCols = Put primary colours in palette (only applies when Depth == 8) SnapToBrowserPalette= TRUE if the palette should be snapped to the browser palette after generation Returns: TRUE if Palette generated ok See also: - Reimplemented in GrabFrameFilter. Definition at line 4397 of file bitfilt.cpp. { #ifdef DO_EXPORT if (Depth > 8) { pOptimisedPalette = NULL; return TRUE; } TRACEUSER( "Neville", _T("Trying to generate an optimised palette ...\n") ); WeAreGeneratingOptPalette = TRUE; // Don't use rendering matrix when exporting BMPs as it uses coordinates as is Matrix Identity; // Don't use view scale; set to 1 FIXED16 Scale(1); // Only use special 8bpp palette if the UsePrimaryColours flag is TRUE BOOL use8bpp = ((Depth == 8) && UsePrimaryCols); GRenderOptPalette* pPalRegion = new GRenderOptPalette(ClipRect, Identity, Scale, 32, DPI, use8bpp); if (pPalRegion) { // we need a View to Attach to, so that: // default Quality setting // CalcPixelWidth etc get called DocView *View = DocView::GetCurrent(); if (View) { // Attach to the right device. (note no DC) pPalRegion->AttachDevice(View, NULL, pSpread); } else ERROR2(FALSE,"BaseBitmapFilter::GenerateOptimisedPalette no current view"); RenderInStrips = TRUE; // Now do an export render pass, using the Palette Region if (ExportRender(pPalRegion)) { UINT32 MaxColours = 1U<<Depth; // let's not use floating point here - UINT32(pow(2,Depth)); if (NumColsInPalette < 1) NumColsInPalette = MaxColours; if (use8bpp && NumColsInPalette < 20) NumColsInPalette = 20; if (NumColsInPalette > MaxColours) NumColsInPalette = MaxColours; // All went ok, so extract the Optimised palette from the Region pOptimisedPalette = pPalRegion->GetOptimisedPalette(MaxColours, NumColsInPalette, GetNumReservedColours(), SnapToBrowserPalette); if (pOptimisedPalette) TRACEUSER( "Neville", _T("Blimey. We got an optimised palette to use.\n") ); } delete pPalRegion; } WeAreGeneratingOptPalette = FALSE; #endif return TRUE; }

BOOL BaseBitmapFilter::GenerateOptimisedPalette (  Spread *  pSpread, BitmapExportOptions *  pOptions, BOOL  SnapToBrowserPalette )  [virtual]

Generates an optimised palette to use during export. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/97 Parameters: pSpread  = ptr to spread [INPUTS] pOptions = ptr to bitmap export options SnapToBrowserPalette = If TRUE, snap all optimised palette entries to the browser palette Returns: TRUE if Palette generated ok This is an alternative interface to GenerateOptimisedPalette(Spread *pSpread, UINT32 Depth, double DPI, UINT32 NumColsInPalette, BOOL UsePrimaryCols); WEBSTER - markn 16/1/97 See also: - Definition at line 4484 of file bitfilt.cpp. { if (pSpread != NULL && pOptions != NULL) { return GenerateOptimisedPalette(pSpread, pOptions->GetDepth(), pOptions->GetDPI(), SnapToBrowserPalette, pOptions->GetNumColsInPalette(), pOptions->GetUseSystemColours() ); } return FALSE; }

BOOL BaseBitmapFilter::GeneratingOptimisedPalette (   )  [static]

Find out if we are currently generating an optimised palette or not. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: -  [INPUTS] Returns: TRUE if we are in the middle of generating an optimised Palette See also: - Definition at line 4518 of file bitfilt.cpp. { return WeAreGeneratingOptPalette; }

BitmapExportOptions * BaseBitmapFilter::GetBitmapExportOptions (   )  const

Support function to obtain BitmapExportOptions. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: Details of the data to be exported Definition at line 4748 of file bitfilt.cpp. { ERROR3IF(m_pExportOptions != NULL && !m_pExportOptions->IS_KIND_OF(BitmapExportOptions), "m_pExportOptions isn't"); return m_pExportOptions; }

LPBITMAPINFO BaseBitmapFilter::GetBitmapInfo (   )  const [protected]

UINT32 BaseBitmapFilter::GetBitmapNumber (   )  const [protected]

On entry to the filter this member function returns the number of the desired bitmap in the file. Once the import is complete, either SetBitmapNumber is called with an argument of the next bitmap that can be read or SetLastBitmap is called indicating there are no more to read. Scope: protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 11/06/96 Parameters: -  [INPUTS] Returns: The next bitmap to read 0 if the bitmap number is invalid See also: SetBitmapNumber(), SetLastBitmap(), ...ReadFromFile() Definition at line 1569 of file bitfilt.cpp. { return m_nBitmapToRead < 1 ? 0 : (UINT32) m_nBitmapToRead; }

DocRect BaseBitmapFilter::GetClipRect (   )  const [inline]

Definition at line 282 of file bitfilt.h. { return ClipRect; }

BOOL BaseBitmapFilter::GetCurrentStripInfo (  ADDR *  ppBits, BMP_SIZE *  pWidth, BMP_SIZE *  pHeight, BMP_DEPTH *  pDepth )  const [protected]

Definition at line 4715 of file bitfilt.cpp. { LPBITMAPINFO pBitmapInfo; LPBYTE pBitmapBits; ExportRegion->GetBitmapData(&pBitmapInfo, &pBitmapBits); if (pBitmapInfo == NULL || pBitmapBits == NULL) { ERROR3("pBitmapInfo == NULL || pBitmapBits == NULL"); return FALSE; } *ppBits = pBitmapBits; *pWidth = pBitmapInfo->bmiHeader.biWidth; *pHeight = pBitmapInfo->bmiHeader.biHeight; *pDepth = pBitmapInfo->bmiHeader.biBitCount; return TRUE; }

OFFSET BaseBitmapFilter::GetDataStartOffset (   )  const [protected, virtual]

Provides information to the BaseBitmapFilter, so that it knows where to start any required BitmapSource. It will only be useful to derived classes that deal with a lossy file format. Notes: The default implementation returns zero, assuming there is no useless garbage before any actual header. Derived classes should override this for any special case. > virtual OFFSET BaseBitmapFilter::GetDataStartOffset() const Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Returns: The offset from the HeaderStart parameter given in HowCompatible(), from which data essential to the correct functionality of this filter starts. See Also: IsFormatLossy() Reimplemented in JPEGImportFilter. Definition at line 667 of file bitfilt.cpp. { return 0; }

static KernelBitmap* BaseBitmapFilter::GetExportBitmap (   )  [inline, static]

Definition at line 285 of file bitfilt.h. {return pExportBitmap; };

CCLexFile * BaseBitmapFilter::GetExportFile (   )  const [protected]

Support function to obtain file to export in WriteBitmapToFile. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: A pointer to the file provided in the filter entry point (DoExport,etc.) Definition at line 4691 of file bitfilt.cpp. { return OutputFile; }

UINT32 BaseBitmapFilter::GetExportMsgID (   )  [virtual]

Used to get the message id to be used during export. Virtual, so that two stage exporters can change the message. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/09/95 Returns: The id of the message to put on the progress display whilst exporting. See also: DoExport; Reimplemented from Filter. Reimplemented in GrabFrameFilter, MakeBitmapFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4368 of file bitfilt.cpp. { if (GeneratingOptimisedPalette()) return _R(IDS_GENOPTPALMSGID); // "Generating optimised palette..." else return Filter::GetExportMsgID(); }

BOOL BaseBitmapFilter::GetExportOptions (  BitmapExportOptions *  pOptions  )  [virtual]

Allows the user to be prompted to get export information which should be set in the given BitmapExportOptions. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 12/11/96 Parameters: pOptions  : A pointer to some BitmapExportOptions [INPUTS] pOptions  : the same with some extra information in it [OUTPUTS] Returns: TRUE if OK FALSE if user pressed Cancel. Notes: Due to the existence of three public entry points into bitmap filters, two of which are virtual, the BaseBitmapFilter::WriteBitmapToFile may not be called and so may not create a BitmapExportOptions object, which would not be disasterous in itself, unless a derived class calls BaseBitmapFilter functions which use BitmapExportOptions. It is therefore at the filter author's discretion whether or not to create one of these objects. Scope: protected Reimplemented in JPEGExportFilter, GrabFrameFilter, MakeBitmapFilter, PreviewFilterBMP, PreviewFilterGIF, PreviewFilterJPEG, PreviewFilterPNG, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 1736 of file bitfilt.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR2IF(pOptions == NULL, FALSE, "NULL Args"); WrittenHeader = FALSE; // When saving a bitmap directly then only use the dialog box for certain filter types // as it will be just requesting compression type and hence otherwise it is superfluous. // Otherwise, always use it. BOOL Ok = TRUE; if (pOptions->GetSelectionType() != ABITMAP) { // This is ok as we are using a modal dialog box PORTNOTE("export", "Remove BmpPrefsDlg usage") #if !defined(EXCLUDE_FROM_XARALX) Ok = BmpPrefsDlg::InvokeDialog(pOptions); #endif } if (Ok) { // Only save the depth as the default if not saving a bitmap itself // from say the bitmap gallery. (keep this rubbish for now...) if (pOptions->GetSelectionType() != ABITMAP && pOptions->GetSelectionType() != SOMEBITMAPS) { pOptions->SetAsDefaults(); } PaletteType = PAL_OPTIMISED; } // Return with the ok/cancel state used on the dialog box return Ok; #else return FALSE; #endif }

virtual FilterType BaseBitmapFilter::GetFilterType (   )  const [inline, virtual]

Reimplemented in BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 181 of file bitfilt.h. { return INVALID; }

ImagemapFilter * BaseBitmapFilter::GetImagemapFilter (   )  [private]

Gets a pointer to the imagemap filter. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/97 Returns: A pointer to the imagemap filter This function may return NULL and the calling code should handle this case. This is in case we ever build a version of Camelot without an Imagemap Filter. All our code should cope with the Imagemap Filter not being there. Definition at line 5092 of file bitfilt.cpp. { //First get a pointer to the filter manager FilterManager* pFilterManager=Camelot.GetFilterManager(); ERROR2IF(pFilterManager==NULL, NULL, "BaseBitmapFilter::GetImagemapFilter - FilterManager does not exist"); //Then return a pointer to the imagemap filter return ((ImagemapFilter*) pFilterManager->FindFilterFromID(FILTERID_IMAGEMAP)); }

CCLexFile* BaseBitmapFilter::GetImportFile (   )  [inline]

Definition at line 198 of file bitfilt.h. { return InputFile; }

UINT32 BaseBitmapFilter::GetImportMsgID (   )  [inline, virtual]

Used to get the message id to be used during export. Virtual, so that multi-stage importers can change the message. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/95 Returns: The id of the message to put on the progress display whilst importing. See also: DoImport; Reimplemented from Filter. Definition at line 217 of file bitfilt.h. { return ImportMsgID; }

BitmapImportOptions * BaseBitmapFilter::GetImportOptions (   )  [protected, virtual]

To allow a filter to offer the user a choice over what gets imported. Derived BaseBitmapFilter classes should also derive a new BitmapImportOptions class and return a new copy on the heap with the user options in it. BaseBitmapFilter will delete the BitmapImportOptions class when no longer needed. At present used by PhotoCD filter to get image to import. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: A pointer to BitmapImportOptions with the options in it set. NULL if an error occured. See also: BaseBitmapFilter::PrepareToImport; BaseBitmapFilter::DoImport Scope: Protected Reimplemented in JPEGImportFilter. Definition at line 616 of file bitfilt.cpp. { BitmapImportOptions* pOptions = new BitmapImportOptions; return pOptions; }

UINT32 BaseBitmapFilter::GetNumReservedColours (   )  [protected, virtual]

Override this to leave spaces in the palette. eg the GIF filter reserves an index for the transparency mask colour. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/96 Parameters: -  [INPUTS] Returns: The numbers of colours the filter would like to reserve. The base class reserves zero colours. See also: - Reimplemented in MaskedFilter. Definition at line 4675 of file bitfilt.cpp. { return 0; }

BMP_SIZE BaseBitmapFilter::GetPixelHeight (   )  const [protected]

Support function to obtain bitmap info. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: The height of the bitmap to export in pixels Definition at line 1686 of file bitfilt.cpp. { return m_PixelHeight; }

BMP_SIZE BaseBitmapFilter::GetPixelWidth (   )  const [protected]

Support function to obtain bitmap info. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: The width of the bitmap to export in pixels Definition at line 1670 of file bitfilt.cpp. { return m_PixelWidth; }

BOOL BaseBitmapFilter::GetRenderBottomToTop (   )  [virtual]

Find out which way we need to render. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if going to use the default of rendering bottom to top, FALSE otherwise Reimplemented in JPEGExportFilter, and BMPFilter. Definition at line 2398 of file bitfilt.cpp. { return TRUE; }

BMP_DEPTH BaseBitmapFilter::GetRenderDepth (   )  const [inline, protected]

Definition at line 494 of file bitfilt.h. { return m_RenderDepth; }

BOOL BaseBitmapFilter::GetSizeOfBitmap (  INT32 *  PixelWidth, INT32 *  PixelHeight )  [static]

Works out the size of the bitmap in the bitmap export options dialog box. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/95 Parameters: -  [INPUTS] PixelWidth  bitmap width in pixels [OUTPUTS] PixelHeight bitmap height in pixels Returns: True if completed ok. See also: BmpPrefsDlg::RecalculateSize; BaseBitmapFilter::PrepareToExport; Definition at line 4308 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pExportBitmap==NULL,FALSE,"BaseBitmapFilter::GetSizeOfBitmap no bitmap"); ERROR2IF(PixelWidth==NULL,FALSE,"BaseBitmapFilter::GetSizeOfBitmap no PixelWidth"); ERROR2IF(PixelHeight==NULL,FALSE,"BaseBitmapFilter::GetSizeOfBitmap no PixelHeight"); // Set return values in case of early exit *PixelWidth = 0; *PixelHeight = 0; // Get a pointer to the actual bitmap so that we can get some details from it. OILBitmap *pOilBitmap = pExportBitmap->ActualBitmap; ERROR3IF(pOilBitmap == NULL,"BaseBitmapFilter::GetSizeOfBitmap null oil bitmap pointer"); if (pOilBitmap) { BitmapInfo BmInfo; pOilBitmap->GetInfo(&BmInfo); *PixelWidth = BmInfo.PixelWidth; *PixelHeight = BmInfo.PixelHeight; } return TRUE; #else return FALSE; #endif }

DocRect BaseBitmapFilter::GetSizeOfDrawing (  Spread *  pSpread = NULL  )  [static]

Works out the size of the rectangle encompassing the drawing. Code also used to work out the pixel size in the bitmap export options dialog box. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/95 Parameters: pointer  to the spread to use [INPUTS] Added by Graham 11/4/97: If pSpread is NULL, we get the first spread of the current document to use Returns: Size of the rectangle encompassing the drawing. See also: BmpPrefsDlg::RecalculateSize; BaseBitmapFilter::DoExport; Definition at line 4208 of file bitfilt.cpp. { // Start out with an empty clip rect DocRect SpreadRect; SpreadRect.MakeEmpty(); //If we have not been passed a spread... if (pSpread == NULL) { //Then let's get the first spread of the current document Document* pdocCurrent=Document::GetCurrent(); ERROR2IF(pdocCurrent==NULL, DocRect(0,0,0,0), "BaseBitmapFilter - no current document"); //And finally the current spread PORTNOTE("spread", "Multi-spread warning!") pSpread=GetFirstSpread(pdocCurrent); ERROR2IF(pSpread==NULL, DocRect(0,0,0,0), "BaseBitmapFilter - no spread"); } // We need to take into account the fact that some layers may not be visible Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { // We've got a layer so check to see if it is visible // Added 8/4/97 extra checks to see if we are the special layers // and so shouldn't be included in the bounding calulations if (pLayer->IncludeLayerInBoundingCalcs()) { // This one is visible, so union it in DocRect LayerRect = pLayer->GetBoundingRect(); SpreadRect = SpreadRect.Union(LayerRect); } // Get the next sibling layer pLayer = pLayer->FindNextLayer(); } // return the found rectangle to the caller. return SpreadRect; }

UINT32 BaseBitmapFilter::GetSizeOfExport (   )  [inline, protected]

Definition at line 435 of file bitfilt.h. { return SizeOfExport; }

DocRect BaseBitmapFilter::GetSizeOfSpread (  Spread *  pSpread  )  [static]

Works out the size of the rectangle encompassing the spread. Code also used to work out the pixel size in the bitmap export options dialog box. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/95 Parameters: pointer  to the spread to use [INPUTS] Returns: Size of the rectangle encompassing the spread. See also: BmpPrefsDlg::RecalculateSize; BaseBitmapFilter::PrepareToExport; Definition at line 4264 of file bitfilt.cpp. { // Start out with an empty clip rect DocRect SpreadRect; SpreadRect.MakeEmpty(); if (pSpread == NULL) { ERROR3("BaseBitmapFilter::GetSizeOfSpread null spread"); return SpreadRect; } // build a rectangle out of all the pages in the selected spread Node *pPage = pSpread->FindFirstPageInSpread(); ERROR3IF(pPage == NULL, "Spread has no pages"); while (pPage) { if (pPage->GetRuntimeClass() == CC_RUNTIME_CLASS(Page) ) SpreadRect = SpreadRect.Union(( (Page*)pPage)->GetPageRect() ); pPage = pPage->FindNext(); } ERROR3IF(SpreadRect.IsEmpty(),"Current spread has no pages"); return SpreadRect; }

static BOOL BaseBitmapFilter::GetWarnedZoomOnImport (   )  [inline, static]

Definition at line 314 of file bitfilt.h. { return s_fWarnedZoomOnImport; }

static BOOL BaseBitmapFilter::GetZoomOnImport (   )  [inline, static]

Definition at line 311 of file bitfilt.h. { return s_fZoomOnImport; }

BOOL BaseBitmapFilter::ImportBitmap (  CCLexFile *  pDiskFile, KernelBitmap **  ppBitmap, const UINT32  nBitmapToRead )

Imports the nBitmapToRead'th bitmap from the given file. This may be used to import a file either via the menu or from the EPS filters. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 12/06/96 Parameters: pDiskFile  - the CCLexFile from which the bitmap should be imported [INPUTS] nBitmapToRead - the position of the bitmap in the CCLexFile ppBitmap  - a pointer to the KernelBitmap into which the bitmap will be [OUTPUTS] imported Returns: TRUE if the bitmap was imported ok (or if it wasn't imported because the file format does not support it; FALSE if an error occured. Errors: See also: CamelotEPSFilter::ExportBitmap, DoImport(), SGLibOil:: Definition at line 1341 of file bitfilt.cpp. { ERROR2IF(pDiskFile == NULL, FALSE, "pDiskFile - invalid"); ERROR2IF(ppBitmap == NULL, FALSE, "ppBitmap is NULL"); ERROR2IF(nBitmapToRead < 1, FALSE, "nBitmapToRead < 1"); *ppBitmap = NULL; SetBitmapNumber(nBitmapToRead); KernelBitmap* KernelBmp; BOOL IsNew = TRUE; BOOL ReuseExisting = ShouldReuseExistingBitmaps(); if (IsPreviewBitmap) //for preview bitmaps always false ReuseExisting = FALSE; BOOL Success = KernelBitmap::ImportBitmap(this, NULL, 0, &KernelBmp, ReuseExisting ? &IsNew : NULL); if (Success && IsNew) { // Give the bitmap a name from the file path CreateBitmapName(pDiskFile, KernelBmp, nBitmapToRead); // If we have a BitmapSource then use it if (m_pBitmapSource != NULL) { KernelBmp->SetOriginalSource(m_pBitmapSource, this); delete InputFile; InputFile = NULL; } } else { // Throw away the source as we already have it or don't need it if (m_pBitmapSource != NULL) { delete m_pBitmapSource; delete InputFile; InputFile = NULL; } } // Free up dynamic objects used for import and close the file CleanUpAfterImport(); if (!Success) { // Did not work - report this to the caller. return FALSE; } *ppBitmap = KernelBmp; return TRUE; }

BOOL BaseBitmapFilter::ImportBitmap (  CCLexFile *  pDiskFile, KernelBitmap **  ppBitmap )  [virtual]

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 8/4/94 Parameters: -  [INPUTS] Returns: TRUE if the bitmap was imported ok (or if it wasn't imported because the file format does not support it; FALSE if an error occured. Errors: Usual disk/file errors. See also: CamelotEPSFilter::ExportBitmap Reimplemented from Filter. Definition at line 1291 of file bitfilt.cpp. { // Make a note of the disk file we are given InputFile = pDiskFile; if (ProcessImportOptions() == FALSE) return FALSE; // Let's get ready if (!PrepareToImport()) return FALSE; if (!ImportBitmap(pDiskFile, ppBitmap, 1)) { if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return FALSE; } if (m_pImportOptions != NULL) { delete m_pImportOptions; m_pImportOptions = NULL; } return TRUE; }

BOOL BaseBitmapFilter::IncProgressBarCount (  UINT32  n  )  [protected, virtual]

Func to incrementing the progress bar count. If there is a progress bar available, it is updated by this call. Scope: Protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (Markn) Date: 5/6/96 Parameters: n  = amount to inc the progress bar count by [INPUTS] Returns: - Reimplemented from Filter. Definition at line 422 of file bitfilt.cpp. { return TRUE; }

virtual BOOL BaseBitmapFilter::Init (  void   )  [inline, virtual]

Declares a preference that allows you to clear memory in delete(). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/94 Returns: TRUE if it worked OK, FALSE if not Implements Filter. Reimplemented in JPEGExportFilter, JPEGImportFilter, PreviewFilterBMP, PreviewFilterGIF, PreviewFilterJPEG, PreviewFilterPNG, BMPFilter, TI_GIFFilter, ImageMagickFilter, MaskedFilter, PNGFilter, BasePMFilter, PPMFilter, PGMFilter, and PBMFilter. Definition at line 173 of file bitfilt.h. { return TRUE; }

BOOL BaseBitmapFilter::InitBaseClass (   )  [static]

Initialises any static member variables for the base bitmap filter class. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/97 Returns: TRUE if the filter was initialized ok FALSE otherwise Definition at line 304 of file bitfilt.cpp. { if( 9999 == s_fZoomOnImport && Camelot.DeclareSection( _T("Filters"), 10 ) ) { s_fZoomOnImport = TRUE; s_fWarnedZoomOnImport = FALSE; Camelot.DeclarePref( NULL, _T("ZoomToFitOnImport"), &s_fZoomOnImport, FALSE, TRUE ); Camelot.DeclarePref( NULL, _T("WarnedZoomToFitOnImport"), &s_fWarnedZoomOnImport, FALSE, TRUE ); } return BitmapExportOptions::Declare(); }

BOOL BaseBitmapFilter::InsertBitmapOnNewLayer (  SelOperation *  pOp, Spread *  pSpread, NodeBitmap *  pNodeBitmap, Layer **  ppNewLayer )  [protected]

When loading in multiple bitmaps then each bitmap should be inserted onto a new layer. The first bitmap is inserted as the last child on the active layer. Each subsequent bitmap is loaded onto a new layer after this. The routine returns the new layer so that this can be used next time as the insertion point. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 6/5/97 Parameters: pOp  the operation to use to insert new items [INPUTS] pSpread the spread we are using pNodeBitmap the new node bitmap which is to be inserted ppNewlayer  the new layer that was inserted (ready to be used next time around) [OUTPUTS] Returns: TRUE if everything was insert ok, FALSE otherwise. See also: BaseBitmapFilter::DoImport Definition at line 1103 of file bitfilt.cpp. { ERROR2IF(pOp == NULL || pSpread == NULL || pNodeBitmap == NULL || ppNewLayer == NULL,FALSE,"InsertBitmapOnNewLayer bad parameters!"); Layer * pCurrentLayer = NULL; if (*ppNewLayer) { // We have been supplied with the last inserted new layer so use this. pCurrentLayer = *ppNewLayer; } else { // We are the first time through and so try and create // a layer after the active layer and put the bitmap there. // We could do this but we get problems when loading multiple animations. So // do what we do elsewhere and load after the last layer. Layer * pInsertionLayer = pSpread->FindLastLayer(); // No Active layer so get out now! if (pInsertionLayer == NULL) return FALSE; // Use the active layer as the insertion point pCurrentLayer = pInsertionLayer; } // Create the new layer Layer* pNewLayer = new Layer; if (pNewLayer == NULL) return FALSE; // Ensure that the layer name has a frame flavour about it // We also need to add an imported at the start so that if the original Frame 1 // layer is deleted as it has nothing on it, then the layer is not called Frame 2 // but Imported Frame 1 String_256 LayerName(_R(IDS_K_EPSFILTER_IMPORTED)); String_256 Suffix(_R(IDS_DEFAULTFRAMENAME)); // Frame LayerName += Suffix; PORTNOTE("dialog","Removed FrameSGallery usage") #ifndef EXCLUDE_FROM_XARALX String_256 NewLayerName = FrameSGallery::CreateUniqueLayerID(pSpread, &LayerName); #else String_256 NewLayerName = ""; #endif pNewLayer->SetLayerID(NewLayerName); pNewLayer->SetVisible(TRUE); // Ensure visible pNewLayer->SetLocked(FALSE); // Ensure unlocked so insertion works pNewLayer->SetPrintable(FALSE); pNewLayer->SetBackground(FALSE); // Ensure it is foreground pNewLayer->SetOutline(FALSE); pNewLayer->SetGuide(FALSE); pNewLayer->SetPageBackground(FALSE); #ifdef WEBSTER // In Webster mode, always make the new layer a frame layer pNewLayer->SetFrame(TRUE); // Mark it as a frame layer #else // In Camelot mode, only make the new layer a frame layer if there are // already frame layers in the document Layer * pFrame = pSpread->FindFirstFrameLayer(); if (pFrame != NULL) pNewLayer->SetFrame(TRUE); // Mark it as a frame layer else pNewLayer->SetFrame(FALSE); // Mark it as a layer #endif // Insert the new layer as the next node after the last page. if (!pOp->DoInsertNewNode(pNewLayer, pCurrentLayer, NEXT, FALSE,FALSE,FALSE,FALSE)) { delete pNewLayer; pNewLayer = NULL; // Return the new layer to the caller *ppNewLayer = pNewLayer; return FALSE; } // And now insert the bitmap node into the new layer if (!pOp->DoInsertNewNode(pNodeBitmap, pNewLayer, FIRSTCHILD,FALSE,FALSE,FALSE,FALSE)) { // It didn't work - hide the layer sub-tree we just created pOp->DoHideNode(pNewLayer, TRUE); // Return the new layer to the caller as null *ppNewLayer = NULL; // Assume the caller deletes the node bitmap return FALSE; } pNewLayer->SetVisible(FALSE); // Ensure it is invisible pNewLayer->SetLocked(TRUE); // Ensure locked // Set the fact that this layer is presently fully defined by this bitmap KernelBitmap * pBitmap = pNodeBitmap->GetBitmap(); pNewLayer->SetReferencedBitmap(pBitmap); pNewLayer->EnsureUniqueLayerID(); BROADCAST_TO_ALL( SpreadMsg( pSpread, SpreadMsg::LAYERCHANGES ) ); // Return the new layer to the caller *ppNewLayer = pNewLayer; return TRUE; }

BOOL BaseBitmapFilter::IsDefaultDocRequired (  const TCHAR *  pcszPathName  )  [virtual]

Works out if opening a file of this type requires a default document to be loaded. If the file format supplies the document then return FALSE otherwise return TRUE. An example would be opening a bitmap file. This has no document defined in the file format and so we need to laod the default document before importing the bitmap into this file. In this baseclass version return FALSE and hence assume that the filters that need to will override this function to return TRUE. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/95 Parameters: pcszPathName  pointer to the pathname to check [INPUTS] Returns: TRUE if the filter requires a default document, FALSE if not. See also: Filter; Filter::IsDefaultDocRequired; CCamDoc::OnOpenDocument; FilterFamily::DoImport; Filter::DoImport; Reimplemented from Filter. Reimplemented in TI_GIFFilter. Definition at line 401 of file bitfilt.cpp. { // No need to check the pathname, just return TRUE as all currently known bitmap filters // will require the default document. return TRUE; }

BOOL BaseBitmapFilter::IsFormatLossy (   )  const [virtual]

Provides information to the BaseBitmapFilter so that it knows whether or not to provide a BitmapSource to prevent progressive degradation of the bitmap when exported via the new file format. Notes: Derived classes should override this function for their particular implementation. > virtual BOOL BaseBitmapFilter::IsFormatLossy() const Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Returns: TRUE if the file format for the derived filter is lossy FALSE otherwise Reimplemented in JPEGImportFilter. Definition at line 640 of file bitfilt.cpp. { return FALSE; }

BOOL BaseBitmapFilter::IsSecondPassRequired (   )  [virtual]

Determines if the a second rendering pass is required or not. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/09/95 Returns: True if this filter wants a second export rendering pass and so have a chance to setup semething like a mask. False if no second pass required. See also: DoExport; Reimplemented in GrabFrameFilter. Definition at line 376 of file bitfilt.cpp. { return FALSE; }

BOOL BaseBitmapFilter::IsThisBppOk (  UINT32  Bpp  )  [virtual]

Check if this Bitmap filter can cope with saving at this Bpp/Colour depth. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/95 Parameters: Bpp  or Colour depth. [INPUTS] Returns: TRUE if this filter can cope with this colour depth, FALSE otherwise. See also: OpMenuExport::DoWithParam; Reimplemented in JPEGExportFilter, MakeBitmapFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, PNGFilter, and BasePMFilter. Definition at line 4349 of file bitfilt.cpp. { // Base class version so always return FALSE. return FALSE; }

void BaseBitmapFilter::PostGetExportOptions (  BitmapExportOptions *  pOptions  )  [virtual]

Reimplemented in JPEGExportFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 1779 of file bitfilt.cpp. { pOptions->SetAsDefaults(); }

BOOL BaseBitmapFilter::PrepareBitmapSource (   )  [protected]

The PrepareToImport() function calls this member to create a BitmapSource for lossy file formats, and a CCLexFile to work with it. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 21/08/96 Returns: TRUE if successful FALSE otherwise See also: IsFormatLossy() Scope: protected Definition at line 484 of file bitfilt.cpp. { #ifdef DO_EXPORT OFFSET offset = GetDataStartOffset(); OFFSET size = InputFile->Size() - offset; // Create the actual BitmapSource object m_pBitmapSource = CreateBitmapSource(size); if (m_pBitmapSource == NULL || !m_pBitmapSource->IsOK()) { Error::SetError(_R(IDS_OUT_OF_MEMORY)); return FALSE; } // Check for errors but let CCFile report them InputFile->SetThrowExceptions(FALSE); InputFile->SetReportErrors(TRUE); // Ignore those superfluous bits at the start of the file InputFile->seekIn(offset); if (!InputFile->good()) { return FALSE; } // Now create a file to fill our BitmapSource & provide the filter with something // to work with CCBufferFile* pBufferFile = new CCBufferFile(InputFile); if (pBufferFile == NULL || !pBufferFile->IsInited()) { Error::SetError(_R(IDS_OUT_OF_MEMORY)); return FALSE; } // We have a file, so attach out BitmapSource to it m_pBitmapSource->AttachToBufferFile(pBufferFile); // Now ditch our current InputFile in favour of the BitmapSource's one // We don't need InputFile again InputFile = (CCLexFile*)pBufferFile; #endif return TRUE; }

BOOL BaseBitmapFilter::PrepareToExport (  Spread *  pSpread, UINT32  Depth, double  DPI, SelectionType  , UINT32  Dither = XARADITHER_ORDERED_GREY )  [protected, virtual]

Reimplemented in JPEGExportFilter. Definition at line 1921 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pSpread==NULL,FALSE,"BaseBitmapFilter::PrepareToExport null spread pointer"); // Check whether the selection contains objects that can't be represented // in a bitmap if (WarnIfIncompatible()==FALSE) { ERRORIF(TRUE, _R(IDN_USER_CANCELLED), FALSE); } // We need to decide what clipping rectangle to set up which we will then render the // bitmap through. The choice might be to export:- // - the selection bounds (if there is a selection), // - or the current spread // - or the current drawing // Ask the virtual function to set it up for us if (ClipRect.IsEmpty()) SetUpClippingRectangleForExport(pSpread, Selection); // We can either have no selection present whereby the user may have chosen to export // the spread or the drawing OR we have a selection present whereby the user may have // chosen to export the spread or drawing instead. In the later case we must output the // spread instead of the selection but double check there is a selection. if (ClipRect.IsEmpty() || ClipRect.Width() < MinExportSize || ClipRect.Height() < MinExportSize || ((Selection==SPREAD) && (!IsPreviewBitmap))) { // Use our function to work out the size of the spread ClipRect = GetSizeOfSpread(pSpread); if (ClipRect.IsEmpty()) { ENSURE(FALSE, "Current spread has no pages"); ERRORIF(TRUE, _R(IDT_DOC_BADSTRUCTURE), FALSE); } } // Don't use rendering matrix when exporting BMPs as it uses coordinates as is Matrix Identity; // Don't use view scale; set to 1 FIXED16 Scale(1); // If this is the Preview bitmap, the scale may need changin if (IsPreviewBitmap) { // Find out the maximum dimension of the clip rect MILLIPOINT Width = ClipRect.Width(); MILLIPOINT Height = ClipRect.Height(); MILLIPOINT MaxSize = (Width>Height) ? Width : Height; // this can't happen considering the code above - but you never know. ERROR3IF( MaxSize==0, "BaseBitmapFilter::PrepareToExport both dimensions of preview are zero"); // stop div zeros. We set it quite high here otherwise we get huge values in the DPI field if (MaxSize==0) MaxSize = 1000; // Set the scale factor to get this down into the required size //WEBSTER-Martin-02/01/97 MILLIPOINT WantSize = PreviewFilter::PreviewBitmapSize; // Removed changes to 'Scale' variable so the scale factor is // now always 1. Jonathan Payne, 8/9/2000. // The Scale Factor is not actually used, so we have to change the size of things // by effecting the DPI. Scale the DPI, but make sure it does not get too small. DPI = ((double)WantSize) / ((double)MaxSize) * DPI; if (DPI < 4.0) DPI = 4.0; //WEBSTER-Martin-30/01/97 // It doesn't matter what rounding we do here, but there is a problem because the bitmap // is not exactly the same size as the cliprect need something like ??? Any region outside // the cliprect is rendered as black hence the black lines that appear at the top and bottom // of some previews. It is especially noticable when the original is smaller than the preview. // Here we are using the dpi to do some scaling we're not really concerned with the exact value INT32 b_dpi = (INT32) DPI; DPI = (double)b_dpi; //round down } else { // Ensure Bitmap is at least 1 pixel square! if (ClipRect.Width()<PIXELWIDTH) ClipRect.hi.x = ClipRect.lo.x + PIXELWIDTH; if (ClipRect.Height()<PIXELHEIGHT) ClipRect.hi.y = ClipRect.lo.y + PIXELHEIGHT; } // Remember the size of the bitmap WinRect Rect = OSRenderRegion::BitmapDocRectToWin( Identity, ClipRect, DPI ); SetPixelWidth(Rect.GetWidth()); SetPixelHeight(Rect.GetHeight()); // Create the region // TRACEUSER( "Gerry", _T("PrepareToExport creating GRenderBitmap %d bpp (cmyk = %d)\n"), Depth, GetBitmapExportOptions()->IsCMYK()); ExportRegion = new GRenderBitmap(ClipRect, Identity, Scale, Depth, DPI, FALSE, Dither, NULL, TRUE); if (ExportRegion == NULL) // Error already set by new, so just return return FALSE; ExportRegion->SetFilter(this); // exporting a bitmap, so we will want any bitmaps used in there to be of the best quality - sjk ExportRegion->SetUsingSmoothedBitmaps(TRUE); // MarkH 23/7/99 - New Flag to say that we require to render using the biCompression Field if(GetBitmapExportOptions()->GetDepth() == 32) { ExportRegion->m_DoCompression = TRUE; } // we need a View to Attach to, so that: // default Quality setting // CalcPixelWidth etc get called DocView *View = DocView::GetCurrent(); if (View) { // Must force background rendering off as otherwise we might get a partly // rendered drawing or object if it is complex. ForceBackgroundRedrawOff(View); if (GetBitmapExportOptions()->GetDepth() == 1) { // If we are outputting at 1bpp, then we'll force antialiasing off, // so that Gavin's palette optimisation can detect objects which // are 'one solid colour' ForceAntialiasingOff(View); } // If we are in preview bitmap mode then force anti-aliasing to be full // rather than the default setting for the view if (IsPreviewBitmap) { ForceAntialiasingFull(View); } // Attach to the right device. (note no DC) ExportRegion->AttachDevice(View, NULL, pSpread); } else { ERROR2(FALSE,"BaseBitmapFilter::WriteToFile no current view"); } #endif // All ok return TRUE; }

BOOL BaseBitmapFilter::PrepareToImport (   )  [protected, virtual]

Prepare to import bitmap data using this filter. This sets up the filter to a sensible state for reading. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 Returns: TRUE if succeeded, FALSE if not. Errors: Out of memory. See also: BaseBitmapFilter::DoImport; BaseBitmapFilter::CleanUpAfterImport Scope: Private Definition at line 545 of file bitfilt.cpp. { ERROR2IF(InputFile == NULL, FALSE, "InputFile is NULL"); // Assume we won't want a BitmapSource m_pBitmapSource = NULL; #ifdef DO_EXPORT // Do we need to keep the data to prevent it from deteriorating? if (IsFormatLossy()) { // SetTotalProgressBarCount(InputFile->Size()); ...one day if (!PrepareBitmapSource()) { return FALSE; } } #endif return TRUE; }

BOOL BaseBitmapFilter::ProcessImportOptions (   )  [protected, virtual]

Validates the options returned by GetImportOptions Sets m_pImportOptions if OK Shouldn't really be overridden. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 12/06/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if it is OK to continue processing FALSE if an error occured or the user cancelled the import, in which case Error::SetError is called signalling the fact. See also: BaseBitmapFilter::DoImport() Definition at line 1416 of file bitfilt.cpp. { // Get any user options, if required ERROR3IF(m_pImportOptions != NULL, "m_pImportOptions not deleted"); BitmapImportOptions* options = GetImportOptions(); if (options == NULL) { ERROR3("options is NULL"); return FALSE; } ERROR3IF(!options->IS_KIND_OF(BitmapImportOptions), "options is not"); if (!options->m_bValid) { delete options; m_pImportOptions = NULL; return TRUE; } if (options->m_bCancelled) { delete options; m_pImportOptions = NULL; Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel return FALSE; // if cancelled } m_pImportOptions = options; return TRUE; }

BOOL BaseBitmapFilter::ReadFromFile (  OILBitmap *  pOilBitmap, BaseCamelotFilter *  pFilter, CCLexFile *  pFile, BOOL  IsCompressed )  [virtual]

Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record. IsCompressed is only used for BMP/BMPZIP type bitmaps at present. Assumes: pFile has already been opened up for reading pFilter has been set up for reading the data e.g. progress bar. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/96 Parameters: pOilBitmap  pointer to the oil bitmap data to be filled in [INPUTS] pFilter - the BaseCamelotFilter which provides functions like progress update pFile - the CCFile class to use to read the data from IsCompressed - Flag to say the bitmap is compressed or not. Will  have filled in BMInfo pointer to the bitmap header to fill in [OUTPUTS] BMBytes pointer to the bitmap data to fill in Returns: TRUE if worked, FALSE if failed. Reimplemented in JPEGImportFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 1546 of file bitfilt.cpp. { ERROR3("Base class bitmap filter ReadFromFile called"); return FALSE; }

BOOL BaseBitmapFilter::ReadFromFile (  OILBitmap *  pOilBitmap  )  [virtual]

Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/95 Parameters: pOilBitmap  pointer to the oil bitmap data to be filled in [INPUTS] Will  have filled in BMInfo pointer to the bitmap header to fill in [OUTPUTS] BMBytes pointer to the bitmap data to fill in Returns: TRUE if worked, FALSE if failed. Reimplemented in JPEGImportFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, PNGFilter, and BasePMFilter. Definition at line 1514 of file bitfilt.cpp. { ERROR3("Base class bitmap filter ReadFromFile called"); return FALSE; }

void BaseBitmapFilter::RestoreBackgroundRedrawState (  DocView *  pView  )  [protected]

Restores the background redraw state in the specified view, to the state before we called BaseBitmapFilter::ForceBackgroundRedrawOff. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Parameters: pView,pointer  to the View to change [INPUTS] Returns: - Errors: - See also: BaseBitmapFilter::ForceBackgroundRedrawOff Scope: Protected Definition at line 2219 of file bitfilt.cpp. { ERROR3IF(pView == NULL, "NULL pointer passed into BaseBitmapFilter::RestoreBackgroundRedrawState"); if (pView == NULL) return; // Only restore if we saved the state earlier ... if (BackgroundRedrawStateSet) { pView->SetForeBackMode(BackgroundRedrawState); BackgroundRedrawStateSet = FALSE; } }

void BaseBitmapFilter::RestoreViewQuality (  DocView *  pView  )  [protected]

Restores the view quality to the state before we called ForceAntialiasingOff. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Parameters: pView,pointer  to the View to change [INPUTS] Returns: - Errors: - See also: BaseBitmapFilter::ForceAntialiasingOff Scope: Protected Definition at line 2314 of file bitfilt.cpp. { ERROR3IF(pView == NULL, "NULL pointer passed into BaseBitmapFilter::RestoreViewQuality"); if (pView == NULL) return; if (ViewQualitySet) { // Restore the previous view quality pView->RenderQuality = ViewQuality; ViewQualitySet = FALSE; } }

BOOL BaseBitmapFilter::SaveExportBitmapsToFile (  CCLexFile *  pFile, PathName *  pPath, BitmapExportParam *  pParam, BOOL  DontShowFileName = FALSE )  [virtual]

Exports the bitmaps specified by the BitmapExportParam object to a multi- image capable filter. Each of the bitmaps will be saved to file using the settings specified. This is the baseclass version and so is usually overriden. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/97 Parameters: pDiskFile  - the file to put the exported data into [INPUTS] pPath - the pathname of the file to be exported to pParam - the data to use when exporting the bitmaps DontShowFileName - if set to true then don't show the filename in the progress string Returns: TRUE if worked, FALSE if failed. Reimplemented in TI_GIFFilter. Definition at line 3594 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pFile == NULL || pPath == NULL, FALSE,"NULL Parameters"); ERROR2IF(pParam == NULL,FALSE,"TI_GIFFilter::DoExportBitmaps null BitmapExportParam specified"); ERROR3("BaseBitmapFilter::SaveExportBitmapsToFile calling baseclass version!"); return TRUE; #endif return FALSE; }

BOOL BaseBitmapFilter::SetAnimationPropertiesFromLoaded (  Spread *  pSpread  )  [protected, virtual]

When loading in multiple bitmaps and placing them on new layers, we should give the filter an opportunity after all the bitmaps have been loaded, to go and look at the bitmaps and set the animation properties accordingly. In the case of a GIF filter this would allow it to set the dithering to none and the palette to something closer to what has been loaded. This baseclass version does nothing. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 8/7/97 Parameters: pSpread  the spread that the bitmaps have been put on [INPUTS] Returns: TRUE if was ok, FALSE otherwise. Reimplemented in TI_GIFFilter. Definition at line 1269 of file bitfilt.cpp. { // Do nothing return TRUE; }

BOOL BaseBitmapFilter::SetBitmapNumber (  const UINT32  nBitmapToRead  )  [protected]

Once a filter has read a bitmap it should call this member function with the number of the next bitmap that can be read. If there are none, SetLastBitmap() should be called instead. Scope: protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 11/06/96 Parameters: -  [INPUTS] Returns: TRUE if set OK FALSE otherwise See also: SetLastBitmap(), GetBitmapNumber() Definition at line 1591 of file bitfilt.cpp. { ERROR2IF(nBitmapToRead < 1, FALSE, "nBitmapToRead invalid"); m_nBitmapToRead = nBitmapToRead; return TRUE; }

void BaseBitmapFilter::SetDepthToRender (  const BMP_DEPTH &  Depth  )  [inline, protected]

Definition at line 493 of file bitfilt.h. { m_RenderDepth = Depth; }

virtual BOOL BaseBitmapFilter::SetExportHint (  Document *  pDoc  )  [inline, protected, virtual]

Reimplemented in JPEGExportFilter, and MaskedFilter. Definition at line 408 of file bitfilt.h. { return(TRUE); }

BOOL BaseBitmapFilter::SetExportOptions (  BitmapExportOptions *  pOptions  )

To allow that f!?$g MakeBitmapFilter have its wicked way. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Returns: TRUE if successful FALSE otherwise Definition at line 4768 of file bitfilt.cpp. { ERROR3IF ( pOptions != NULL && !pOptions->IS_KIND_OF ( BitmapExportOptions ), "BitmapExportOptions is wrong kind" ); // Don't delete the old options unless specifically requested. This is to avoid the nasty // access violations that might occur otherwise. //if (m_pExportOptions && pOptions != m_pExportOptions) // delete m_pExportOptions; m_pExportOptions = pOptions; return TRUE; }

BOOL BaseBitmapFilter::SetFlagsFromBitmap (  Layer *  pLayer, KernelBitmap *  pBitmap, UINT32  nBitmapToRead )  [protected, virtual]

When loading in multiple bitmaps and placing them on new layers, we should give the filter an opportunity to set the layer flags from the bitmap. In the case of a GIF filter this would allow it to set the solid and overlay flags. This baseclass version does nothing. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/5/97 Parameters: pLayer  the layer that the bitmap is being put on [INPUTS] pBitmap the bitmap being placed on the layer nBitmapToRead the number of the bitmap in the sequence Returns: TRUE if was ok, FALSE otherwise. Reimplemented in TI_GIFFilter. Definition at line 1224 of file bitfilt.cpp. { // Do nothing return TRUE; }

virtual void BaseBitmapFilter::SetImportDPI (  DPI  ImportDPI  )  [inline, virtual]

Reimplemented in ImageMagickFilter. Definition at line 309 of file bitfilt.h. {}

BOOL BaseBitmapFilter::SetLastBitmap (   )  [protected]

When the bitmap filter has no more bitmaps to read from its file it should call this member function. Scope: protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 11/06/96 Parameters: -  [INPUTS] Returns: TRUE if set OK FALSE otherwise See also: SetBitmapNumber(), GetBitmapNumber() Definition at line 1613 of file bitfilt.cpp. { m_nBitmapToRead = -1; return TRUE; }

BOOL BaseBitmapFilter::SetPixelHeight (  const BMP_SIZE &  Height  )  [protected]

Support function to obtain bitmap info See Also: GetExportHeight(). Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Parameters: Height  : The pixel height of the bitmap to be exported [INPUTS] Returns: TRUE if the operation was successful FALSE otherwise Definition at line 1705 of file bitfilt.cpp. { m_PixelHeight = Height; return TRUE; }

BOOL BaseBitmapFilter::SetPixelWidth (  const BMP_SIZE &  Width  )  [protected]

Support function to obtain bitmap info See Also: GetExportHeight(). Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/96 Parameters: Width  : The width of the bitmap to be exported in pixels [INPUTS] Returns: TRUE if the operation was successful FALSE otherwise Definition at line 1653 of file bitfilt.cpp. { m_PixelWidth = Width; return TRUE; }

void BaseBitmapFilter::SetPreviewBitmap (  BOOL  IsPreviewBmp  )

Allows you to set the state of this flag. Always set it back to FALSE after the export as the filter hangs around, ready for the next export. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: isPreviewBmp  - TRUE if this bitmap we are saving is actually a Preview bitmap [INPUTS] FALSE if not. Definition at line 333 of file bitfilt.cpp. { IsPreviewBitmap = IsPreviewBmp; }

void BaseBitmapFilter::SetSizeOfExport (  UINT32  NewVal  )  [inline, protected]

Definition at line 436 of file bitfilt.h. { SizeOfExport = NewVal; }

void BaseBitmapFilter::SetTotalProgressBarCount (  UINT32  n  )  [protected]

Func to set total the progress bar count. If there is a progress bar available, it is updated by this call. Scope: Protected. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (Markn) Date: 5/6/96 Parameters: n  = amount to set the total progress bar count to [INPUTS] Definition at line 440 of file bitfilt.cpp. { ERROR3IF(n == 0,"Should only be set to a value greater that 0"); m_TotalProgressBarCount = n; }

BOOL BaseBitmapFilter::SetUpClippingRectangleForExport (  Spread *  pSpread, SelectionType  Selection )  [virtual]

Sets up the class variable ClipRect to be the clipping rectangle to be used during export. See Also: PrepareToExport(). > virtual BOOL BaseBitmapFilter::SetUpClippingRectangleForExport(Spread *pSpread, SelectionType Selection) Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Parameters: pSpread  the spread to export [INPUTS] Selection the selection type to use during export Returns: TRUE if the operation was successful FALSE otherwise Reimplemented in GrabFrameFilter. Definition at line 1803 of file bitfilt.cpp. { ERROR2IF(pSpread == NULL,FALSE,"SetUpClippingRectangleForExport Bad spread"); // We need to decide what clipping rectangle to set up which we will then render the // bitmap through. The choice might be to export:- // - the selection bounds (if there is a selection), // - or the current spread // - or the current drawing // First, check if there is a selection present. ClipRect should be empty if not. // Karim 17/07/2000 // We need to take controller nodes into account when we're finding this bbox, // which means temporarily setting PromoteToParent on the selection. SelRange* pSel = GetApplication()->FindSelection(); if (pSel != NULL) { ClipRect = pSel->GetBoundingRect(TRUE); } // However, if this is a Preview Bitmap then use the spreads bounds as the clip rect // This should in fact be the bounding rectangle of all visible layers in the current // drawing. if (IsPreviewBitmap || (Selection==DRAWING)) { // Work out the size of the rectangle encompassing the drawing (visible layers only) ClipRect = GetSizeOfDrawing(pSpread); } if (!IsPreviewBitmap && (Selection==SELECTION)) { // Quick check to make sure the selection is something sensible ... SelRange* pSel = GetApplication()->FindSelection(); if (pSel && pSel->Count()==1) { // Only one thing selected ... Is it the Text Caret per chance ? Node* pSelNode = pSel->FindFirst(); if (pSelNode && pSelNode->IsAVisibleTextNode()) { VisibleTextNode* pTextNode = (VisibleTextNode*)pSelNode; if (pTextNode->IsACaret()) { // Aha! It's the Caret that's selected. // We'll use the bounds of the parent text line instead then ... Node* pTextLine = pTextNode->FindParent(); ERROR3IF(!IS_A(pTextLine, TextLine), "Caret doesn't have a parent text line in DoCreateBitmap"); // Get the bounds of the text line ClipRect = ((TextLine*)pTextLine)->GetBoundingRect(); Selection = DRAWING; } } } } // If this is the Preview bitmap, then we have to check for too big and too small cases if (IsPreviewBitmap) { // Find out how big the preview is at the moment MILLIPOINT Width = ClipRect.Width(); MILLIPOINT Height = ClipRect.Height(); // Note from Martin: This is probably a bodge connected with the scaling bodge which // has been corrected below, but I'm leaving this one in cos it leaves a nice 1 pixel // boarder round the thumbnail. // Inflate the rect a little as we can get odd clipping effects at the edges otherwise ClipRect.Inflate(Width/128, Height/128); // Define what too big and too small are // bigger the 2 feet or smaller than 1/2 inch MILLIPOINT MaxWidth = 72000 * 12 * 2; MILLIPOINT MinWidth = 72000 / 2; // See if the rectangle is too big or too small and fix it if it is MILLIPOINT WidthChange = 0; MILLIPOINT HeightChange = 0; // too big? WidthChange = Width>MaxWidth ? (MaxWidth - Width)/2 : 0; // a -ve number HeightChange = Height>MaxWidth ? (MaxWidth - Height)/2 : 0; // a -ve number // too little? WidthChange = Width<MinWidth ? (MinWidth - Width)/2 : 0; // a +ve number HeightChange = Height<MinWidth ? (MinWidth - Height)/2 : 0; // a +ve number // Shrink or expand the clip rect if ( WidthChange || HeightChange ) ClipRect.Inflate( WidthChange, HeightChange ); } return TRUE; }

BOOL BaseBitmapFilter::SetUpExportBitmapOptions (  BitmapExportOptions **  ppExportOptions, KernelBitmap *  pBitmap, BOOL  OnlyDefaults = FALSE )

Displays the export options dialog for this bitmap filter. This allows export options to be obtained by somebody else then the filter. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/97 Parameters: [INPUTS]  ppExportOptions  - pointer, where a pointer to the export options object [OUTPUTS] will be returned Returns: TRUE if worked, FALSE if failed. Definition at line 3374 of file bitfilt.cpp. { #ifdef DO_EXPORT ERROR2IF(pBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null bitmap pointer specified"); // Note this pointer for later use pExportBitmap = pBitmap; // Note this ptr for use in JPEG export. JPEGExportOptions::SetKernelBitmap(pBitmap); // Get a pointer to the actual bitmap so that we can get some details from it. OILBitmap *pOilBitmap = pBitmap->ActualBitmap; ERROR2IF(pOilBitmap == NULL,FALSE,"BaseBitmapFilter::DoExportBitmap null oil bitmap pointer"); // Create a record of information about the export *ppExportOptions = CreateExportOptions(); if (*ppExportOptions == NULL) { return FALSE; } // Get the default settings (*ppExportOptions)->RetrieveDefaults(); // Specify to the user what the export options for depth etc are going to be (*ppExportOptions)->SetSelectionType(ABITMAP); // Get the details from the specified bitmap BitmapInfo BmInfo; pOilBitmap->GetInfo(&BmInfo); (*ppExportOptions)->SetDepth(BmInfo.PixelDepth); // get the bitmaps bpp // Should really save the dpi when we load the file itself rather than doing // all this conversion with possible rounding errors. // Use the original size that has been calculated in the info header UINT32 PixWidth = BmInfo.PixelWidth; // UINT32 PixHeight = BmInfo.PixelHeight; MILLIPOINT RecWidth = BmInfo.RecommendedWidth; // MILLIPOINT RecHeight = BmInfo.RecommendedHeight; if (PixWidth > 0) { (*ppExportOptions)->SetDPI((PixWidth * 72000.0)/(double)RecWidth); } // WEBSTER - markn 5/2/97 // If the bitmap has a transparent colour index, store it in the options object // -1 means no transparent colour INT32 TransIndex = -1; if (!pBitmap->GetTransparencyIndex(&TransIndex)) TransIndex = -1; (*ppExportOptions)->SetTransparencyIndex(TransIndex); // check whether only the defaults are needed if (OnlyDefaults) return TRUE; BOOL ok = GetExportOptions(*ppExportOptions); if (!ok) { if (*ppExportOptions != NULL) { delete *ppExportOptions; *ppExportOptions = NULL; } Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel return FALSE; // if cancelled } return ok; #else return FALSE; #endif }

BOOL BaseBitmapFilter::SetUpExportOptions (  BitmapExportOptions **  ppExportOptions, BOOL  OnlyDefaults = FALSE )

Displays the export options dialog for this bitmap filter. This allows export options to be obtained by somebody else then the filter. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/97 Parameters: [INPUTS]  ppExportOptions  - pointer, where a pointer to the export options object [OUTPUTS] will be returned Returns: TRUE if worked, FALSE if failed. NB. SMFIX sjk this function will if you pass it a NULL ptr new the correct options for the filter for the calling function. This is great. However in this case the caller function has responsibility to delete this export object when they are finished with it. They receive the export object through the static member variable BmapPrevDlg::m_pExportOptions which is a ptr to the base class BitmapExportOptions, rather than just filling in the users structure, since if the graphic type has changed the users class will have been deleted and the export object could be a different class derived from BitmapExportOptions. Definition at line 3009 of file bitfilt.cpp. { ERROR2IF(ppExportOptions == NULL, FALSE,"BaseBitmapFilter::Can't Set up export options"); Document *pDoc = Document::GetCurrent(); // Get pointer to the spread to export. PORTNOTE("spread", "Multi-spread warning!") pSpread = GetFirstSpread(pDoc); ERROR2IF(pSpread == NULL, FALSE,"BaseCamelotFilter::DoExport no spread to export"); // We must now check if there is a selection present so that we can set up whether the // user gets the choice of exporting the selection, drawing or spread if there is a // selection present OR just a choice between the spread or drawing if no selection is // present. // If have a caret selected in a text story then the selection will be almost zero so trap // this case as well. DocRect ClipRect = GetApplication()->FindSelection()->GetBoundingRect(TRUE); SelectionType Selection = DRAWING; if ( ClipRect.IsEmpty() || ClipRect.Width() < MinExportSize || ClipRect.Height() < MinExportSize ) Selection = DRAWING; // no selection present, so choose drawing by default else Selection = SELECTION; // selection present, so choose this by default if (Selection == DRAWING) { // Work out the size of the rectangle encompassing the drawing (visible layers only) ClipRect = GetSizeOfDrawing(pSpread); // Check that that cliprect is ok, if not then set the spread as the export type if ( ClipRect.IsEmpty() || ClipRect.Width() < MinExportSize || ClipRect.Height() < MinExportSize ) Selection = SPREAD; } // If there is no selection then warn the user that exporting the current spread may // take a lot of disc space, but only if this is not a Preview Bitmap. if ((!IsPreviewBitmap) && (Selection == SPREAD)) { // Warn the user that there is no selection = large export ErrorInfo Info; Info.ErrorMsg = _R(IDT_BMPEXP_NOSELECTION); Info.Button[0] = _R(IDB_EXPQUERY_EXPORT); Info.Button[1] = _R(IDB_EXPQUERY_DONTEXPORT); if ((ResourceID)AskQuestion(&Info) == _R(IDB_EXPQUERY_DONTEXPORT)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel return FALSE; // if cancelled } } // Create a record of information about the export *ppExportOptions = CreateExportOptions(); if (*ppExportOptions == NULL) { return FALSE; } (*ppExportOptions)->RetrieveDefaults(); (*ppExportOptions)->SetSelectionType(Selection); // check whether only the defaults are needed if (OnlyDefaults) return TRUE; // get the user options for depth etc here BOOL ok = GetExportOptions( *ppExportOptions ); // remember this ptr and make it externally available // dont do this any more the above call brings up the export dlg and sets the BmapPrevDlg::m_pExportOptions // even when the user has messed around with them //BmapPrevDlg::m_pExportOptions = *ppExportOptions; // so rather the *ppExportOptions should reflect the state that the dlg left them in if (BmapPrevDlg::m_pExportOptions) *ppExportOptions = BmapPrevDlg::m_pExportOptions; if (!ok) { if (*ppExportOptions != NULL) { delete *ppExportOptions; *ppExportOptions = NULL; } Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set on cancel BmapPrevDlg::m_pExportOptions = NULL; // we have no export options return FALSE; // if cancelled } return TRUE; }

static void BaseBitmapFilter::SetWarnedZoomOnImport (  BOOL  fFlag  )  [inline, static]

Definition at line 315 of file bitfilt.h. { s_fWarnedZoomOnImport = fFlag; }

static void BaseBitmapFilter::SetZoomOnImport (  BOOL  fFlag  )  [inline, static]

Definition at line 312 of file bitfilt.h. { s_fZoomOnImport = fFlag; }

virtual BOOL BaseBitmapFilter::ShouldReuseExistingBitmaps (   )  [inline, virtual]

Reimplemented in TI_GIFFilter. Definition at line 221 of file bitfilt.h. { return TRUE; }

BOOL BaseBitmapFilter::WarnIfIncompatible (   )  [protected]

Checks for things that can't be represented using the current options E.g. non-mix transparencies in Alpha channel bitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 14/05/2004 Parameters: -  [INPUTS] Returns: TRUE is can continue FALSE if export should be aborted Errors: - Scope: Protected Definition at line 2087 of file bitfilt.cpp. { // Check whether the user has asked us to be silent about this if (bDontWarnBitmapNonMixTransp) return TRUE; // Check whether the export options will make transparencies difficult // Is export type 32BPP including alpha? // If not everything's OK if (m_pExportOptions->GetDepth()!=32) { return TRUE; } // Check whether the export selection contains non-mix transparency BOOL bFound = FALSE; Node* pNode = NULL; switch (m_pExportOptions->GetSelectionType()) { case SELECTION: { Range* pscanrange; pscanrange = Camelot.FindSelection(); pNode = pscanrange->FindFirst(TRUE); while (pNode!=NULL && !bFound) { if (pNode->IsAnAttribute()) { if (((NodeAttribute*)pNode)->IsATranspFill()) { UINT32 transptype = ((AttrFillGeometry*)pNode)->GetTranspType(); if (transptype!=TT_Mix && transptype!=TT_NoTranspType) bFound = TRUE; } } pNode = pscanrange->FindNext(pNode, TRUE); } } break; case DRAWING: case PAGE: case SPREAD: { Node* pRootNode = pSpread; pNode = pRootNode->FindFirstDepthFirst(); while (pNode!=NULL && !bFound) { if (pNode->IsAnAttribute()) { if (((NodeAttribute*)pNode)->IsATranspFill()) { UINT32 transptype = ((AttrFillGeometry*)pNode)->GetTranspType(); if (transptype!=TT_Mix && transptype!=TT_NoTranspType) bFound = TRUE; } } pNode = pNode->FindNextDepthFirst(pRootNode); } } break; default: ERROR2RAW("Unknown selection type in WarnIfIncompatible"); return FALSE; } if (!bFound) return TRUE; // We need to show the warning dialog... INT32 ret = InformWarning(_R(IDS_WARN_INCOMPATIBLETRANSPARENCY), _R(IDS_CONTINUE), _R(IDS_ALWAYSCONTINUE), _R(IDS_CANCEL)); if (ret==3) return FALSE; if (ret==2) bDontWarnBitmapNonMixTransp = TRUE; return TRUE; }

BOOL BaseBitmapFilter::WriteBitmapToFile (  KernelBitmap *  pKernelBitmap, double  Dpi )  [protected, virtual]

Physically put the bitmap into the disk. Inherited classes override this to write in different file formats. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/95 Parameters: Pointer  to the bitmap to be exported. [INPUTS] Returns: TRUE if worked, FALSE if errored. See also: WriteDataToFile(); AccusoftFilters::WriteToFile; AccusoftFilters::WriteDataToFile; Reimplemented in JPEGExportFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4146 of file bitfilt.cpp. { ERROR3("Base class bitmap filter WriteBitmapToFile called"); return FALSE; }

BOOL BaseBitmapFilter::WriteBitmapToFile (  KernelBitmap *  pKernelBitmap, BaseCamelotFilter *  pFilter, CCLexFile *  pFile, INT32  Compression )  [virtual]

Reimplemented in JPEGExportFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4174 of file bitfilt.cpp. { // Create a record of information about the export m_pExportOptions = CreateExportOptions(); if (GetBitmapExportOptions() == NULL) { return FALSE; } OutputFile = pFile; return TRUE; }

BOOL BaseBitmapFilter::WriteFileEnd (  void   )  [protected, virtual]

To write out the file specific data at the end of the file This base class version calls EndWriteToFile() so that derived classes do not have to implement the multi-image stuff. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4617 of file bitfilt.cpp. { return(EndWriteToFile()); }

BOOL BaseBitmapFilter::WriteFileHeader (  void   )  [protected, virtual]

To write out the file specific header data. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in JPEGExportFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4537 of file bitfilt.cpp. { return(TRUE); }

BOOL BaseBitmapFilter::WriteFrame (  void   )  [protected, virtual]

To write out the image itself This base class version actually calls the WriteToFile() function so that derived classes do not have to implement any of the multi-image stuff. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in JPEGExportFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4577 of file bitfilt.cpp. { return(WriteToFile(TRUE)); }

BOOL BaseBitmapFilter::WritePostFrame (  void   )  [protected, virtual]

To write out any frame specific info after the image. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in JPEGExportFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4596 of file bitfilt.cpp. { return(TRUE); }

BOOL BaseBitmapFilter::WritePostOptimisedPalette (  void   )  [protected, virtual]

Called after the optimised palette has been generated but before the export of the bitmap. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4657 of file bitfilt.cpp. { return(TRUE); }

BOOL BaseBitmapFilter::WritePreFrame (  void   )  [protected, virtual]

To write out any frame specific info before the image. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4556 of file bitfilt.cpp. { return(TRUE); }

BOOL BaseBitmapFilter::WritePreSecondPass (  void   )  [protected, virtual]

Called before the second pass of a two pass export so the filter can reset itself. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/96 Parameters: -  [INPUTS] Returns: FALSE if failed else TRUE See also: - Reimplemented in TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 4637 of file bitfilt.cpp. { return(TRUE); }

BOOL BaseBitmapFilter::WriteToFile (  BOOL  AtEnd  )  [protected, virtual]

Writes out the bitmap to a file. Inherited classes override this to write in different file formats. AtEnd is ignored now and should always be set to TRUE. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 22/8/94 Parameters: AtEnd  is TRUE if this is the last chunk of the file, FALSE if not. [INPUTS] Returns: TRUE if worked, FALSE if failed. Reimplemented in MakeBitmapFilter, BMPFilter, and MaskedFilter. Definition at line 4106 of file bitfilt.cpp. { ENSURE(FALSE, "Base class bitmap filter WriteToFile called"); return FALSE; }

---

Member Data Documentation

BOOL BaseBitmapFilter::BackgroundRedrawState [protected]

Definition at line 465 of file bitfilt.h.

BOOL BaseBitmapFilter::BackgroundRedrawStateSet [protected]

Definition at line 466 of file bitfilt.h.

BOOL BaseBitmapFilter::BadExportRender [protected]

Definition at line 430 of file bitfilt.h.

DocRect BaseBitmapFilter::ClipRect [protected]

Definition at line 476 of file bitfilt.h.

UINT32 BaseBitmapFilter::ExportingMsgID [protected]

Definition at line 450 of file bitfilt.h.

GRenderBitmap * BaseBitmapFilter::ExportRegion = NULL [static, protected]

Definition at line 462 of file bitfilt.h.

UINT32 BaseBitmapFilter::FilterInfoID [protected]

Definition at line 445 of file bitfilt.h.

UINT32 BaseBitmapFilter::FilterNameID [protected]

Definition at line 444 of file bitfilt.h.

CCLexFile* BaseBitmapFilter::InputFile [protected]

Definition at line 453 of file bitfilt.h.

BOOL BaseBitmapFilter::IsPreviewBitmap [protected]

Definition at line 319 of file bitfilt.h.

DPI BaseBitmapFilter::m_DefaultExportDPI = 96.0 [static, private]

Definition at line 514 of file bitfilt.h.

INT32 BaseBitmapFilter::m_nBitmapToRead [private]

Definition at line 508 of file bitfilt.h.

INT32 BaseBitmapFilter::m_NumberOfPaletteEntries = 0 [static]

Definition at line 300 of file bitfilt.h.

BitmapSource* BaseBitmapFilter::m_pBitmapSource [private]

Definition at line 510 of file bitfilt.h.

LPLOGPALETTE BaseBitmapFilter::m_pBrowserPalette = NULL [static, protected]

Definition at line 491 of file bitfilt.h.

BitmapExportOptions* BaseBitmapFilter::m_pExportOptions [private]

Definition at line 515 of file bitfilt.h.

BitmapImportOptions* BaseBitmapFilter::m_pImportOptions [protected]

Definition at line 328 of file bitfilt.h.

BMP_SIZE BaseBitmapFilter::m_PixelHeight [private]

Definition at line 518 of file bitfilt.h.

BMP_SIZE BaseBitmapFilter::m_PixelWidth [private]

Definition at line 517 of file bitfilt.h.

LPLOGPALETTE BaseBitmapFilter::m_pOptimisedPalette2 [protected]

Definition at line 490 of file bitfilt.h.

Progress* BaseBitmapFilter::m_pProgress [private]

Definition at line 506 of file bitfilt.h.

UINT32 BaseBitmapFilter::m_ProgressBarCount [private]

Definition at line 504 of file bitfilt.h.

String_64 BaseBitmapFilter::m_ProgressBarMessage [private]

Definition at line 507 of file bitfilt.h.

BMP_DEPTH BaseBitmapFilter::m_RenderDepth [private]

Definition at line 519 of file bitfilt.h.

UINT32 BaseBitmapFilter::m_TotalProgressBarCount [private]

Definition at line 505 of file bitfilt.h.

const INT32 BaseBitmapFilter::MinExportSize = 10 [static]

Definition at line 296 of file bitfilt.h.

const INT32 BaseBitmapFilter::MinPelsPerMeter = 1000 [static]

Definition at line 294 of file bitfilt.h.

UINT32 BaseBitmapFilter::OurNumNodes = 0 [static, protected]

Definition at line 431 of file bitfilt.h.

CCLexFile * BaseBitmapFilter::OutputFile = NULL [static, protected]

Definition at line 456 of file bitfilt.h.

UINT32 BaseBitmapFilter::PaletteType [protected]

Definition at line 481 of file bitfilt.h.

KernelBitmap * BaseBitmapFilter::pExportBitmap = NULL [static, protected]

Definition at line 473 of file bitfilt.h.

KernelBitmap* BaseBitmapFilter::pNewBitmap [protected]

Definition at line 459 of file bitfilt.h.

LPLOGPALETTE BaseBitmapFilter::pOptimisedPalette = NULL [static, protected]

Definition at line 487 of file bitfilt.h.

UINT32 BaseBitmapFilter::PreviewDither [protected]

Definition at line 483 of file bitfilt.h.

UINT32 BaseBitmapFilter::PreviewPalette [protected]

Definition at line 484 of file bitfilt.h.

Spread* BaseBitmapFilter::pSpread [protected]

Definition at line 479 of file bitfilt.h.

BOOL BaseBitmapFilter::RenderBottomToTop [protected]

Definition at line 429 of file bitfilt.h.

BOOL BaseBitmapFilter::RenderInStrips [protected]

Definition at line 428 of file bitfilt.h.

BOOL BaseBitmapFilter::s_fWarnedZoomOnImport = 9999 [static, protected]

Definition at line 500 of file bitfilt.h.

BOOL BaseBitmapFilter::s_fZoomOnImport = 9999 [static, protected]

Definition at line 499 of file bitfilt.h.

UINT32 BaseBitmapFilter::SizeOfExport = 100 [static, protected]

Definition at line 434 of file bitfilt.h.

Quality BaseBitmapFilter::ViewQuality [protected]

Definition at line 469 of file bitfilt.h.

BOOL BaseBitmapFilter::ViewQualitySet [protected]

Definition at line 470 of file bitfilt.h.

BOOL BaseBitmapFilter::WeAreGeneratingOptPalette = FALSE [static, protected]

Definition at line 488 of file bitfilt.h.

BOOL BaseBitmapFilter::WrittenHeader = FALSE [static, protected]

Definition at line 427 of file bitfilt.h.

---

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

• Kernel/bitfilt.h (r1785/r1771)
• Kernel/bitfilt.cpp (r1785/r1762)

---