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);