Filter Class Reference

Pure base class for import and export filters. Provides static functions to initialise and deinitialise all the available filters. More...

#include <filters.h>

Inheritance diagram for Filter:

List of all members.

Public Member Functions
	Filter ()
	Set the Filter object up to be in a clean state.
virtual	~Filter ()
	Destroys the OILFilter object and the current attribute array/values associated with this Filter.
virtual BOOL	Init ()=0
	Declares a preference that allows you to clear memory in delete().
virtual void	Deinit ()
FilterFlags	GetFlags ()
	Get the flags for a specified filter.
ADDR	LoadInitialSegment (PathName &Path, UINT32 *Size, size_t *FileSize)
ADDR	LoadInitialSegment (CCLexFile *pFile, UINT32 *pSize, size_t *pFileSize)
	Determine if this filter can load the specified file. The filter is provided with the first n bytes of the file, where n is HeaderSize. It should look at this data and/or the pathname to determine if it can load this file. NB. Base class function is pure virtual - override it!Loads in the first n bytes of a file, in order to investigate whether a filter (or number of filters in the case of the FilterFamily class), is compatible with the file - i.e. how well this file recognises the file header. The last byte in the block is set to 0, to prevent ASCII lexers from going trundling off the end.
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 BOOL	PreHowCompatible ()
	Allows a filter or set of filters to take some action or set up variables before being called by HowCompatible. A group of filters which share common code may require some variable set up before being asked to check the type. Base class does nothing and so works for all filters which do not require it.
virtual INT32	HowCompatible (PathName &Filename, ADDR HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
virtual BOOL	DoImport (SelOperation *, CCLexFile *, Document *, BOOL AutoChosen=FALSE, ImportPosition *Pos=NULL, KernelBitmap **ppImportedBitmap=NULL, DocCoord *pPosTranslate=NULL, String_256 *URL=NULL)
virtual BOOL	DoExport (Operation *, CCLexFile *, PathName *, Document *, BOOL=TRUE)
virtual BOOL	JoinFamily (CCRuntimeClass *)
	Allow a filter to choose whether or not it wants to become part of a filter 'family', e.g. a filter family such as "EPS files", or "Bitmap files". The default implementation checks to see if the filter is of the same kind of filter, using IsKindOf(), and if so, it consents to be in the filter family. Filters should only over-ride this if they need different behaviour for some bizarre reason.
virtual BOOL	ImportBitmap (CCLexFile *, KernelBitmap **)
virtual BOOL	ExportBitmap (KernelBitmap &)
	Virtual function to export a bitmap to a file. This base class version always does nothing and returns TRUE, so formats which do not support bitmaps need do nothing. Formats that support bitmaps should over-ride this function to do the necessary work required to embed the bitmap into the file.
Document *	GetDocument ()
AttributeEntry *	GetCurrentAttrs ()
virtual INT32	ImportBinary (ADDR pData, INT32 Length)
	Read in binary data from the file and place it in the buffer supplied by the caller. This is over-ridden by filters to do whatever translation is necessary, e.g. EPS filters convert ASCII Hexadecimal data to binary.
virtual BitmapFilterSupport	GetBitmapSupportLevel ()
	Determine how well this filter supports bitmaps when exporting.
virtual BOOL	CanIncludePreviewBmp ()
	Allows you to find out if a particular filter can produce a Preview Bitmap in it.
void	IncludePreviewBmp (BOOL WantBmp)
	Asks the filter to include a Preview bitmap or not. NOTE: This only has any effect if the Filter answered TRUE to a call to CanIncludePreviewBmp. NOTE2: All the filters hang around even if they are not doing any filtering, so if you set this flag one way it will stay like that for all future uses of the filter until it is set again. The best method will be to swtich it on if required, do the import and then switch it off again immediatly afterwards.
virtual BOOL	ExportVisibleLayersOnly ()
	Determines if the filter wants to export only visible layers. NB. This base class version does the default action of making the filter export everything including hidden layers.
virtual BOOL	ExportSelectionOnly (BOOL MaskedRender=FALSE)
	Determines if the filter wants to export only selected items. In the filters baseclass version the default action will be to export all objects by default Only used by bitmap export and in particular masked gif rendering at present.
virtual BOOL	WillAcceptExistingFile (PathName pthToReplace)
	Checks to see if this filter will accept an existing file to export to.
virtual void	SetSaveAttributes (BOOL DoSave)
	Informs the filter whether or not it should record the attribute settings along with the file data. This allows templates to have default colours other than the standard Camelot values, whilst not encumbering save files with this extra information.
void	SetSoleLayer (Layer *pLayer)
Layer *	GetSoleLayer ()
virtual BOOL	OpenExportFile (CCDiskFile *pDiskFile, PathName *pPath)
	Opens up the file ready for exporting into. Assumes the file has already been constructed with the correct buffers etc..
virtual BOOL	DeleteExportFile (CCDiskFile *pDiskFile)
	Used for when either an export has been aborted by the user half way through or when an error has occured. It closes up the export file, if open, and then deletes it.
virtual BOOL	ExportRender (RenderRegion *pRegion, BOOL MaskedRender=FALSE)
	Export a file to a given render region. It is the responsibility of the derived filter to create a render region of the correct type, and then pass it to this function.
virtual BOOL	ExportRenderNodes (RenderRegion *pRegion, ExportDC *pDC, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE, BOOL ShowProgress=TRUE)
	Sets up the file to do an export of the nodes in the tree, by initialising the file, and any slow-job code. It then calls the WriteNodes method to do the actual work, and EndExportRender to complete the task.
virtual String_64	GetImportProgressString (CCLexFile *File, UINT32 ImportingMsgID)
	Works out what progress bar string to use during importing of the file. This consists of a basic message plus, if it will fit, a truncated form of the filename being imported.
virtual String_64	GetExportProgressString (CCLexFile *File, UINT32 ExportingMsgID)
	Works out what progress bar string to use during exporting of the file. This consists of a basic message plus, if it will fit, a truncated form of the filename being exported.
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 UINT32	GetImportMsgID ()
	Used to get the message id to be used during export. Virtual, so that multi-stage importers can change the message.
virtual BOOL	AddStringToProgressString (String_64 *Str)
virtual BOOL	ShouldExportHTMLTag ()
virtual void	ExportHTMLTag ()
virtual BOOL	IncProgressBarCount (UINT32 n)
BOOL	UpdateExportedNodeCount (UINT32 NumNodes=1)
	Update the progress display according to the number passed in. The NumNodes parameter indicates how many nodes have just been saved. Most nodes won't call this when exporting as they are only '1' node. Nodes such as blenders or bitmaps may call this to update the progress more smoothly. E.g. a bitmap might say that it is 20 nodes if it has 20 scanlines. It could then call this function after each scanline is saved with the value 1. It should not call it with more than the number of nodes it claims to be, e.g. the example bitmap above should only ever call with NumNodes in the range 1 to 20. And the cumulative total of NumNodesSaved passed in by one node should never be more than the number of nodes it claims to be either.
UINT32	GetNumNodes ()
	Allows access to the stored numbers of nodes which is currently set up to be used for a progress bar.
UINT32	SetNumNodes (UINT32 NewNumNodes)
	Allows setting of the stored numbers of nodes which is currently set up to be used for a progress bar.
Static Public Member Functions
static void	ForceStatusExportMessage (UINT32 nMessageID)
	Overrides the status-line message shown when a file is exported. This is used by the clipboard code to change "Saving document..." to "Copying to clipboard...".
static void	UnforceStatusExportMessage ()
	Resets the message override on export back to "no override".
static GenericFilter *	GetGenericFilter ()
static Filter *	FindFilterFromID (const UINT32 FilterID)
	Provides the Filter given its ID.
static BOOL	InitFilters ()
	Scans all filters to find out which filters are available for use, and instantiates one of each, and holds them in a list.
static BOOL	DeinitFilters ()
	Destroy all the Filter objects.
static Filter *	GetFirst ()
	Iterating through the list of filters known to Camelot. This function returns the first filter.
static Filter *	GetNext (Filter *)
	Iterating through the list of filters known to Camelot. This function returns the next filter.
static List &	GetFilters ()
static ID	GetNewFilterID ()
	Support function providing an unique ID for each newly registered Filter.
static ID	RegisterFilter (Filter *const pFilter)
	Permits the filter to be used by the FilterManager. For an import filter to be present on the Import dialog the filter should associate itself with the requisite FileFormats via AssociateFilterWithFormat().
Public Attributes
String_256	FilterName
String_256	FilterInfo
UINT32	FilterID
OILFilter *	pOILFilter
Static Public Attributes
static BOOL	AddUnnamedColours = FALSE
	If it is TRUE then any colours used in the imported file but not explicitly named by whatever colour table structure the file uses will be created as named colours (usu. of the form Unnamed 1, Unnamed 2 and so on). If FALSE, immediate colours will be used, and will not appear on the document's colour bar. Defaults to FALSE.
static INT32	ImportWithLayers = 2
	Controls how files are imported: TRUE => Layers are imported/created as necessary when importing. FALSE => Layers are ignore when importing, and the whole imported file is placed in the document as a group.
static BOOL	OpenWithLayers = TRUE
	Controls how files are opened: TRUE => Layers are imported/created as necessary when opening a file. FALSE => Layers are ignore when importing, and the whole opened file is placed in the document as a group. Note: Does not affect v2 Native file formats such as xar and web.
static BOOL	ImportBitmapsOntoLayers = TRUE
	Controls how bitmap files are opened/imported: TRUE => each bitmap is placed on a new layer. FALSE => each bitmaps is placed on the current layer. Applies to multiple format bitmaps such as animated GIFs.
static BOOL	bDontWarnBitmapNonMixTransp = FALSE
	Controls how bitmap files are opened/imported: TRUE => each bitmap is placed on a new layer. FALSE => each bitmaps is placed on the current layer. Applies to multiple format bitmaps such as animated GIFs.
Protected Member Functions
Layer *	GetActiveLayer (Document *)
	Find the active layer of the first spread of the specified document.
BOOL	MakeSureLayerExists (Document *pDoc)
	This functions checks that there is a layer to put nodes onto during an import, and will create a new layer if there are none. This means that filters can call this function just before they try and insert a new node into the tree and be sure that there will be a layer for it to go onto. The function will return TRUE if there is a layer in the document (even if this function had to create the layer). It will return FALSE only if there are no layers and it was unable to create any new ones.
virtual BOOL	WriteNodes (RenderRegion *pRegion, ExportDC *pDC, BOOL VisibleLayersOnly, BOOL CheckSelected, BOOL ShowProgress)
	Actually export the nodes to the given render region showing a progress bar as we go. Assumes everything has been set up by ExportRender. Assumes that either a progress bar has been started and will be ended by the caller or that it should start and end the progress bar itself.
virtual BOOL	EndExportRender (RenderRegion *pRegion, BOOL ShowProgress)
	Shuts down the export render process.
BOOL	SetUpCurrentAttrs ()
	Obtains an attribute array from the attribute manager. This array is the set of default attributes - the filter should use them to maintain its set of current attributes while importing. It then asks the attribute manager to add the correct attributes to each node based on this array. This should be called when importing, not when intialising, otherwise all filters will have this array hanging around all the time, which is bad.
void	DeleteCurrentAttrs ()
	Deallocates any objects used to hold the current attributes for the filter. Should be called after import has finished, so the attribute table isn't hanging around all the time.
BOOL	SetLineColour (DocColour &)
	Updates the current attribute for line colour to reflect the value passed in.
BOOL	SetLineWidth (MILLIPOINT)
	Updates the current attribute for line width to reflect the value passed in.
BOOL	SetLineCap (LineCapType)
	Updates the current attribute for line cap style to reflect the value passed in.
BOOL	SetJoinType (JointType)
	Updates the current attribute for line join style to reflect the value passed in.
BOOL	SetLineTransp (UINT32 TranspType, UINT32 Transp)
	Updates the current attribute for line transparency to reflect the value passed in.
BOOL	SetDashPattern (DashRec &)
	Updates the current attribute for dash pattern to reflect the value passed in.
BOOL	SetStartArrow (ArrowRec &)
	Updates the current attribute for Start Arrow to reflect the value passed in.
BOOL	SetEndArrow (ArrowRec &)
	Updates the current attribute for End Arrow to reflect the value passed in.
BOOL	SetMitreLimit (MILLIPOINT)
	Updates the current attribute for the Mitre Limit to reflect the value passed in.
BOOL	SetTextFont (String_64 *EncodedName, INT32 Millipoint)
	Set the font specified in the encoded font name. The font which actually gets set in the attribute stack is one found by GetCompatibleFont(), a super new fontmanager call.
BOOL	SetTextFontStyle (String_64 *FName, INT32 MillFSize, BOOL Bold, BOOL Italic)
	This function creates attributes for the typeface, the pointsize, bold and italic all at once.
BOOL	SetTextSize (INT32 Size)
	Updates the current attribute for TextSize to reflect the value passed in.
BOOL	SetTextTypeFace (String_64 *Name, FontClass Class=FC_UNDEFINED)
	Updates the current attribute for TextSize to reflect the value passed in.
BOOL	SetTextBold (BOOL Bold)
	Updates the current attribute for Bold to reflect the value passed in.
BOOL	SetTextItalic (BOOL Italic)
	Updates the current attribute for Italic to reflect the value passed in.
BOOL	SetTextUnderline (BOOL Underline)
	Updates the current attribute for Underline to reflect the value passed in.
BOOL	SetTextAspectRatio (FIXED16 AspectR)
	Updates the current attribute for AspectRatio to reflect the value passed in.
BOOL	SetTextTracking (INT32 Tracking)
	Updates the current attribute for TextSize to reflect the value passed in.
BOOL	SetTextJustification (Justification Justify)
	Updates the current attribute for TextSize to reflect the value passed in.
virtual BOOL	SetTextLineSpacing (INT32 Type, INT32 EMLSpace, MILLIPOINT MLSpace, double DLSpace)
	Updates the current attribute for line spacing to reflect the value passed in. One of three values will be used depending on the type (as above).
BOOL	SetTextBaseLine (MILLIPOINT BaseLine)
	Updates the current attribute for BaseLine shift to reflect the value passed in.
BOOL	SetTextScript (INT32 rise, INT32 pointsize)
	Updates the current attribute for subscript or superscript.
BOOL	SetTextBoldFont (BOOL Bold)
	This function simply sets the bold style flag in the current font typeface attribute (to be applied to the next created character).
BOOL	SetTextItalicFont (BOOL Italic)
	This function simply sets the italic style flag in the current font typeface attribute (to be applied to the next created character).
BOOL	RemoveTextScript ()
	Removes any script attribute which is currently active.
BOOL	SetPathFilled (BOOL Filled)
	Indicate whether paths should be filled or not. This is independent of the current fill attribute, so, for example, if this function is called to set the paths to be unfilled, and then called again to set them to be filled, then afterwards all paths filled will be filled with whatever fill attribute was last set.
BOOL	SetFillColour (DocColour &)
	Updates the current attribute for fill colour to reflect the value passed in.
BOOL	SetLinearFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint, DocCoord *EndPoint3=NULL)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetRadialFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetRadialFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint1, DocCoord EndPoint2)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetSquareFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint1, DocCoord EndPoint2)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetConicalFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetBitmapFill (KernelBitmap *pBitmap, DocCoord StartPoint, DocCoord EndPoint, DocCoord EndPoint2, DocColour *StartColour=0, DocColour *EndColour=0)
	Updates the current attribute for fill colour to reflect the value passed in.
BOOL	SetFractalFill (DocColour &StartColour, DocColour &EndColour, DocCoord StartPoint, DocCoord EndPoint1, DocCoord EndPoint2, INT32 Seed, double Graininess, double Gravity, double Squash, UINT32 DPI, BOOL Tileable)
	Updates the current attribute for colour fill geometry to be a fractal fill using the values passed in.
BOOL	SetNoTranspFill ()
	Set the current transparency fill for this import operation to be none, i.e. there is no transparency.
BOOL	SetFlatTranspFill (UINT32 TranspType, UINT32 Transp)
	Set the current transparency fill for this import operation to be a flat transparency value.
BOOL	SetLinearTranspFill (UINT32 TranspType, UINT32 StartTransp, UINT32 EndTransp, DocCoord StartPoint, DocCoord EndPoint, DocCoord *EndPoint3=NULL)
	Updates the current attribute for transparency fill to be a linear transparent fill as specified by the values passed in.
BOOL	SetRadialTranspFill (UINT32 TranspType, UINT32 StartTransp, UINT32 EndTransp, DocCoord StartPoint, DocCoord EndPoint)
	Updates the current attribute for transparency fill to be a circular transparent fill as specified by the values passed in.
BOOL	SetRadialTranspFill (UINT32 TranspType, UINT32 StartTransp, UINT32 EndTransp, DocCoord StartPoint, DocCoord EndPoint1, DocCoord EndPoint2)
	Updates the current attribute for transparency fill to be an elliptical transparent fill as specified by the values passed in.
BOOL	SetConicalTranspFill (UINT32 TranspType, UINT32 StartTransp, UINT32 EndTransp, DocCoord StartPoint, DocCoord EndPoint)
	Updates the current attribute for gradfill colour to reflect the value passed in.
BOOL	SetBitmapTranspFill (UINT32 TranspType, KernelBitmap *pBitmap, DocCoord StartPoint, DocCoord EndPoint, DocCoord EndPoint2, UINT32 StartTransp=0, UINT32 EndTransp=255)
	Updates the current attribute for fill colour to reflect the value passed in.
BOOL	SetFractalTranspFill (UINT32 TranspType, DocCoord StartPoint, DocCoord EndPoint1, DocCoord EndPoint2, INT32 Seed, double Graininess, double Gravity, double Squash, UINT32 DPI, BOOL Tileable, UINT32 StartTransp=0, UINT32 EndTransp=255)
	Updates the current attribute for colour fill geometry to be a fractal fill using the values passed in.
BOOL	SetFadeFillEffect ()
BOOL	SetRainbowFillEffect ()
BOOL	SetAltRainbowFillEffect ()
BOOL	SetLinearFillMapping (INT32 Repeat)
BOOL	SetLinearTranspFillMapping (INT32 Repeat)
BOOL	SetWindingRule (WindingType)
	Updates the current attribute for winding rule to reflect the value passed in.
virtual BOOL	GetDragAndDropTranslation (ImportPosition *pPos, DocRect BoundsRect, Coord *Offset)
	Given an drag'n'drop point (in pPos), calculate the translation necessary to position the imported objects at this position on the spread. It ensures that bounding rectangles smaller than the spread are wholly contained within the spread. i.e. if you drag a file right to the edge of a spread, the translation will move it closer to the centre of the spread so that it is wholly contained within the spread.
BOOL	SnapShotCurrentAttrs ()
	This function grabs a snap shot of the filter managers current attributes. It simply makes a new List identical to that of CurrentAttrs.
void	PushCurrentAttrsBasedOnSnapShot ()
	This function uses the snap shot facility. It checks the snap shot list against the current attribute list to find attributes which differ. Those that do are obviously new attributes. ie attributes which have been parsed by the filter after the snap shot was taken. This function takes the current attrubute list and removes all those attributes which have changed in this way. It resets them to their default none temp attribute types.
void	PopCurrentAttrsBasedOnSnapShot ()
	This function uses the snap shot facility. It checks the snap shot list against the current attribute list to find attributes which differ. Those that do are obviously new attributes. ie attributes which have been parsed by the filter after the snap shot was taken. This function takes the current attrubute list and removes all those attributes which have changed in this way. It resets them to their default none temp attribute types.
void	DeleteSnapShot ()
	This function removes the snap shot list allocated during SnapShotCurrentAttrs(). It should be called to match any successfull return of its sister function. ie SnapShotCurrentAttrs() and DeleteSnapShot() should be paired. Note, the calls are not recursive. ie a SnapShot SnapShot Delete Delete is not currently supported.
void	DeleteAttributeList (AttributeEntry *pAttrList)
	This function removes all temp attributes from the attribute list provided All temp attributes will have their list entries updated with NULL pointers.
BOOL	ApplyChangedAttrs (Node *pNode)
	This function uses the snapshot facility to work out which of the current attributes have changed. Obviously it expects a snap shot to have been taken some time earlier. Only those attributes that have changes will be applied to the node described on entry. Note, any changed attributes which now match defaults will not be applied as the function calls ApplyBasedOnDefaults() with the changes list.
virtual void	UpdateFilterProgress (UINT32 increment)
	Shuts down the export render process.
Static Protected Member Functions
static BOOL	DeclareFilterPreferenceSection ()
	Ensures all filter related preferences go to the same section.
static Spread *	GetFirstSpread (Document *)
	Find the first spread of the specified document.
Protected Attributes
BOOL	WantPreviewBmp
FilterFlags	Flags
Document *	TheDocument
UINT32	ExportMsgID
UINT32	StopExportMsgID
UINT32	ImportMsgID
BOOL	SaveAttributes
Layer *	m_pSoleLayer
String_64	m_StrToAddToProgress
AttributeEntry *	CurrentAttrs
SnapShotList	FilterSnapShot
AttributeEntry	FillAttr
BOOL	PathFilled
Static Protected Attributes
static UINT32	m_nForcedStatusExportMessage = 0
static INT32	MinLineWidth = 250
	Controls how line widths are handled - if a line width thinner than the value of this preference is found, then the line width is forced to be this width. E.g. set it to 500 to make all imported lines be at least 0.5 points wide. (It defaults to 0.25pt).
static UINT32	NumNodes = 0
static UINT32	UpdateEvery = 1
static UINT32	LastExportProgressUpdate = 0
static UINT32	CurrentProgressLimit = 0
static UINT32	ProgressOffset = 0
static UINT32	m__StripStart = 0
Static Private Attributes
static GenericFilter *	pGenericFilter = NULL
static List	FilterList
static ID	m_NextFilterID = 1099 + 1
Friends
class	FilterRenderCallback

---

Detailed Description

Pure base class for import and export filters. Provides static functions to initialise and deinitialise all the available filters.

Author:

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

Date:

08/03/94

See also:

OILFilter

Definition at line 447 of file filters.h.

---

Constructor & Destructor Documentation

Filter::Filter (   )

Set the Filter object up to be in a clean state. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 See also: Filter; Filter::~Filter; OILFilter Definition at line 372 of file filters.cpp. { // Ensure destructor will not corrupt heap pOILFilter = NULL; CurrentAttrs = NULL; FillAttr.pAttr = NULL; FillAttr.Temp = FALSE; FillAttr.Ignore = FALSE; // Set default of no export message ExportMsgID = 0; // Set default message of none (use default message) StopExportMsgID = 0; // Set default of no import message ImportMsgID = 0; // No document yet... TheDocument = NULL; // No Preview Bitmap Please WantPreviewBmp = FALSE; // Ensure these are at known states, set them to do nothing so people have to change them Flags.CanImport = FALSE; Flags.CanExport = FALSE; Flags.CanExportMultipleImages = FALSE; // Want to show filters by default, unless the user specificaly requests otherwise Flags.ShowFilter = TRUE; // set the path filled flag to a sensible state PathFilled = TRUE; // Don't save attributes as default. SaveAttributes = FALSE; m_pSoleLayer = NULL; }

Filter::~Filter (   )  [virtual]

Destroys the OILFilter object and the current attribute array/values associated with this Filter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 See also: Filter; OILFilter Definition at line 425 of file filters.cpp. { // Destroy the associated OILFilter object delete pOILFilter; // Destory any temporary saved fill attribute if (FillAttr.Temp) delete FillAttr.pAttr; }

---

Member Function Documentation

BOOL Filter::AddStringToProgressString (  String_64 *  Str  )  [virtual]

Author: Olivier_Gascoin (Xara Group Ltd) <camelotdev@xara.com> Date: 21/04/97 Parameters: Str  - This is the string to add in the ProgressString [INPUTS] -  [OUTPUTS] Returns: TRUE See also: Definition at line 1696 of file filters.cpp. { m_StrToAddToProgress = *Str; return TRUE; }

BOOL Filter::ApplyChangedAttrs (  Node *  pNode  )  [protected]

This function uses the snapshot facility to work out which of the current attributes have changed. Obviously it expects a snap shot to have been taken some time earlier. Only those attributes that have changes will be applied to the node described on entry. Note, any changed attributes which now match defaults will not be applied as the function calls ApplyBasedOnDefaults() with the changes list. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: -  [INPUTS] Returns: TRUE if the changed attributes have been applied to pNode FALSE if nothing has been applied Definition at line 657 of file filters.cpp. { return FilterSnapShot.ApplyChangedAttrs(pNode,CurrentAttrs); }

BOOL Filter::CanIncludePreviewBmp (   )  [virtual]

Allows you to find out if a particular filter can produce a Preview Bitmap in it. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Returns: TRUE if the filter is capable of having a preview bitmap put in it somehow. FALSE if it can't. Most filters can not do this. Reimplemented in CamelotEPSFilter. Definition at line 466 of file filters.cpp. { // Say no. Filters that can will have to say yes return FALSE; }

BOOL Filter::DeclareFilterPreferenceSection (   )  [static, protected]

Ensures all filter related preferences go to the same section. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 30/10/96 Returns: TRUE if the preference section was declared correctly FALSE otherwise Definition at line 447 of file filters.cpp. { return( Camelot.DeclareSection( _T("Filters"), 10 ) ); }

virtual void Filter::Deinit (  void   )  [inline, virtual]

Reimplemented in BaseCamelotFilter. Definition at line 458 of file filters.h. { if (pOILFilter) { delete pOILFilter; pOILFilter = NULL; } };

BOOL Filter::DeinitFilters (   )  [static]

Destroy all the Filter objects. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 See also: Filter Definition at line 1028 of file filters.cpp. { ListItem* pListItem = FilterList.GetHead(); while (pListItem != NULL) { ((Filter*)pListItem)->Deinit(); pListItem = FilterList.GetNext(pListItem); } // Get rid of our filters FilterList.DeleteAll(); // All ok return TRUE; }

void Filter::DeleteAttributeList (  AttributeEntry *  pAttrList  )  [protected]

This function removes all temp attributes from the attribute list provided All temp attributes will have their list entries updated with NULL pointers. void Filter::DeleteAttributeList(AttributeEntry* pAttrList) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: pAttrList  = A pointer to the first item in the attribute list [INPUTS] Returns: - Definition at line 575 of file filters.cpp. { // Delete any attribute values we created INT32 NumAttrs = AttributeManager::GetNumAttributes(); for (INT32 i=0; i<NumAttrs; i++) { // Delete the object if it is temporary. if (pAttrList[i].Temp) { delete pAttrList[i].pAttr; pAttrList[i].pAttr = NULL; pAttrList[i].Temp = FALSE; } } }

void Filter::DeleteCurrentAttrs (   )  [protected]

Deallocates any objects used to hold the current attributes for the filter. Should be called after import has finished, so the attribute table isn't hanging around all the time. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 See also: Filter::SetUpCurrentAttrs Definition at line 550 of file filters.cpp. { // Delete any attribute values we created if (CurrentAttrs != NULL) { DeleteAttributeList(CurrentAttrs); // Lose the attribute value array CCFree(CurrentAttrs); CurrentAttrs = NULL; } }

BOOL Filter::DeleteExportFile (  CCDiskFile *  pDiskFile  )  [virtual]

Used for when either an export has been aborted by the user half way through or when an error has occured. It closes up the export file, if open, and then deletes it. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/95 Parameters: pDiskFile  The constructed disk file to use [INPUTS] Returns: True if the file has been closed and deleted correctly, False otherwise. See also: OpMenuExport::DoWithParam; Filters::DoExport; ClipboardMapping::ExportToTempFile; OpMenuSave::SaveSpecificFile; Definition at line 1864 of file filters.cpp. { #ifdef DO_EXPORT ERROR2IF(pDiskFile == NULL, FALSE,"Filter::CloseExportFile null file supplied"); // Remove the zero length file that we created as part of the process. // First, ensure file is closed if (pDiskFile->isOpen()) pDiskFile->close(); // Get its pathname PathName Path = pDiskFile->GetPathName(); // And try and remove it, only if it exists if (Path.IsValid()) { BOOL Exists = TRUE; BOOL status = TRUE; Exists = SGLibOil::FileExists(&Path); if (Exists) status = SGLibOil::FileDelete(&Path); TRACEUSER( "Neville", _T("Filter::DeleteExportFile removed exists status =%d, file status =%d/n"),Exists,status); } #endif return TRUE; }

void Filter::DeleteSnapShot (   )  [protected]

This function removes the snap shot list allocated during SnapShotCurrentAttrs(). It should be called to match any successfull return of its sister function. ie SnapShotCurrentAttrs() and DeleteSnapShot() should be paired. Note, the calls are not recursive. ie a SnapShot SnapShot Delete Delete is not currently supported. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: -  [INPUTS] Returns: - See also: SnapShotCurrentAttrs() Definition at line 633 of file filters.cpp. { FilterSnapShot.DestroySnapShot(); }

virtual BOOL Filter::DoExport (  Operation *  , CCLexFile *  , PathName *  , Document *  , BOOL  = TRUE )  [inline, virtual]

Reimplemented in BaseBitmapFilter, BaseCamelotFilter, CDRFilter, CMXFilter, CMXImportFilter, PaletteFilter, AcornDrawFilter, EPSFilter, FilterFamily, ImagemapFilter, PreviewFilter, PreviewFilterBMP, PreviewFilterGIF, PreviewFilterJPEG, PreviewFilterPNG, ThumbnailFilterPNG, FlashFilter, PluginNativeFilter, and MetaFileFilter. Definition at line 520 of file filters.h. { return FALSE; }

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

Reimplemented in BaseBitmapFilter, BaseCamelotFilter, CDRFilter, CMXFilter, CMXImportFilter, PaletteFilter, AcornDrawFilter, EPSFilter, FilterFamily, PreviewFilter, FlashFilter, PluginNativeFilter, and MetaFileFilter. Definition at line 510 of file filters.h. { return FALSE; }

BOOL Filter::EndExportRender (  RenderRegion *  pRegion, BOOL  ShowProgress )  [protected, virtual]

Shuts down the export render process. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> (from Neville's original code) Date: 12/4/00 Parameters: pRegion  - the render region to export to. [INPUTS] 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: Filter::ExportRender, Filter::ExportRenderNodes Definition at line 2369 of file filters.cpp. { #ifdef DO_EXPORT //TRY { // Finished rendering - deinit render region. pRegion->StopRender (); // Shut down the render region. pRegion->CloseDown (); } #if 0 CATCH ( CFileException, e ) { // Didn't work - report failure to caller. if ( ShowProgress ) EndSlowJob (); return FALSE; } END_CATCH #endif // Close down progress display, if present if ( ShowProgress ) EndSlowJob (); // All OK return TRUE; #else return FALSE; #endif }

BOOL Filter::ExportBitmap (  KernelBitmap &   )  [virtual]

Virtual function to export a bitmap to a file. This base class version always does nothing and returns TRUE, so formats which do not support bitmaps need do nothing. Formats that support bitmaps should over-ride this function to do the necessary work required to embed the bitmap into the file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 01/09/94 Parameters: TheBitmap  - the bitmap to export [INPUTS] Returns: TRUE if the bitmap was exported ok (or if it wasn't exported because the file format does not support it; FALSE if an error occured. Errors: Usual disk/file errors. See also: CamelotEPSFilter::ExportBitmap Reimplemented in CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 2579 of file filters.cpp. { // Base class - ignore bitmaps return TRUE; }

virtual void Filter::ExportHTMLTag (   )  [inline, virtual]

Reimplemented in CamelotNULLWebFilter. Definition at line 638 of file filters.h. { }

BOOL Filter::ExportRender (  RenderRegion *  pRegion, BOOL  MaskedRender = FALSE )  [virtual]

Export a file to a given render region. It is the responsibility of the derived filter to create a render region of the correct type, and then pass it to this function. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: pRegion  - the render region to export to. [INPUTS] Returns: TRUE if the export process completed successfully, FALSE if an error occured. Errors: Render region is not connected to a spread. See also: EPSRenderRegion::ExportRender, FlashRenderRegion::ExportRender Definition at line 1908 of file filters.cpp. { #ifdef DO_EXPORT // Disable bitmap caching but remember the old state so we can set it back ScopedFlagSetter fsBitmapCacheing(NodeRenderableBounded::bEnableCacheing, FALSE); ERROR2IF(pRegion==NULL,FALSE,"Filter::ExportRender null render region supplied"); // We need special handling for Camelot EPS // (NB. but not native files - do not change this to IS_KIND_OF!) BOOL IsCamelotEPS = IS_A(pRegion, CamelotEPSRenderRegion); // Get the DC for this export operation // This can be NULL, in the case of bitmap export, or a CMetaFileDC in the case // of MetaFile export. In the later case we MUST NOT set up the ExportDC pointer // pDC otherwise the CATCH handlers will fail as there is no ExportFile. Also the // progress bar message will fail. // The CDC can be Null if we are talking about bitmap export CNativeDC* pCDC = pRegion->GetRenderDC(); ExportDC* pDC = NULL; NumNodes = 0; // At present, it appears that only EPS derived filters have a file attached and so // are the only ones which use an ExportDC. All bitmap filters use NULL. if( pCDC != NULL && this->IS_KIND_OF(EPSFilter)) pDC = (ExportDC*)CCDC::ConvertFromNativeDC(pCDC); // Find out how big the document and document components are... // (We only do this for EPS files) if( this->IS_KIND_OF(EPSFilter) && !IsCamelotEPS) { // First, we ask the document itself Document *pDocument = GetDocument(); NumNodes += pDocument->GetSizeOfExport(this); // Next, the document components... DocComponent *pComponent = pDocument->EnumerateDocComponents(NULL); while (pComponent != NULL) { // Ask this document component how much data it will export. NumNodes += pComponent->GetSizeOfExport(this); // Look for next doc component pComponent = pDocument->EnumerateDocComponents(pComponent); } } // Remember how big this initial header is, so we don't overflow when writing // out and screw up the progress indication (which could happen if, e.g. the // bitmap export code was incorrect). CurrentProgressLimit = NumNodes; // Find the first node that we should export from this spread Node *pNode = pRegion->GetRenderSpread(); ENSURE(pNode != NULL, "Render Region has no spread in Filter::ExportRender!"); ERRORIF(pNode == NULL, _R(IDT_EXPORT_INTERNAL_ERR), FALSE); // Go and find the bounding rect for this spread and set the render regions // clipping rect to it if (pNode->IsSpread()) { // find out the old clip rect DocRect OldClipRect = pRegion->GetClipRect(); // only do something if it is empty if (OldClipRect.IsEmpty()) { // Get a pointer to the spread and find out its bounding rect Spread* pSpread = (Spread*) pNode; DocRect SpreadRect = pSpread->GetBoundingRect(); pSpread->DocCoordToSpreadCoord(&SpreadRect); // and set the render regions clipping rect to this pRegion->SetClipRect(SpreadRect); } } // Work out if this filter wants to include all layers or just the visible ones // Default action will be to include all so that say an eps or native filters save // everything. BOOL bVisibleLayersOnly = ExportVisibleLayersOnly(); BOOL bSelectedOnly = ExportSelectionOnly(MaskedRender); if (IsCamelotEPS) { try { // Special 3-stage rendering needed for Camelot EPS to be renderable. View *pView = DocView::GetSelected(); Matrix RenderMatrix = pRegion->GetMatrix(); RenderViewResult Result = pView->RenderSimpleView(pRegion, RenderMatrix, pRegion->GetRenderSpread(), FALSE); if (Result == RENDERVIEW_USERABORT) // Export is over - user has aborted it (but this is not an error) return TRUE; if (Result == RENDERVIEW_FAILURE) // Export was not successful return FALSE; // This should never happen, as Camelot EPS cannot do 'eveything' ERROR3IF(Result == RENDERVIEW_NOTNEEDED, "RenderSimpleView did not render anything into EPS!"); // Finished render region - close down region (i.e. output trailer). ((EPSRenderRegion *) pRegion)->CloseDown(); } catch(CFileException) { // Didn't work - report failure to caller. if (pDC) pDC->ExportFile->SetThrowExceptions(FALSE); return FALSE; } // All ok return TRUE; } else { FilterRenderCallback MyCallback(this, TRUE, bVisibleLayersOnly, bSelectedOnly); pRegion->RenderTree(pNode, FALSE, FALSE, &MyCallback); pRegion->ResetRender(); // Now actually export the nodes themselves // Use a virtual function so that filters can overide this and say render in strips as // the bitmap filters are required to do ProgressOffset = 0; BOOL Result = ExportRenderNodes(pRegion, pDC, bVisibleLayersOnly, bSelectedOnly, FALSE/*TRUE*/); // return the result to the caller return Result; } #else return FALSE; #endif }

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

Sets up the file to do an export of the nodes in the tree, by initialising the file, and any slow-job code. It then calls the WriteNodes method to do the actual work, and EndExportRender to complete the task. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> (from Neville's original code) Date: 12/4/00 Parameters: pRegion  - the render region to export to. [INPUTS] pDc - device context to use, can be NULL. 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: Filter::ExportRender, Filter::WriteNodes, Filter::EndExportRender Reimplemented in BaseBitmapFilter. Definition at line 2189 of file filters.cpp. { #ifdef DO_EXPORT ERROR2IF ( pRegion == NULL, FALSE, "Filter::ExportRender null render region supplied" ); // Start a progress update going if ( ShowProgress ) { String_64 ExportMessage ( GetExportMsgID () ); if ( pDC && pDC->ExportFile ) { ExportMessage = GetExportProgressString ( pDC->ExportFile, GetExportMsgID () ); } BeginSlowJob ( NumNodes, FALSE, &ExportMessage ); } // Work out how often we want to update the progress bar. UpdateEvery = ( NumNodes / 100 ) + 1; LastExportProgressUpdate = 0; NumNodes = 0; // Guard against disk/file errors, and get ready to render. //TRY { // Get the region ready to render. if ( !pRegion->StartRender() ) { // An error occured. if ( ShowProgress ) EndSlowJob (); return FALSE; } } #if 0 CATCH ( CFileException, e ) { // Didn't work - report failure to caller. if ( pDC ) pDC->ExportFile->SetThrowExceptions ( FALSE ); if ( ShowProgress ) EndSlowJob (); return FALSE; } END_CATCH #endif // Write the nodes out to the file, and end the export if ( WriteNodes ( pRegion, pDC, VisibleLayersOnly, CheckSelected, ShowProgress ) && EndExportRender ( pRegion, ShowProgress ) ) { // It worked. return TRUE; } else { // Houston, we have a problem. return FALSE; } #else return FALSE; #endif }

BOOL Filter::ExportSelectionOnly (  BOOL  MaskedRender = FALSE  )  [virtual]

Determines if the filter wants to export only selected items. In the filters baseclass version the default action will be to export all objects by default Only used by bitmap export and in particular masked gif rendering at present. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/09/95 Returns: True if this filter wants check if an object is selected or not and so export only the selected items Or False if want to export everything. See also: Filter::ExportRender; Reimplemented in ImagemapFilter, GrabFrameFilter, FlashFilter, and MaskedFilter. Definition at line 1801 of file filters.cpp. { // base class version says export everything regardless of whether selected or not. return FALSE; }

BOOL Filter::ExportVisibleLayersOnly (   )  [virtual]

Determines if the filter wants to export only visible layers. NB. This base class version does the default action of making the filter export everything including hidden layers. 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 in BaseBitmapFilter, GrabFrameFilter, and FlashFilter. Definition at line 1779 of file filters.cpp. { // base class version includes all layers and so everything will get exported return FALSE; }

Filter * Filter::FindFilterFromID (  const UINT32  FilterID  )  [static]

Provides the Filter given its ID. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (moved into this class by Graham 7/7/97) Date: 10/12/96 (This function is also in Filter Manager. Unfortunately, having it there means that every time you use it you have to get a pointer to the application, then use that to get a pointer to the filter manager, then use that pointer to call this function. So I've copied it here for convenience) Definition at line 6648 of file filters.cpp. { Filter *pFilter; for( pFilter = Filter::GetFirst(); pFilter != 0; pFilter = Filter::GetNext(pFilter)) if (pFilter->FilterID == FilterID) { ERROR3IF(FilterID == FILTERID_NONE, "Filter::FindFilterFromID: filter has _R(ID_NONE)?"); break; } return pFilter; }

void Filter::ForceStatusExportMessage (  UINT32  nMessage  )  [static]

Overrides the status-line message shown when a file is exported. This is used by the clipboard code to change "Saving document..." to "Copying to clipboard...". Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/96 Parameters: nMessage  ---- the message to use instead of the usual when [INPUTS] exporting a file. See also: Filter::UnforceStatusExportMessage; ExternalClipboard::GetDataSource Definition at line 1565 of file filters.cpp. { // Use this message please (if derived classes allow it). m_nForcedStatusExportMessage = nMessage; }

Layer * Filter::GetActiveLayer (  Document *  pDoc  )  [protected]

Find the active layer of the first spread of the specified document. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: pDoc  - the document to search. [INPUTS] Returns: Pointer to the layer found, or NULL if none, See also: Filter::GetFirstSpread Definition at line 1384 of file filters.cpp. { PORTNOTE("spread", "Multi-spread warning!") Spread *pSpread = GetFirstSpread(pDoc); if (pSpread != NULL) return pSpread->FindActiveLayer(); return NULL; }

BitmapFilterSupport Filter::GetBitmapSupportLevel (   )  [virtual]

Determine how well this filter supports bitmaps when exporting. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/95 Returns: NoBitmapSupport - This filter does not support bitmap images. SimpleBitmapSupport - This filter has simple support for bitmap images; they must be saved into the file whenever they are used. IndirectedBitmapSupport - This filter supports bitmap indirection; i.e. a bitmap pool of some type is saved and then this can be referenced in the file. Reimplemented in ArtWorksEPSFilter, and CamelotNativeEPSFilter. Definition at line 2531 of file filters.cpp. { // Defaults to no bitmap support return NoBitmapSupport; }

AttributeEntry* Filter::GetCurrentAttrs (   )  [inline]

Definition at line 533 of file filters.h. { return CurrentAttrs; }

Document* Filter::GetDocument (   )  [inline]

Reimplemented in BaseCamelotFilter. Definition at line 532 of file filters.h. { return TheDocument; }

BOOL Filter::GetDragAndDropTranslation (  ImportPosition *  pPos, DocRect  BoundsRect, Coord *  Offset )  [protected, virtual]

Given an drag'n'drop point (in pPos), calculate the translation necessary to position the imported objects at this position on the spread. It ensures that bounding rectangles smaller than the spread are wholly contained within the spread. i.e. if you drag a file right to the edge of a spread, the translation will move it closer to the centre of the spread so that it is wholly contained within the spread. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/10/94 Parameters: pSpread  - the spread to check against. [INPUTS] BoundsRect - the bounding rectangle to check (in spread coordinates). Offset  - [OUTPUTS] Returns: TRUE if the bounding rectangle is smaller than the spread => Offset now contains the translation necessary to position the objects correctly. FALSE if bounding rectangle is bigger than the spread, or pPos was NULL. In either case, a FALSE return results in Offset containing (0,0). Used by the import filters for drag'n'drop to ensure that after the imported objects are translated to the drop point, they are all still on the spread. Made virtual 20/5/97. See also: Filter::DoImport Reimplemented in TI_GIFFilter. Definition at line 4404 of file filters.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // First check to se if we actually have a drag and drop point. if (pPos == NULL) { // No - set offset to 0 and return FALSE to indicate we can't cope with this. Offset->x = 0; Offset->y = 0; return FALSE; } // Get the spread's bounding rectangle and convert it to spread coords. DocRect SpreadRect = pPos->pSpread->GetPasteboardRect(); pPos->pSpread->DocCoordToSpreadCoord(&SpreadRect); #if defined( DODGY_BITMAP_POS_CODE ) // Now check that the bounding rectangle is small enough to fit on the spread... if ((BoundsRect.Width() > SpreadRect.Width()) || (BoundsRect.Height() > SpreadRect.Height())) { // No - set offset to 0 and return FALSE to indicate we can't cope with this. Offset->x = 0; Offset->y = 0; return FALSE; } #endif // Bounding box should be centred on drop point DocCoord Centre; Centre.x = (BoundsRect.lo.x + BoundsRect.hi.x) / 2; Centre.y = (BoundsRect.lo.y + BoundsRect.hi.y) / 2; Offset->x = pPos->Position.x - Centre.x; Offset->y = pPos->Position.y - Centre.y; // Transform the bounding rect to see if it's off the spread. BoundsRect.Translate(Offset->x, Offset->y); // If it's off the spread - limit it to the edge of the spread: // (a) Horizontal adjustment if (BoundsRect.lo.x < SpreadRect.lo.x) Offset->x += (SpreadRect.lo.x - BoundsRect.lo.x); else if (BoundsRect.hi.x > SpreadRect.hi.x) Offset->x -= (BoundsRect.hi.x - SpreadRect.hi.x); // (b) Vertical adjustment (most useful to clip hi co-ords) if (BoundsRect.hi.y > SpreadRect.hi.y) Offset->y -= (BoundsRect.hi.y - SpreadRect.hi.y); else if (BoundsRect.lo.y < SpreadRect.lo.y) Offset->y += (SpreadRect.lo.y - BoundsRect.lo.y); // Whatever happened, we can fit it on the spread. return TRUE; #else Offset->x = 0; Offset->y = 0; return FALSE; #endif }

UINT32 Filter::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 in BaseBitmapFilter, GrabFrameFilter, MakeBitmapFilter, TI_GIFFilter, ImageMagickFilter, and PNGFilter. Definition at line 1545 of file filters.cpp. { return (m_nForcedStatusExportMessage) ? m_nForcedStatusExportMessage : ExportMsgID; }

String_64 Filter::GetExportProgressString (  CCLexFile *  pExportFile, UINT32  ExportingMsgID )  [virtual]

Works out what progress bar string to use during exporting of the file. This consists of a basic message plus, if it will fit, a truncated form of the filename being exported. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/95 Parameters: ExportFile  file being used for importing [INPUTS] ImportingMsgID id of message to use as basis on progress string -  [OUTPUTS] Returns: String to use on the progress bar during import. See also: Filter::GetImportProgressString; Definition at line 1748 of file filters.cpp. { #ifdef DO_EXPORT String_64 ProgressString(ExportingMsgID); // Ammend the string with the filename, if we can. GetProgressString(pExportFile, &ProgressString); return ProgressString; #else return String_64( _T("") ); #endif }

static List& Filter::GetFilters (   )  [inline, static]

Definition at line 808 of file filters.h. { return FilterList; }

Filter * Filter::GetFirst (   )  [static]

Iterating through the list of filters known to Camelot. This function returns the first filter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: Pointer to the first filter, or NULL if none. See also: Filter::GetNext() Scope: Static Definition at line 1084 of file filters.cpp. { return (Filter *) FilterList.GetHead(); }

Spread * Filter::GetFirstSpread (  Document *  pDoc  )  [static, protected]

Find the first spread of the specified document. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: pDoc  - the document to search. [INPUTS] Returns: Pointer to the spread found, or NULL if no spread was found. See also: Filter::GetActiveLayer Definition at line 1461 of file filters.cpp. { // Search for the first chapter node Node *pNode = pDoc->GetFirstNode()->FindNext()->FindFirstChild(); while ((pNode != NULL) && (!pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter)))) pNode = pNode->FindNext(); ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter)), "Filter::GetFirstSpread(): Could not find Chapter"); Chapter *pChapter = (Chapter *) pNode; // pSpread is a child of pChapter PORTNOTE("spread", "Multi-spread warning!") Spread *pSpread = (Spread *) pChapter->FindFirstChild(); ENSURE(pSpread->IsKindOf(CC_RUNTIME_CLASS(Spread)), "Filter::GetFirstSpread(): Could not find Spread"); if (pSpread->IsKindOf(CC_RUNTIME_CLASS(Spread))) return pSpread; else return NULL; }

FilterFlags Filter::GetFlags (   )

Get the flags for a specified filter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: The FilterFlags structure See also: FilterFlags Definition at line 1120 of file filters.cpp. { return Flags; }

static GenericFilter* Filter::GetGenericFilter (   )  [inline, static]

Definition at line 530 of file filters.h. { return pGenericFilter; }

UINT32 Filter::GetImportMsgID (   )  [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 in BaseBitmapFilter. Definition at line 1527 of file filters.cpp. { return ImportMsgID; }

String_64 Filter::GetImportProgressString (  CCLexFile *  pImportFile, UINT32  ImportingMsgID )  [virtual]

Works out what progress bar string to use during importing of the file. This consists of a basic message plus, if it will fit, a truncated form of the filename being imported. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/95 Parameters: ImportFile  file being used for importing [INPUTS] ImportingMsgID id of message to use as basis on progress string -  [OUTPUTS] Returns: String to use on the progress bar during import. See also: Filter::GetExportProgressString; Definition at line 1721 of file filters.cpp. { String_64 ProgressString(ImportingMsgID); // Ammend the string with the filename, if we can. GetProgressString(pImportFile, &ProgressString, &m_StrToAddToProgress); return ProgressString; }

ID Filter::GetNewFilterID (   )  [static]

Support function providing an unique ID for each newly registered Filter. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 10/12/96 Returns: A FilterID unique to this FilterManager for each call to the function Definition at line 979 of file filters.cpp. { ERROR3IF(!m_NextFilterID, "Creating duff FilterID"); return m_NextFilterID++; }

Filter * Filter::GetNext (  Filter *  pFilter  )  [static]

Iterating through the list of filters known to Camelot. This function returns the next filter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Parameters: pFilter  - pointer to the filter to be used to get the following filter. [INPUTS] Returns: Pointer to the next filter, or NULL if none. See also: Filter::GetFirst Definition at line 1103 of file filters.cpp. { return (Filter *) FilterList.GetNext(pFilter); }

UINT32 Filter::GetNumNodes (   )

Allows access to the stored numbers of nodes which is currently set up to be used for a progress bar. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The numbers of nodes which are currently set up to be used for a progress bar. Definition at line 2417 of file filters.cpp. { return NumNodes; }

Layer* Filter::GetSoleLayer (   )  [inline]

Definition at line 562 of file filters.h. {return m_pSoleLayer;}

virtual INT32 Filter::HowCompatible (  PathName &  Filename, ADDR  HeaderStart, UINT32  HeaderSize, UINT32  FileSize )  [inline, virtual]

Reimplemented in BaseCamelotFilter, CDRFilter, CMXFilter, CMXImportFilter, MSPaletteFilter, PaintShopProPaletteFilter, AdobeColourTableFilter, AdobeColourSwatchFilter, CorelPaletteFilter, JCWColourFilter, AcornDrawFilter, EPSFilter, JPEGExportFilter, FilterFamily, FlareTemplateFilter, JPEGImportFilter, PreviewFilter, PluginNativeFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, MetaFileFilter, PNGFilter, and BasePMFilter. Definition at line 502 of file filters.h. { return 0; }

INT32 Filter::ImportBinary (  ADDR  pData, INT32  Length )  [virtual]

Read in binary data from the file and place it in the buffer supplied by the caller. This is over-ridden by filters to do whatever translation is necessary, e.g. EPS filters convert ASCII Hexadecimal data to binary. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Parameters: Length  - the number of bytes to read. [INPUTS] pData  - the buffer to place the bytes in. [OUTPUTS] Returns: The number of bytes read, or -1 for an error. (NB. Base class version always returns -1) NB. This base class version has no functionality - it always returns FALSE without setting the error ID and ENSUREs in debug builds. Don't use it! Returns: Errors: End of file; Disk error Reimplemented in EPSFilter, and CamelotNativeEPSFilter. Definition at line 1507 of file filters.cpp. { ENSURE(FALSE, "Base class ImportBinary() function called!"); return -1; }

BOOL Filter::ImportBitmap (  CCLexFile *  , KernelBitmap **  )  [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 in BaseBitmapFilter, and FilterFamily. Definition at line 2553 of file filters.cpp. { // Base class - ignore bitmaps return TRUE; }

void Filter::IncludePreviewBmp (  BOOL  WantBmp  )

Asks the filter to include a Preview bitmap or not. NOTE: This only has any effect if the Filter answered TRUE to a call to CanIncludePreviewBmp. NOTE2: All the filters hang around even if they are not doing any filtering, so if you set this flag one way it will stay like that for all future uses of the filter until it is set again. The best method will be to swtich it on if required, do the import and then switch it off again immediatly afterwards. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: WantBmp  - TRUE if you want the filter to Include a Preview Bitmap. [INPUTS] FALSE if not. See also: Filter::CanIncludePreviewBmp Definition at line 491 of file filters.cpp. { // Set the internal Flag WantPreviewBmp = WantBmp; }

virtual BOOL Filter::IncProgressBarCount (  UINT32  n  )  [inline, virtual]

Reimplemented in BaseBitmapFilter, and BaseCamelotFilter. Definition at line 831 of file filters.h. { return TRUE; } // do nothing

virtual BOOL Filter::Init (  void   )  [pure 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 Reimplemented from SimpleCCObject. Implemented in AI5EPSFilter, AI8EPSFilter, AIEPSFilter, PhotoShopEPSFilter, ArtWorksEPSFilter, BaseBitmapFilter, CamelotEPSFilter, BaseCamelotFilter, CDRFilter, CMXFilter16, CMXFilter32, CMXImportFilter, MSPaletteFilter, PaintShopProPaletteFilter, AdobeColourTableFilter, AdobeColourSwatchFilter, CorelPaletteFilter, JCWColourFilter, CorelEPSFilter, Corel3EPSFilter, Corel4EPSFilter, AcornDrawFilter, EPSFilter, JPEGExportFilter, GenericFilter, VectorFilterFamily, BitmapFilterFamily, GenericEPSFilter, PaletteFilterFamily, ImagemapFilter, FreeHandEPSFilter, FlareTemplateFilter, JPEGImportFilter, CamelotNativeFilter, CamelotNativeEPSFilter, PreviewFilter, PreviewFilterBMP, PreviewFilterGIF, PreviewFilterJPEG, PreviewFilterPNG, FlashFilter, CamelotWebFilter, BMPFilter, TI_GIFFilter, ImageMagickFilter, MaskedFilter, MetaFileFilter, PNGFilter, BasePMFilter, PPMFilter, PGMFilter, and PBMFilter.

BOOL Filter::InitFilters (   )  [static]

Scans all filters to find out which filters are available for use, and instantiates one of each, and holds them in a list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: TRUE if initialised ok, FALSE if not. Errors: Out of memory (if a filter fails to initialise for other reasons then an error is reported, but Camelot will still start up ok, i.e. TRUE is returned). See also: Filter Definition at line 744 of file filters.cpp. { // Find the filters - the kernel ones are hard-wired. Filter* pFilter; // Create, initialise and install the Generic import filter ADD_FILTER(GenericFilter) // Keep a pointer to this one, for handling drag'n'drop pGenericFilter = (GenericFilter *) pFilter; // Create, initialise and install the generic vector and bitmap filters ADD_FILTER(VectorFilterFamily) ADD_FILTER(BitmapFilterFamily) #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) #if BUILD_TEXT_FILTERS ADD_FILTER(TextFilterFamily) #endif #endif // Create, initialise and install the Generic EPS import filter #ifndef STANDALONE ADD_FILTER(GenericEPSFilter) #endif #ifndef EXCLUDE_FROM_XARALX // Remove this next line to add the CDR / CMX filters... #ifndef NOCDRCMX ADD_FILTER(PaletteFilterFamily) #endif #endif // Create, initialise and install the other supported filters: // This must be the first filter that uses .xar or "Save as" wont work ADD_FILTER(CamelotNativeFilter) // The new designed native filter, used for v2 PORTNOTETRACE("filter","Removed CamelotWebFilter usage"); #ifndef EXCLUDE_FROM_XARALX ADD_FILTER(CamelotWebFilter) // The minimalistic form of the v2 native filter #endif ADD_FILTER(CamelotEPSFilter) ADD_FILTER(CamelotNativeEPSFilter) // The old style EPS native filter, used in v1.1 // Winoil filters are initialised here to prevent the drop-down list from being // mis-ordered. // Graeme (25-9-00) - Primary filters, in the order that Mark requested. ADD_FILTER(JPEGExportFilter) ADD_FILTER(JPEGImportFilter) ADD_FILTER(PNGFilter) if (ImageMagickFilter::CheckPath()) { // Most of these commented out whilst we have no useful interface for // filter selection ADD_FILTER(ImageMagickFilterBMP) //ADD_FILTER(ImageMagickFilterCUR) //ADD_FILTER(ImageMagickFilterCUT) //ADD_FILTER(ImageMagickFilterDCM) //ADD_FILTER(ImageMagickFilterDCX) //ADD_FILTER(ImageMagickFilterDIB) //ADD_FILTER(ImageMagickFilterDNG) //ADD_FILTER(ImageMagickFilterEPDF) //ADD_FILTER(ImageMagickFilterEPI) //ADD_FILTER(ImageMagickFilterEPS) //ADD_FILTER(ImageMagickFilterEPS2) //ADD_FILTER(ImageMagickFilterEPS3) //ADD_FILTER(ImageMagickFilterEPSF) //ADD_FILTER(ImageMagickFilterEPSI) //ADD_FILTER(ImageMagickFilterEPT) //ADD_FILTER(ImageMagickFilterFAX) //ADD_FILTER(ImageMagickFilterFITS) ADD_FILTER(ImageMagickFilterICO) //ADD_FILTER(ImageMagickFilterJNG) //ADD_FILTER(ImageMagickFilterMIFF) //ADD_FILTER(ImageMagickFilterMPC) //ADD_FILTER(ImageMagickFilterOTB) //ADD_FILTER(ImageMagickFilterP7) //ADD_FILTER(ImageMagickFilterPALM) //ADD_FILTER(ImageMagickFilterPAM) //ADD_FILTER(ImageMagickFilterPBM) ADD_FILTER(ImageMagickFilterPCD) //ADD_FILTER(ImageMagickFilterPCDS) //ADD_FILTER(ImageMagickFilterPCL) //ADD_FILTER(ImageMagickFilterPCX) //ADD_FILTER(ImageMagickFilterPDB) ADD_FILTER(ImageMagickFilterPDF) //ADD_FILTER(ImageMagickFilterPGM) ADD_FILTER(ImageMagickFilterPICT) //ADD_FILTER(ImageMagickFilterPIX) ADD_FILTER(ImageMagickFilterPNM) ADD_FILTER(ImageMagickFilterPPM) //ADD_FILTER(ImageMagickFilterPS) //ADD_FILTER(ImageMagickFilterPS2) //ADD_FILTER(ImageMagickFilterPS3) ADD_FILTER(ImageMagickFilterPSD) //ADD_FILTER(ImageMagickFilterPTIF) //ADD_FILTER(ImageMagickFilterPWP) //ADD_FILTER(ImageMagickFilterRLA) //ADD_FILTER(ImageMagickFilterRLE) //ADD_FILTER(ImageMagickFilterSCT) //ADD_FILTER(ImageMagickFilterSFW) //ADD_FILTER(ImageMagickFilterSUN) // // ADD_FILTER(ImageMagickFilterSVG) - removed per NeilH 19/07/2006 so it doesn't clash with vector SVG import //ADD_FILTER(ImageMagickFilterTGA) ADD_FILTER(ImageMagickFilterTIFF) //ADD_FILTER(ImageMagickFilterTIM) //ADD_FILTER(ImageMagickFilterTTF) //ADD_FILTER(ImageMagickFilterVICAR) //ADD_FILTER(ImageMagickFilterVIFF) //ADD_FILTER(ImageMagickFilterWBMP) //ADD_FILTER(ImageMagickFilterWPG) //ADD_FILTER(ImageMagickFilterXBM) //ADD_FILTER(ImageMagickFilterXCF) ADD_FILTER(ImageMagickFilterXPM) //ADD_FILTER(ImageMagickFilterXWD) } ADD_FILTER(TI_GIFFilter) PORTNOTETRACE("filter","Removed TIFFFilter"); #ifndef EXCLUDE_FROM_XARALX ADD_FILTER(TIFFFilter) #endif #if !defined(EXCLUDE_FROM_XARALX) && !defined(PROD_XS) // disabled for XS builds OILFilter::InitPluginFilters(FilterList); #endif PORTNOTE("filter","Removed Flash filter for 0.7") #if defined(_DEBUG) ADD_FILTER(FlashFilter) #endif #ifndef STANDALONE // Other filters in alphabetical order. PORTNOTE("filter","Removed filters usage") #ifndef EXCLUDE_FROM_XARALX ADD_FILTER(AcornDrawFilter) #endif // Adobe AI / EPS filters. ADD_FILTER(AIEPSFilter) ADD_FILTER(AI5EPSFilter) ADD_FILTER(AI8EPSFilter) ADD_FILTER(PhotoShopEPSFilter) ADD_FILTER(ArtWorksEPSFilter) PORTNOTE("filter","Removed filters usage") #ifndef EXCLUDE_FROM_XARALX // ADD_FILTER(BMPFilter) // These filters are not shown in the drop-down menu. // ADD_FILTER(AdobeColourSwatchFilter) // ADD_FILTER(AdobeColourTableFilter) // ADD_FILTER(JCWColourFilter) // Remove this next line to add the CDR / CMX filters... #ifndef NOCDRCMX // Corel native filters. (CMX and CDR.) ADD_FILTER(CDRFilter) ADD_FILTER(CMXImportFilter) PORTNOTE("filter","Removed CMXFilterX usage") ADD_FILTER(CMXFilter16) ADD_FILTER(CMXFilter32) #endif //NOCDRCMX // Corel EPS filters. PORTNOTE("filter","Removed Corel EPS filters usage") ADD_FILTER(Corel3EPSFilter) ADD_FILTER(Corel4EPSFilter) ADD_FILTER(CorelPaletteFilter) #endif ADD_FILTER(FreeHandEPSFilter) PORTNOTE("filter","Removed filters usage") #ifndef EXCLUDE_FROM_XARALX // HTML based filters. PORTNOTE("filter","Removed HTMLFilter usage") ADD_FILTER(HTMLFilter) // the HTML filter ADD_FILTER(ImagemapFilter) #endif //EXCLUDE_FROM_XARALX #if BUILD_OTHER_TEXT_FILTERS // The text filters don't appear in the drop-down menu. ADD_FILTER(ANSITextFilter) ADD_FILTER(UnicodeTextFilter) ADD_FILTER(RTFTextFilter) #endif #endif #ifdef _DEBUG ADD_FILTER(FlareTemplateFilter) // The text version #endif // Initialise the OIL filters (but they are still objects of class "Filter") // This can include filters specific to one platform. OILFilter::InitFilters(FilterList); #if !defined(EXCLUDE_FROM_RALPH) // Register our preference for minimum line widths, and whether or not we import // unnamed colours into the document colour list. Camelot.DeclareSection(_T("Filters"), 10); Camelot.DeclarePref(_T("Filters"), _T("MinLineWidth"), &MinLineWidth, 0, 10000); Camelot.DeclarePref(_T("Filters"), _T("ImportWithLayers"), &ImportWithLayers); Camelot.DeclarePref(_T("Filters"), _T("OpenWithLayers"), &OpenWithLayers); Camelot.DeclarePref(_T("Filters"), _T("ImportBitmapsOntoLayers"), &ImportBitmapsOntoLayers); Camelot.DeclarePref(_T("Filters"), _T("DontWarnBitmapNonMixTransp"), &bDontWarnBitmapNonMixTransp); Camelot.DeclarePref(_T("Filters"), _T("AddUnnamedColours"), &AddUnnamedColours); #endif XSEPSExportOptions::Init(); BaseBitmapFilter::InitBaseClass(); // All ok return TRUE; }

BOOL Filter::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 in BaseBitmapFilter, CamelotEPSFilter, BaseCamelotFilter, CMXImportFilter, PaletteFilter, AcornDrawFilter, EPSFilter, FilterFamily, CamelotWebFilter, TI_GIFFilter, and MetaFileFilter. Definition at line 1145 of file filters.cpp. { // No need to check the pathname, just return FALSE as most filters will not require the // default document. return FALSE; }

BOOL Filter::JoinFamily (  CCRuntimeClass *  pRuntimeClass  )  [virtual]

Allow a filter to choose whether or not it wants to become part of a filter 'family', e.g. a filter family such as "EPS files", or "Bitmap files". The default implementation checks to see if the filter is of the same kind of filter, using IsKindOf(), and if so, it consents to be in the filter family. Filters should only over-ride this if they need different behaviour for some bizarre reason. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/07/94 Parameters: pRuntimeClass  - the type of filters in this family. [INPUTS] Returns: TRUE if the filter can be added to the family; FALSE if not. Reimplemented in FilterFamily. Definition at line 1065 of file filters.cpp. { return IsKindOf(pRuntimeClass); }

ADDR Filter::LoadInitialSegment (  CCLexFile *  pFile, UINT32 *  pSize, size_t *  pFileSize )

Determine if this filter can load the specified file. The filter is provided with the first n bytes of the file, where n is HeaderSize. It should look at this data and/or the pathname to determine if it can load this file. NB. Base class function is pure virtual - override it!Loads in the first n bytes of a file, in order to investigate whether a filter (or number of filters in the case of the FilterFamily class), is compatible with the file - i.e. how well this file recognises the file header. The last byte in the block is set to 0, to prevent ASCII lexers from going trundling off the end. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: pFile  - the file to load from. [INPUTS] Size - the number of bytes to load from the file. Size  - the number of bytes actually loaded (not actually implemented yet; [OUTPUTS] waiting for the CCFile class to be updated). Returns: Address the the loaded block Errors: Unable to open file; Out of memory See also: Filter::HowCompatible; Filter::PreHowCompatible Definition at line 1217 of file filters.cpp. { ERROR3IF(pFile == NULL, "Null CCLexFile* in Filter::LoadInitialSegment"); BOOL ThrowState = pFile->SetThrowExceptions(TRUE); BOOL ErrorState = pFile->SetReportErrors(FALSE); // Tell caller how big the file is in bytes *pFileSize = pFile->Size(); // Now that we know the file size, check to see if it has a chance of being loaded. // 4 is a nice small size that would fail the tests below. if (*pFileSize < 4) { // Could set a new special 'I don't think this file has any useful info in'. TRACEUSER( "Neville", _T("LoadInitialSegment(): Very small file found\n")); ERROR1(NULL, _R(IDE_FILETOOSMALL)); } // Check if the file size is less than the required initial segement size. // If so set the size to be the file size. // Casting UINT32 to INT32 should be ok as we know we are between 4 and the specified size. if ((UINT32) *pFileSize < *pSize) *pSize = (UINT32) *pFileSize; ADDR FilterBuf = (ADDR) CCMalloc(*pSize); if (FilterBuf == NULL) return NULL; // Save the current read pointer. FilePos nOldPos = pFile->tellIn(); try { // A flag see if things are working BOOL IsResultOK = TRUE; // First we will check to see if it starts with the fabby binary EPS marker char Buf[4]; pFile->SetDontFail(TRUE); pFile->read(Buf, 4); pFile->SetDontFail(FALSE); if( Progress::IsRalphAbort() ) return NULL; if ((Buf[0]=='\xC5') && (Buf[1]=='\xD0') && (Buf[2]=='\xD3') && (Buf[3]=='\xC6')) { // Yes, this is a binary EPS file that has a TIFF attached, so find the EPS FilePos StartOfEPS = 0; pFile->SetDontFail(TRUE); pFile->read(&StartOfEPS, 4); StartOfEPS = LEtoNative(StartOfEPS); pFile->SetDontFail(FALSE); if(Progress::IsRalphAbort()) return NULL; TRACEUSER( "Rik", _T("EPS Starts at %ld\n"), StartOfEPS); // see if the result makes sense if (StartOfEPS==0) { // Must be rubbish TRACEUSER( "Rik", _T("This file claims to start at 0 - Its rubbish\n")); IsResultOK = FALSE; } // Seek to the start of the EPS ready for the importer to read it. pFile->seekIn(StartOfEPS, ios::beg); // If the end of the file comes before the 1k we require then we must only read // the remaining file size otherwise the read below will error. if ((UINT32)(*pFileSize - StartOfEPS) < *pSize) { *pSize = (UINT32) (*pFileSize - StartOfEPS); TRACEUSER( "Neville", _T("Reduced initial segement size to %d\n"), *pSize); } } else { // This was not a binary EPS file, so go back to the start of the file pFile->seekIn(nOldPos, ios::beg); } // BODGE: Size should be updated to the number of bytes actually read. pFile->SetDontFail(TRUE); if (IsResultOK) pFile->read(FilterBuf, *pSize); pFile->SetDontFail(FALSE); if( Progress::IsRalphAbort() ) return NULL; // Don't need this file anymore - restote its original read pointer. pFile->seekIn(nOldPos, ios::beg); // Set back the old error informing and throwing states pFile->SetThrowExceptions(ThrowState); pFile->SetReportErrors(ErrorState); // If it worked if (IsResultOK) { // Zero the last byte of the buffer to make it simple for ASCII analysis. FilterBuf[(*pSize) - 1] = 0; // Return address of file data return FilterBuf; } // If we get here, there was a problem, so return null if (FilterBuf != NULL) CCFree(FilterBuf); // return ERROR1(NULL, _R(IDS_FILECORRUPT)); } catch( CFileException ) { // Restore the original read pointer. pFile->seekIn(nOldPos, ios::beg); // Set back the old error informing and throwing states pFile->SetThrowExceptions(ThrowState); pFile->SetReportErrors(ErrorState); // We had an error so the buffer is no good any more so remove it and // return NULL to the caller. if (FilterBuf != NULL) CCFree(FilterBuf); // We had a problem so return null return NULL; } // Should not get here return NULL; }

ADDR Filter::LoadInitialSegment (  PathName &  Path, UINT32 *  Size, size_t *  FileSize )

Definition at line 1356 of file filters.cpp. { CCDiskFile FilterFile; if (!FilterFile.open(Path, ios::in | ios::binary)) { TRACEUSER( "Tim", _T("LoadInitialSegment(): Could not open file\n")); ERROR1(NULL, _R(IDT_IMPORT_NOTFOUND)); } return LoadInitialSegment(&FilterFile, Size, FileSize); }

BOOL Filter::MakeSureLayerExists (  Document *  pDoc  )  [protected]

This functions checks that there is a layer to put nodes onto during an import, and will create a new layer if there are none. This means that filters can call this function just before they try and insert a new node into the tree and be sure that there will be a layer for it to go onto. The function will return TRUE if there is a layer in the document (even if this function had to create the layer). It will return FALSE only if there are no layers and it was unable to create any new ones. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/95 Parameters: pDoc  - the document that the inserting is happening in [INPUTS] Returns: TRUE if there is a layer Definition at line 1414 of file filters.cpp. { // Find the spread that all the action is happening on PORTNOTE("spread", "Multi-spread warning!") Spread* pSpread = GetFirstSpread(pDoc); if (pSpread==NULL) return FALSE; // Try and find a layer in this spread Layer* pLayer = pSpread->FindFirstLayer(); // If there were no layers, then we should try and make one if (pLayer==NULL) { // Time to build a new layer... Layer *pNewLayer = new Layer(pSpread, LASTCHILD, String_256(_R(IDS_K_FILTERS_LAYERNAME))); // If we failed, return FALSE to the caller if (pNewLayer==NULL) return FALSE; // Make Layer1 (top layer) the active layer pNewLayer->SetActive(TRUE); // Move the Insertion position onto the new layer pDoc->ResetInsertionPosition(); } // all worked return TRUE; }

BOOL Filter::OpenExportFile (  CCDiskFile *  pDiskFile, PathName *  pPath )  [virtual]

Opens up the file ready for exporting into. Assumes the file has already been constructed with the correct buffers etc.. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/95 Parameters: pDiskFile  The constructed disk file to use [INPUTS] pPath The pathname of the file to be opened Returns: True if the file has been opened correctly, False otherwise. See also: OpMenuExport::DoWithParam; Filters::DoExport; Returns: Errors: The relevent error is set if the file did not open properly Definition at line 1824 of file filters.cpp. { #ifdef DO_EXPORT ERROR2IF(pDiskFile == NULL, FALSE,"Filter::OpenExportFile null file supplied"); ERROR2IF(pPath == NULL, FALSE,"Filter::OpenExportFile null pathname supplied"); // Open up the file. This will create a zero length file just to make sure that it // is possible, i.e. we have write access. This should have actually already been // checked by the file export dialog code and trapped before this. // Added 27/9/95 ios::trunc as exporting a bitmap or eps file to the same file twice // appended the data to the end of the file on Windows 95. BOOL ok = pDiskFile->open(*pPath, ios::in | ios::out | ios::binary | ios::trunc); if (!ok) { // Failed to open the file so set the error that we want to report Error::SetError(_R(IDT_EXPORT_NOTFOUND), 0); } return ok; #else return FALSE; #endif }

void Filter::PopCurrentAttrsBasedOnSnapShot (   )  [protected]

This function uses the snap shot facility. It checks the snap shot list against the current attribute list to find attributes which differ. Those that do are obviously new attributes. ie attributes which have been parsed by the filter after the snap shot was taken. This function takes the current attrubute list and removes all those attributes which have changed in this way. It resets them to their default none temp attribute types. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: -  [INPUTS] Returns: - Definition at line 704 of file filters.cpp. { FilterSnapShot.PopAttrsBasedOnSnapShot(CurrentAttrs); }

BOOL Filter::PreHowCompatible (   )  [virtual]

Allows a filter or set of filters to take some action or set up variables before being called by HowCompatible. A group of filters which share common code may require some variable set up before being asked to check the type. Base class does nothing and so works for all filters which do not require it. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Returns: True if it it worked ok. See also: HowCompatible Definition at line 1167 of file filters.cpp. { return TRUE; }

void Filter::PushCurrentAttrsBasedOnSnapShot (   )  [protected]

This function uses the snap shot facility. It checks the snap shot list against the current attribute list to find attributes which differ. Those that do are obviously new attributes. ie attributes which have been parsed by the filter after the snap shot was taken. This function takes the current attrubute list and removes all those attributes which have changed in this way. It resets them to their default none temp attribute types. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: -  [INPUTS] Returns: - Definition at line 681 of file filters.cpp. { FilterSnapShot.PushAttrsBasedOnSnapShot(CurrentAttrs); }

ID Filter::RegisterFilter (  Filter *const   pFilter  )  [static]

Permits the filter to be used by the FilterManager. For an import filter to be present on the Import dialog the filter should associate itself with the requisite FileFormats via AssociateFilterWithFormat(). Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/94 Parameters: pFilter,:  pointer to the filter to register [INPUTS] DestructMethod : whether or not the given filter should be destructed when the collection of registered filters is destructed. Returns: FilterID that uniquely identifies the given filter within the scope of this FilterManager and allows for fast retrieval of the filter. Definition at line 1005 of file filters.cpp. { ERROR2IF(pFilter == NULL, 0, "NULL Args"); ID newID = GetNewFilterID(); GetFilters().AddTail(pFilter); return newID; }

BOOL Filter::RemoveTextScript (   )  [protected]

Removes any script attribute which is currently active. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 26/04/94 Parameters: -  [INPUTS] Returns TRUE if the attribute was removed FALSE otherwise. Returns: Errors: Out of memory. See also: Definition at line 6561 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // if a script attribute exists, delete it. if (CurrentAttrs[ATTR_TXTSCRIPT].Temp) CurrentAttrs[ATTR_TXTSCRIPT].Ignore = TRUE; return TRUE; }

BOOL Filter::SetAltRainbowFillEffect (   )  [protected]

Definition at line 4195 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_FILLEFFECT].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectAltRainbowAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_FILLEFFECT].Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(CurrentAttrs[ATTR_FILLEFFECT].pAttr, FillEffectAltRainbowAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_FILLEFFECT].pAttr; CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectAltRainbowAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; } } // All worked ok. return TRUE; }

BOOL Filter::SetBitmapFill (  KernelBitmap *  pBitmap, DocCoord  StartPoint, DocCoord  EndPoint, DocCoord  EndPoint2, DocColour *  StartColour = 0, DocColour *  EndColour = 0 )  [protected]

Updates the current attribute for fill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Parameters: pBitmap  - pointer to the bitmap object to fill with. [INPUTS] StartPoint, EndPoint, EndPoint2 - see BitmapFillAttribute. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; BitmapFillAttribute Definition at line 3483 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); ERROR3IF((StartColour != 0 && EndColour == 0) || (StartColour == 0 && EndColour != 0), "SetBitmapFill, StartColour and EndColour have a different status"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new BitmapFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, BitmapFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new BitmapFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. BitmapFillAttribute *pAttr = (BitmapFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(StartColour); pAttr->SetEndColour(EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); pAttr->SetEndPoint2(&EndPoint2); GetDocument()->SetCurrent(); // pAttr->AttachBitmap(pBitmap); pAttr->GetBitmapRef()->Attach(pBitmap, GetDocument()); if (pAttr->GetBitmap() != pBitmap) { // It didn't use the bitmap we gave it, so we can delete it delete pBitmap; } // All worked ok. return TRUE; }

BOOL Filter::SetBitmapTranspFill (  UINT32  TranspType, KernelBitmap *  pBitmap, DocCoord  StartPoint, DocCoord  EndPoint, DocCoord  EndPoint2, UINT32  StartTransp = 0, UINT32  EndTransp = 255 )  [protected]

Updates the current attribute for fill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] pBitmap - pointer to the bitmap object to fill with. StartPoint, EndPoint, EndPoint2 - see BitmapTranspFillAttribute. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; BitmapFillAttribute Definition at line 3987 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new BitmapTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(BitmapTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new BitmapTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. BitmapTranspFillAttribute *pAttr = (BitmapTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); // waz 3606 pAttr->SetStartTransp(&StartTransp); pAttr->SetEndTransp(&EndTransp); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); pAttr->SetEndPoint2(&EndPoint2); GetDocument()->SetCurrent(); // pAttr->AttachBitmap(pBitmap); pAttr->GetBitmapRef()->Attach(pBitmap, GetDocument()); if (pAttr->GetBitmap() != pBitmap) { // It didn't use the bitmap we gave it, so we can delete it delete pBitmap; } // All worked ok. return TRUE; }

BOOL Filter::SetConicalFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: StartColour,EndColour,StartPoint,EndPoint  - see GradFillAttribute. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3413 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new ConicalFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, ConicalFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new ConicalFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. ConicalFillAttribute *pAttr = (ConicalFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(&StartColour); pAttr->SetEndColour(&EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); // All worked ok. return TRUE; }

BOOL Filter::SetConicalTranspFill (  UINT32  TranspType, UINT32  StartTransp, UINT32  EndTransp, DocCoord  StartPoint, DocCoord  EndPoint )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] StartTransp - the 8 bit start transparency value (0-255) EndTransp - the 8 bit end transparency value (0-255) StartPoint, EndPoint - the points defining the conical fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3921 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new ConicalTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(ConicalTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new ConicalTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. ConicalTranspFillAttribute *pAttr = (ConicalTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); // waz 3538 pAttr->SetStartTransp(&StartTransp); pAttr->SetEndTransp(&EndTransp); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); // All worked ok. return TRUE; }

BOOL Filter::SetDashPattern (  DashRec &  Dash  )  [protected]

Updates the current attribute for dash pattern to reflect the value passed in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: Dash  - the Dash Pattern to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2818 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_DASHPATTERN].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_DASHPATTERN].pAttr = new DashPatternAttribute; if (CurrentAttrs[ATTR_DASHPATTERN].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_DASHPATTERN].Temp = TRUE; } // We have an attribute - just change it. DashPatternAttribute *pAttr = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; // Bodge // When we save Native files we at present save out a dash pattern ID and then // save out the full dash pattern definition! This is ok apart from wasting space. // The problem happens when we load the information back in, we load the id and apply // the relevent dash pattern and then load the definition and apply it, zapping the // id. // If we are a native filter then assume that the id has already been set up // Now done in CheckIfDefaultPattern below. // But have to disable both checks as if we set the id then we would have an id on // a scaled version of the pattern. This would also only fix files which have been // save once, as saving again will have completely lost all trace of the id! /* if (this->IS_KIND_OF(CamelotNativeEPSFilter)) { // Note the current id already put there by the native filter INT32 DashId = pAttr->DashPattern.GetDashID(); // Copy the new dash pattern over pAttr->DashPattern = Dash; // Copy the original ID across but only if it has been set // As it will default to zero then we copy it across if we have changed it! if (DashId != 0) pAttr->DashPattern.DashID = DashId; } else */ pAttr->DashPattern = Dash; // make sure the dash pattern is OK pAttr->DashPattern.CheckAndFix(); // Reset the ID if it is one of our default patterns // Cannot do this check as when a line is first saved the definition is scaled // for some strange and bizarre reason, possible to do with the fact that a general // EPS saving routine is being used. //pAttr->DashPattern.CheckIfDefaultPattern(); // All worked ok. return TRUE; }

BOOL Filter::SetEndArrow (  ArrowRec &  Arrow  )  [protected]

Updates the current attribute for End Arrow to reflect the value passed in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: Arrow  - the Arrow to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2935 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_ENDARROW].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_ENDARROW].pAttr = new EndArrowAttribute; if (CurrentAttrs[ATTR_ENDARROW].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_ENDARROW].Temp = TRUE; } // We have an attribute - just change it. EndArrowAttribute *pAttr = (EndArrowAttribute *) CurrentAttrs[ATTR_ENDARROW].pAttr; pAttr->EndArrow = Arrow; // All worked ok. return TRUE; }

BOOL Filter::SetFadeFillEffect (   )  [protected]

Definition at line 4131 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_FILLEFFECT].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectFadeAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_FILLEFFECT].Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(CurrentAttrs[ATTR_FILLEFFECT].pAttr, FillEffectFadeAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_FILLEFFECT].pAttr; CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectFadeAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; } } // All worked ok. return TRUE; }

BOOL Filter::SetFillColour (  DocColour &  Col  )  [protected]

Updates the current attribute for fill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Col  - the new fill colour to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 3093 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new FlatFillAttribute(Col); if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, FlatFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new FlatFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. FlatFillAttribute *pAttr = (FlatFillAttribute *) pEntry->pAttr; pAttr->SetStartColour(&Col); // All worked ok. return TRUE; }

BOOL Filter::SetFlatTranspFill (  UINT32  TranspType, UINT32  Transp )  [protected]

Set the current transparency fill for this import operation to be a flat transparency value. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] Transp - the 8 bit transparency value (0-255) Returns: TRUE if the fill attribute is set ok; FALSE if not (e.g. out of memory) Errors: Out of memory See also: Filter; Filter::Init; TranspFillAttribute Definition at line 3682 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new FlatTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(FlatTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new FlatTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. FlatTranspFillAttribute *pAttr = (FlatTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); pAttr->SetStartTransp(&Transp); // All worked ok. return TRUE; }

BOOL Filter::SetFractalFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint1, DocCoord  EndPoint2, INT32  Seed, double  Graininess, double  Gravity, double  Squash, UINT32  DPI, BOOL  Tileable )  [protected]

Updates the current attribute for colour fill geometry to be a fractal fill using the values passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/11/94 Parameters: StartColour,EndColour  - the colours of the fill [INPUTS] StartPoint, EndPoint1, EndPoint2 - co-ordinates of the fill mesh Seed, Graininess, Gravity, Squash - strange fractal parameters DPI - the resolution of the fractal bitmap (dots per inch). Tileable - whether the fractal bitmap is tileable or not (ask Alex). Returns: TRUE if the attribute was changed ok; FALSE otherwise => ERROR1 Errors: Out of memory => ERROR1 See also: Filter; Filter::Init; FractalFillAttribute Definition at line 3573 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new FractalFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, FractalFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new FractalFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. FractalFillAttribute *pAttr = (FractalFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(&StartColour); pAttr->SetEndColour(&EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint1); pAttr->SetEndPoint2(&EndPoint2); pAttr->SetSeed(Seed); pAttr->SetGraininess(Graininess); pAttr->SetGravity(Gravity); pAttr->SetSquash(Squash); pAttr->SetTileable(Tileable); // Actually create the fractal bitmap pAttr->SetFractalDPI(DPI); pAttr->RecalcFractal(); // All worked ok. return TRUE; }

BOOL Filter::SetFractalTranspFill (  UINT32  TranspType, DocCoord  StartPoint, DocCoord  EndPoint1, DocCoord  EndPoint2, INT32  Seed, double  Graininess, double  Gravity, double  Squash, UINT32  DPI, BOOL  Tileable, UINT32  StartTransp = 0, UINT32  EndTransp = 255 )  [protected]

Updates the current attribute for colour fill geometry to be a fractal fill using the values passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/11/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] StartPoint, EndPoint1, EndPoint2 - co-ordinates of the fill mesh Seed, Graininess, Gravity, Squash - strange fractal parameters DPI - the resolution of the fractal bitmap (dots per inch). Tileable - whether the fractal bitmap is tileable or not (ask Alex). Returns: TRUE if the attribute was changed ok; FALSE otherwise => ERROR1 Errors: Out of memory => ERROR1 See also: Filter; Filter::Init; FractalFillAttribute Definition at line 4069 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new FractalTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(FractalTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new FractalTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. FractalTranspFillAttribute *pAttr = (FractalTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); // waz 3690 pAttr->SetStartTransp(&StartTransp); pAttr->SetEndTransp(&EndTransp); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint1); pAttr->SetEndPoint2(&EndPoint2); pAttr->SetSeed(Seed); pAttr->SetGraininess(Graininess); pAttr->SetGravity(Gravity); pAttr->SetSquash(Squash); pAttr->SetTileable(Tileable); // Actually create the fractal bitmap pAttr->SetFractalDPI(DPI); pAttr->RecalcFractal(); // All worked ok. return TRUE; }

BOOL Filter::SetJoinType (  JointType  JoinType  )  [protected]

Updates the current attribute for line join style to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: JoinType  - the new line join style to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2733 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_JOINTYPE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_JOINTYPE].pAttr = new JoinTypeAttribute; if (CurrentAttrs[ATTR_JOINTYPE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_JOINTYPE].Temp = TRUE; } // We have an attribute - just change it. JoinTypeAttribute *pAttr = (JoinTypeAttribute *) CurrentAttrs[ATTR_JOINTYPE].pAttr; pAttr->JoinType = JoinType; // All worked ok. return TRUE; }

BOOL Filter::SetLinearFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint, DocCoord *  EndPoint2 = NULL )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: StartColour,EndColour,StartPoint,EndPoint  - see GradFillAttribute. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3157 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new LinearFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, LinearFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new LinearFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. LinearFillAttribute *pAttr = (LinearFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(&StartColour); pAttr->SetEndColour(&EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); pAttr->SetEndPoint2(EndPoint2); // All worked ok. return TRUE; }

BOOL Filter::SetLinearFillMapping (  INT32  Repeat  )  [protected]

Definition at line 4228 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); ERROR3IF((Repeat < 0) || (Repeat > 3),"Bad mapping repeat in SetLinearFillMapping()"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_FILLMAPPING].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_FILLMAPPING].pAttr = new FillMappingLinearAttribute; if (CurrentAttrs[ATTR_FILLMAPPING].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_FILLMAPPING].Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(CurrentAttrs[ATTR_FILLMAPPING].pAttr, FillMappingLinearAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_FILLMAPPING].pAttr; CurrentAttrs[ATTR_FILLMAPPING].pAttr = new FillMappingLinearAttribute; if (CurrentAttrs[ATTR_FILLMAPPING].pAttr == NULL) return FALSE; } } // Set the repeat state FillMappingLinearAttribute *pAttr = (FillMappingLinearAttribute *) CurrentAttrs[ATTR_FILLMAPPING].pAttr; pAttr->Repeat = Repeat; // ******************************************************************* // Added by Will 12/2/95 // Bitmap and Fractal tesselation does not appear to be being saved. // This code ensures that the repeat and tesselation values matach up. FillGeometryAttribute* pCurrentFill = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (pCurrentFill != NULL) pCurrentFill->SetTesselation(Repeat); // ******************************************************************* // All worked ok. return TRUE; }

BOOL Filter::SetLinearTranspFill (  UINT32  TranspType, UINT32  StartTransp, UINT32  EndTransp, DocCoord  StartPoint, DocCoord  EndPoint, DocCoord *  EndPoint2 = NULL )  [protected]

Updates the current attribute for transparency fill to be a linear transparent fill as specified by the values passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] StartTransp - the 8 bit start transparency value (0-255) EndTransp - the 8 bit end transparency value (0-255) StartPoint, EndPoint - the start and end-points of the linear fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; TranspFillAttribute Definition at line 3744 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new LinearTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(LinearTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new LinearTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. LinearTranspFillAttribute *pAttr = (LinearTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); // waz 3362 pAttr->SetStartTransp(&StartTransp); pAttr->SetEndTransp(&EndTransp); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint); pAttr->SetEndPoint2(EndPoint2); // All worked ok. return TRUE; }

BOOL Filter::SetLinearTranspFillMapping (  INT32  Repeat  )  [protected]

Definition at line 4280 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); ERROR3IF((Repeat < 0) || (Repeat > 3),"Bad mapping repeat in SetLinearTranspFillMapping()"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLMAPPING].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr = new TranspFillMappingLinearAttribute; if (CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLMAPPING].Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr, TranspFillMappingLinearAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr; CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr = new TranspFillMappingLinearAttribute; if (CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr == NULL) return FALSE; } } // Set the repeat state TranspFillMappingLinearAttribute *pAttr = (TranspFillMappingLinearAttribute *) CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr; pAttr->Repeat = Repeat; // ******************************************************************* // Added by Will 12/2/95 // Bitmap and Fractal tesselation does not appear to be being saved. // This code ensures that the repeat and tesselation values matach up. TranspFillAttribute* pCurrentFill = (TranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; if (pCurrentFill != NULL) pCurrentFill->SetTesselation(Repeat); // ******************************************************************* // All worked ok. return TRUE; }

BOOL Filter::SetLineCap (  LineCapType  LineCap  )  [protected]

Updates the current attribute for line cap style to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: LineCap  - the new line cap style to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2692 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_STARTCAP].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_STARTCAP].pAttr = new StartCapAttribute; if (CurrentAttrs[ATTR_STARTCAP].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_STARTCAP].Temp = TRUE; } // We have an attribute - just change it. StartCapAttribute *pAttr = (StartCapAttribute *) CurrentAttrs[ATTR_STARTCAP].pAttr; pAttr->StartCap = LineCap; // All worked ok. return TRUE; }

BOOL Filter::SetLineColour (  DocColour &  Col  )  [protected]

Updates the current attribute for line colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Col  - the new line colour to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2602 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_STROKECOLOUR].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_STROKECOLOUR].pAttr = new StrokeColourAttribute(Col); if (CurrentAttrs[ATTR_STROKECOLOUR].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_STROKECOLOUR].Temp = TRUE; } else { // We already have an attribute - just change it. StrokeColourAttribute *pAttr = (StrokeColourAttribute *) CurrentAttrs[ATTR_STROKECOLOUR].pAttr; pAttr->Colour = Col; } // All worked ok. return TRUE; }

BOOL Filter::SetLineTransp (  UINT32  TranspType, UINT32  Transp )  [protected]

Updates the current attribute for line transparency to reflect the value passed in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: TranspType  - the transparency type to use. [INPUTS] Transp - the transparency (0 to 255) of the line. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2775 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_STROKETRANSP].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_STROKETRANSP].pAttr = new StrokeTranspAttribute; if (CurrentAttrs[ATTR_STROKETRANSP].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_STROKETRANSP].Temp = TRUE; } // We have an attribute - just change it. StrokeTranspAttribute *pAttr = (StrokeTranspAttribute *) CurrentAttrs[ATTR_STROKETRANSP].pAttr; pAttr->TranspType = TranspType; pAttr->Transp = Transp; // All worked ok. return TRUE; }

BOOL Filter::SetLineWidth (  MILLIPOINT  Width  )  [protected]

Updates the current attribute for line width to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Width  - the new line width to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2645 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Avoid zero width lines - change them to the value specified in the user preference. if (Width == 0) Width = MinLineWidth; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_LINEWIDTH].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_LINEWIDTH].pAttr = new LineWidthAttribute(Width); if (CurrentAttrs[ATTR_LINEWIDTH].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_LINEWIDTH].Temp = TRUE; } else { // We already have an attribute - just change it. LineWidthAttribute *pAttr = (LineWidthAttribute *) CurrentAttrs[ATTR_LINEWIDTH].pAttr; pAttr->LineWidth = Width; } // All worked ok. return TRUE; }

BOOL Filter::SetMitreLimit (  MILLIPOINT  MitreLimit  )  [protected]

Updates the current attribute for the Mitre Limit to reflect the value passed in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: Arrow  - the Arrow to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2977 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_MITRELIMIT].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_MITRELIMIT].pAttr = new MitreLimitAttribute; if (CurrentAttrs[ATTR_MITRELIMIT].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_MITRELIMIT].Temp = TRUE; } // We have an attribute - just change it. MitreLimitAttribute *pAttr = (MitreLimitAttribute *) CurrentAttrs[ATTR_MITRELIMIT].pAttr; pAttr->MitreLimit = MitreLimit; // All worked ok. return TRUE; }

BOOL Filter::SetNoTranspFill (   )  [protected]

Set the current transparency fill for this import operation to be none, i.e. there is no transparency. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/94 Returns: TRUE if the fill attribute is set ok; FALSE if not (e.g. out of memory) Errors: Out of memory See also: Filter; Filter::Init; Filter::SetFlatTranspFill; TranspFillAttribute Note: This also (via SetFlatTranspFill) set the new painting mode attribute as well Definition at line 3658 of file filters.cpp. { // At present, we use a flat transparent fill with 0% transparency and T type 1 for // 'no transparency'. return SetFlatTranspFill(1, 0); }

UINT32 Filter::SetNumNodes (  UINT32  NewNumNodes  )

Allows setting of the stored numbers of nodes which is currently set up to be used for a progress bar. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The old number of nodes value Definition at line 2436 of file filters.cpp. { UINT32 OldNumNodes = NumNodes; NumNodes = NewNumNodes; return OldNumNodes; }

BOOL Filter::SetPathFilled (  BOOL  Filled  )  [protected]

Indicate whether paths should be filled or not. This is independent of the current fill attribute, so, for example, if this function is called to set the paths to be unfilled, and then called again to set them to be filled, then afterwards all paths filled will be filled with whatever fill attribute was last set. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/01/95 Parameters: Filled  - whether or not paths should be filled. [INPUTS] Returns: TRUE if ok; FALSE otherwise (e.g. out of memory) Errors: Out of memory => ERROR1 See also: Filter::SetFillColour Definition at line 3024 of file filters.cpp. { if(Filled == PathFilled) return TRUE; if (Filled) { // See if we need to reinstate the fill attribute if (FillAttr.pAttr != NULL) { // Yes we do... if (CurrentAttrs[ATTR_FILLGEOMETRY].Temp) { // Get rid of the current one (if it is a temporary attribute) delete CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; } // Install the new one, and vape the pointer so we don't do this again. CurrentAttrs[ATTR_FILLGEOMETRY] = FillAttr; FillAttr.pAttr = NULL; } } else { // Lose the current saved FillAttr if we need to. if ((FillAttr.pAttr != NULL) && (FillAttr.Temp)) { delete FillAttr.pAttr; } // Disabling the fill attribute - remember the current one. FillAttr = CurrentAttrs[ATTR_FILLGEOMETRY]; // Install a new flat colour fill... CurrentAttrs[ATTR_FILLGEOMETRY].pAttr = new FlatFillAttribute; if (CurrentAttrs[ATTR_FILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_FILLGEOMETRY].Temp = TRUE; // .. and make it a transparent fill DocColour TransCol(COLOUR_TRANS); FillGeometryAttribute *pAttr = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; pAttr->SetStartColour(&TransCol); } PathFilled = Filled; // Must be ok if we got here return TRUE; }

BOOL Filter::SetRadialFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint1, DocCoord  EndPoint2 )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: StartColour,EndColour  - colours to fade between. [INPUTS] StartPoint, EndPoint1, EndPoint2 - the points defining the elliptical radial fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3265 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new RadialFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, RadialFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new RadialFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. RadialFillAttribute *pAttr = (RadialFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(&StartColour); pAttr->SetEndColour(&EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint1); pAttr->SetEndPoint2(&EndPoint2); // Make sure it's elliptical pAttr->MakeElliptical(); // All worked ok. return TRUE; }

BOOL Filter::SetRadialFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: StartColour,EndColour  - colours to fade between. [INPUTS] StartPoint, EndPoint1 - the points defining the radial fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3228 of file filters.cpp. { // Call the more general function... BOOL Success = SetRadialFill(StartColour, EndColour, StartPoint, EndPoint, EndPoint); // Set the new attribute to be a circular one, if it worked if (Success) { RadialFillAttribute *pAttr = (RadialFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; pAttr->MakeCircular(); } return Success; }

BOOL Filter::SetRadialTranspFill (  UINT32  TranspType, UINT32  StartTransp, UINT32  EndTransp, DocCoord  StartPoint, DocCoord  EndPoint1, DocCoord  EndPoint2 )  [protected]

Updates the current attribute for transparency fill to be an elliptical transparent fill as specified by the values passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] StartTransp - the 8 bit start transparency value (0-255) EndTransp - the 8 bit end transparency value (0-255) StartPoint, EndPoint, EndPoint2 - the points defining the elliptical fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3851 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new RadialTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].Temp = TRUE; } else { // Ensure we have the correct attribute if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr->GetRuntimeClass() != CC_RUNTIME_CLASS(RadialTranspFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr = new RadialTranspFillAttribute; if (CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr == NULL) return FALSE; } } // We've got an attribute - change it. RadialTranspFillAttribute *pAttr = (RadialTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Copy field values. pAttr->SetTranspType(TranspType); // waz 3469 pAttr->SetStartTransp(&StartTransp); pAttr->SetEndTransp(&EndTransp); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint1); pAttr->SetEndPoint2(&EndPoint2); // Make sure it's elliptical pAttr->MakeElliptical(); // All worked ok. return TRUE; }

BOOL Filter::SetRadialTranspFill (  UINT32  TranspType, UINT32  StartTransp, UINT32  EndTransp, DocCoord  StartPoint, DocCoord  EndPoint )  [protected]

Updates the current attribute for transparency fill to be a circular transparent fill as specified by the values passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: TranspType  - the type of transparency (1-3) [INPUTS] StartTransp - the 8 bit start transparency value (0-255) EndTransp - the 8 bit end transparency value (0-255) StartPoint - the centre of the radial fill. EndPoint - a point on the edge of the circle defining the radial fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3812 of file filters.cpp. { // Call the more general function... BOOL Success = SetRadialTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint, EndPoint); // Set the new attribute to be a circular one, if it worked if (Success) { RadialTranspFillAttribute *pAttr = (RadialTranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; pAttr->MakeCircular(); } return Success; }

BOOL Filter::SetRainbowFillEffect (   )  [protected]

Definition at line 4163 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_FILLEFFECT].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectRainbowAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_FILLEFFECT].Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(CurrentAttrs[ATTR_FILLEFFECT].pAttr, FillEffectRainbowAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete CurrentAttrs[ATTR_FILLEFFECT].pAttr; CurrentAttrs[ATTR_FILLEFFECT].pAttr = new FillEffectRainbowAttribute; if (CurrentAttrs[ATTR_FILLEFFECT].pAttr == NULL) return FALSE; } } // All worked ok. return TRUE; }

void Filter::SetSaveAttributes (  BOOL  DoSave  )  [virtual]

Informs the filter whether or not it should record the attribute settings along with the file data. This allows templates to have default colours other than the standard Camelot values, whilst not encumbering save files with this extra information. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 14/3/00 Parameters: DoSave  - Should the attributes be saved along with the file data? [INPUTS] Returns: - Definition at line 4544 of file filters.cpp. { SaveAttributes = DoSave; }

void Filter::SetSoleLayer (  Layer *  pLayer  )  [inline]

Definition at line 561 of file filters.h. {m_pSoleLayer = pLayer;}

BOOL Filter::SetSquareFill (  DocColour &  StartColour, DocColour &  EndColour, DocCoord  StartPoint, DocCoord  EndPoint1, DocCoord  EndPoint2 )  [protected]

Updates the current attribute for gradfill colour to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/08/94 Parameters: StartColour,EndColour  - colours to fade between. [INPUTS] StartPoint, EndPoint1, EndPoint2 - the points defining the elliptical radial fill. Returns: TRUE if the attribute was changed ok; FALSE otherwise. FN copied and modified by Ben. Returns: Errors: Out of memory. See also: Filter; Filter::Init; GradFillAttribute Definition at line 3343 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // Find out which fill attribute to change AttributeEntry *pEntry; if (FillAttr.pAttr == NULL) // No 'saved' fill attribute, so just update the normal one. pEntry = &CurrentAttrs[ATTR_FILLGEOMETRY]; else // Update the saved fill attribute. pEntry = &FillAttr; // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!pEntry->Temp) { // Make the correct attribute value and install it as the current one. pEntry->pAttr = new SquareFillAttribute; if (pEntry->pAttr == NULL) return FALSE; pEntry->Temp = TRUE; } else { // Ensure we have the correct attribute if (!IS_A(pEntry->pAttr, SquareFillAttribute)) { // Wrong type - delete it and get the right type of attribute value. delete pEntry->pAttr; pEntry->pAttr = new SquareFillAttribute; if (pEntry->pAttr == NULL) return FALSE; } } // We've got an attribute - change it. SquareFillAttribute *pAttr = (SquareFillAttribute *) pEntry->pAttr; // Copy field values. pAttr->SetStartColour(&StartColour); pAttr->SetEndColour(&EndColour); pAttr->SetStartPoint(&StartPoint); pAttr->SetEndPoint(&EndPoint1); pAttr->SetEndPoint2(&EndPoint2); // All worked ok. return TRUE; }

BOOL Filter::SetStartArrow (  ArrowRec &  Arrow  )  [protected]

Updates the current attribute for Start Arrow to reflect the value passed in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: Arrow  - the Arrow to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 2893 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_STARTARROW].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_STARTARROW].pAttr = new StartArrowAttribute; if (CurrentAttrs[ATTR_STARTARROW].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_STARTARROW].Temp = TRUE; } // We have an attribute - just change it. StartArrowAttribute *pAttr = (StartArrowAttribute *) CurrentAttrs[ATTR_STARTARROW].pAttr; pAttr->StartArrow = Arrow; // All worked ok. return TRUE; }

BOOL Filter::SetTextAspectRatio (  FIXED16  AspectRatio  )  [protected]

Updates the current attribute for AspectRatio to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: AspectRatio  - the new Aspect Ratio to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6232 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTASPECTRATIO].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTASPECTRATIO].pAttr = new TxtAspectRatioAttribute(AspectRatio); if (CurrentAttrs[ATTR_TXTASPECTRATIO].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTASPECTRATIO].Temp = TRUE; } else { // We already have an attribute - just change it. TxtAspectRatioAttribute *pAttr = (TxtAspectRatioAttribute*) CurrentAttrs[ATTR_TXTASPECTRATIO].pAttr; pAttr->AspectRatio = AspectRatio; } // All worked ok. return TRUE; }

BOOL Filter::SetTextBaseLine (  MILLIPOINT  BaseShift  )  [protected]

Updates the current attribute for BaseLine shift to reflect the value passed in. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/94 Parameters: BaseShift  - the new baseline shift to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6457 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTBASELINE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTBASELINE].pAttr = new TxtBaseLineAttribute(BaseShift); if (CurrentAttrs[ATTR_TXTBASELINE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTBASELINE].Temp = TRUE; } else { // We already have an attribute - just change it. TxtBaseLineAttribute *pAttr = (TxtBaseLineAttribute*) CurrentAttrs[ATTR_TXTBASELINE].pAttr; pAttr->Value = BaseShift; } // All worked ok. return TRUE; }

BOOL Filter::SetTextBold (  BOOL  Bold  )  [protected]

Updates the current attribute for Bold to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Bold  - the new Bold state to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6103 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTBOLD].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTBOLD].pAttr = new TxtBoldAttribute(Bold); if (CurrentAttrs[ATTR_TXTBOLD].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTBOLD].Temp = TRUE; } else { // We already have an attribute - just change it. TxtBoldAttribute *pAttr = (TxtBoldAttribute*) CurrentAttrs[ATTR_TXTBOLD].pAttr; pAttr->BoldOn = Bold; } // All worked ok. return TRUE; }

BOOL Filter::SetTextBoldFont (  BOOL  Bold  )  [protected]

This function simply sets the bold style flag in the current font typeface attribute (to be applied to the next created character). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/06/95 Returns: TRUE if the font and style has been set FALSE if an error occured (out current typeface) Definition at line 6586 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If there is no current typeface then we cannot set its style if (!CurrentAttrs[ATTR_TXTFONTTYPEFACE].Temp) return FALSE; // There is an attribute - just change it. TxtFontTypefaceAttribute *pAttr = (TxtFontTypefaceAttribute*) CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr; pAttr->IsBold = Bold; return TRUE; }

BOOL Filter::SetTextFont (  String_64 *  EncodedName, INT32  MillFSize )  [protected]

Set the font specified in the encoded font name. The font which actually gets set in the attribute stack is one found by GetCompatibleFont(), a super new fontmanager call. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/05/95 Returns: TRUE if the font has been set correctly FALSE if an error occured specifying the font Definition at line 5885 of file filters.cpp. { String_64 CompFont; INT32 Style; BOOL Bold,Italic; // Find a nice compatible font we can use FONTMANAGER->GetCompatibleFont(*EncodedName, CompFont, Style); // get the style bits Bold=((Style & 1) != 0); Italic=((Style & 2) != 0); return SetTextFontStyle(&CompFont, MillFSize, Bold, Italic); }

BOOL Filter::SetTextFontStyle (  String_64 *  FName, INT32  MillFSize, BOOL  Bold, BOOL  Italic )  [protected]

This function creates attributes for the typeface, the pointsize, bold and italic all at once. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/05/95 Returns: TRUE if the font and styles have been set FALSE if an error occured (out of memory) Definition at line 5970 of file filters.cpp. { if ((FONTMANAGER->CacheNamedFont(FName) == ILLEGALFHANDLE)) return FALSE; if (!SetTextTypeFace(FName)) return FALSE; if (!SetTextSize(MillFSize)) return FALSE; // Build any style definitions we need if (!SetTextBold(Bold)) return FALSE; if (!SetTextItalic(Italic)) return FALSE; return TRUE; }

BOOL Filter::SetTextItalic (  BOOL  Italic  )  [protected]

Updates the current attribute for Italic to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Italic-  the new Italic state to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6146 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTITALIC].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTITALIC].pAttr = new TxtItalicAttribute(Italic); if (CurrentAttrs[ATTR_TXTITALIC].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTITALIC].Temp = TRUE; } else { // We already have an attribute - just change it. TxtItalicAttribute *pAttr = (TxtItalicAttribute*) CurrentAttrs[ATTR_TXTITALIC].pAttr; pAttr->ItalicOn = Italic; } // All worked ok. return TRUE; }

BOOL Filter::SetTextItalicFont (  BOOL  Italic  )  [protected]

This function simply sets the italic style flag in the current font typeface attribute (to be applied to the next created character). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/06/95 Returns: TRUE if the font and style has been set FALSE if an error occured (no current typeface) Definition at line 6616 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If there is no current typeface then we cannot set its style if (!CurrentAttrs[ATTR_TXTFONTTYPEFACE].Temp) return FALSE; // There is an attribute - just change it. TxtFontTypefaceAttribute *pAttr = (TxtFontTypefaceAttribute*) CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr; pAttr->IsItalic = Italic; return TRUE; }

BOOL Filter::SetTextJustification (  Justification  Justify  )  [protected]

Updates the current attribute for TextSize to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Size  - the new FontSize to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6318 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTJUSTIFICATION].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTJUSTIFICATION].pAttr = new TxtJustificationAttribute(Justify); if (CurrentAttrs[ATTR_TXTJUSTIFICATION].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTJUSTIFICATION].Temp = TRUE; } else { // We already have an attribute - just change it. TxtJustificationAttribute *pAttr = (TxtJustificationAttribute*) CurrentAttrs[ATTR_TXTJUSTIFICATION].pAttr; pAttr->justification = Justify; } // All worked ok. return TRUE; }

BOOL Filter::SetTextLineSpacing (  INT32  Type, INT32  EMLSpace, MILLIPOINT  MLSpace, double  DLSpace )  [protected, virtual]

Updates the current attribute for line spacing to reflect the value passed in. One of three values will be used depending on the type (as above). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/94 Parameters: Type  = the type of linespacing to create (0,1 or 2) [INPUTS] 0 EMLSpace = linespacing in em's (units related to the current pointsize) 1 MLSpace = absolute millipoint line spacing 2 DLSpace = propoptional linespacing Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Reimplemented in AIEPSFilter. Definition at line 6367 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); INT32 LLSpace=0; double RLSpace=0; switch (Type) { case 0: { // Use the default size. INT32 FSize = 19200; // Need to convert the linespacing to a sensible millipoint value if (CurrentAttrs[ATTR_TXTFONTSIZE].Temp) { // We already have an attribute - just change it. TxtFontSizeAttribute *pAttr = (TxtFontSizeAttribute*) CurrentAttrs[ATTR_TXTFONTSIZE].pAttr; FSize = pAttr->FontSize; } // Convert line space to millipoints. double LS = (double)EMLSpace; LLSpace = (INT32)((LS*FSize/1000)+0.5); break; } case 1: LLSpace = MLSpace; break; case 2: RLSpace = DLSpace; break; } // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTLINESPACE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTLINESPACE].pAttr = new TxtLineSpaceAttribute(); if (CurrentAttrs[ATTR_TXTLINESPACE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTLINESPACE].Temp = TRUE; } // Get a pointer to the attribute and set its new values TxtLineSpaceAttribute *pAttr = (TxtLineSpaceAttribute*) CurrentAttrs[ATTR_TXTLINESPACE].pAttr; switch (Type) { case 0: case 1: pAttr->IsRatio = FALSE; pAttr->Value = LLSpace; pAttr->Ratio = FIXED16(0); break; case 2: pAttr->IsRatio = TRUE; pAttr->Value = 0; pAttr->Ratio = RLSpace; break; } // All worked ok. return TRUE; }

BOOL Filter::SetTextScript (  INT32  rise, INT32  pointsize )  [protected]

Updates the current attribute for subscript or superscript. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/94 Parameters: rise  = signed rise in millipoints away from the baseline [INPUTS] pointsize = size of font to use in millipoints Returns TRUE if the attribute was changed ok FALSE otherwise. Returns: Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6500 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // ignore any crazy values if (pointsize<=0) return TRUE; // Use the default size. INT32 fsize = 19200; if (CurrentAttrs[ATTR_TXTFONTSIZE].Temp) { TxtFontSizeAttribute *pAttr = (TxtFontSizeAttribute*) CurrentAttrs[ATTR_TXTFONTSIZE].pAttr; fsize = pAttr->FontSize; } double tr = (double)rise/(double)fsize; double tp = (double)pointsize/(double)fsize; FIXED16 offset(tr); FIXED16 size(tp); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTSCRIPT].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTSCRIPT].pAttr = new TxtScriptAttribute(offset,size); if (CurrentAttrs[ATTR_TXTSCRIPT].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTSCRIPT].Temp = TRUE; } else { // We already have an attribute - just change it. CurrentAttrs[ATTR_TXTSCRIPT].Ignore = FALSE; TxtScriptAttribute *pAttr = (TxtScriptAttribute*) CurrentAttrs[ATTR_TXTSCRIPT].pAttr; pAttr->Offset = offset; pAttr->Size = size; } // All worked ok. return TRUE; }

BOOL Filter::SetTextSize (  INT32  Size  )  [protected]

Updates the current attribute for TextSize to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Size  - the new FontSize to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6008 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTFONTSIZE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTFONTSIZE].pAttr = new TxtFontSizeAttribute(Size); if (CurrentAttrs[ATTR_TXTFONTSIZE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTFONTSIZE].Temp = TRUE; } else { // We already have an attribute - just change it. TxtFontSizeAttribute *pAttr = (TxtFontSizeAttribute *) CurrentAttrs[ATTR_TXTFONTSIZE].pAttr; pAttr->FontSize = Size; } // All worked ok. return TRUE; }

BOOL Filter::SetTextTracking (  INT32  Tracking  )  [protected]

Updates the current attribute for TextSize to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Size  - the new FontSize to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6275 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTTRACKING].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTTRACKING].pAttr = new TxtTrackingAttribute(Tracking); if (CurrentAttrs[ATTR_TXTTRACKING].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTTRACKING].Temp = TRUE; } else { // We already have an attribute - just change it. TxtTrackingAttribute *pAttr = (TxtTrackingAttribute*) CurrentAttrs[ATTR_TXTTRACKING].pAttr; pAttr->Tracking = Tracking; } // All worked ok. return TRUE; }

BOOL Filter::SetTextTypeFace (  String_64 *  Name, FontClass  Class = FC_UNDEFINED )  [protected]

Updates the current attribute for TextSize to reflect the value passed in. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Name  - the font name to use when creating a new typeface attribute [INPUTS] Class - the class of font this name is supposed to be eg FC_TRUETYPE. the class defaults to FC_UDEFINED which means the first font cached which matches the font name will be used whatever type of font it is. Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6056 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); WORD hTypeface = FONTMANAGER->GetFontHandle(Name, Class); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTFONTTYPEFACE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr = new TxtFontTypefaceAttribute(hTypeface); if (CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTFONTTYPEFACE].Temp = TRUE; } else { // We already have an attribute - just change it. TxtFontTypefaceAttribute *pAttr = (TxtFontTypefaceAttribute*) CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr; pAttr->HTypeface = hTypeface; pAttr->IsBold = FALSE; pAttr->IsItalic = FALSE; } // All worked ok. return TRUE; }

BOOL Filter::SetTextUnderline (  BOOL  Underline  )  [protected]

Updates the current attribute for Underline to reflect the value passed in. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: Underline  - the new Underline state to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init Definition at line 6189 of file filters.cpp. { // Sanity check ERROR2IF(CurrentAttrs == NULL, FALSE, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_TXTUNDERLINE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_TXTUNDERLINE].pAttr = new TxtUnderlineAttribute(Underline); if (CurrentAttrs[ATTR_TXTUNDERLINE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_TXTUNDERLINE].Temp = TRUE; } else { // We already have an attribute - just change it. TxtUnderlineAttribute *pAttr = (TxtUnderlineAttribute*) CurrentAttrs[ATTR_TXTUNDERLINE].pAttr; pAttr->Underlined = Underline; } // All worked ok. return TRUE; }

BOOL Filter::SetUpCurrentAttrs (   )  [protected]

Obtains an attribute array from the attribute manager. This array is the set of default attributes - the filter should use them to maintain its set of current attributes while importing. It then asks the attribute manager to add the correct attributes to each node based on this array. This should be called when importing, not when intialising, otherwise all filters will have this array hanging around all the time, which is bad. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Returns: TRUE if attributes set up ok; FALSE otherwise. Errors: Out of memory. See also: AttributeManager; AttributeManager::ApplyBasedOnDefaults Definition at line 518 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs == NULL, "Filter::SetUpCurrentAttrs called unnecessarily!"); // Get the array of default attributes to use as our current attributes. CurrentAttrs = AttributeManager::GetDefaultAttributes(); if (CurrentAttrs == NULL) return FALSE; // Clear the 'ignore' flag on all attributes. INT32 NumAttrs = AttributeManager::GetNumAttributes(); for (INT32 i = 0; i < NumAttrs; i++) CurrentAttrs[i].Ignore = FALSE; // All done return TRUE; }

BOOL Filter::SetWindingRule (  WindingType  WindingRule  )  [protected]

Updates the current attribute for winding rule to reflect the value passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/94 Parameters: WindingRule  - the new winding rule to use. [INPUTS] Returns: TRUE if the attribute was changed ok; FALSE otherwise. Errors: Out of memory. See also: Filter; Filter::Init; WindingType Definition at line 4348 of file filters.cpp. { // Sanity check ENSURE(CurrentAttrs != NULL, "No current attributes in filter!"); // If we haven't changed this attribute yet, then make a new attribute object for // our own personal use... if (!CurrentAttrs[ATTR_WINDINGRULE].Temp) { // Make the correct attribute value and install it as the current one. CurrentAttrs[ATTR_WINDINGRULE].pAttr = new WindingRuleAttribute(WindingRule); if (CurrentAttrs[ATTR_WINDINGRULE].pAttr == NULL) return FALSE; CurrentAttrs[ATTR_WINDINGRULE].Temp = TRUE; } else { // We already have an attribute - just change it. WindingRuleAttribute *pAttr = (WindingRuleAttribute *) CurrentAttrs[ATTR_WINDINGRULE].pAttr; pAttr->WindingRule = WindingRule; } // All worked ok. return TRUE; }

virtual BOOL Filter::ShouldExportHTMLTag (   )  [inline, virtual]

Reimplemented in BaseCamelotFilter, FlareTemplateFilter, CamelotWebFilter, and CamelotNULLWebFilter. Definition at line 632 of file filters.h. { return FALSE; }

BOOL Filter::SnapShotCurrentAttrs (   )  [protected]

This function grabs a snap shot of the filter managers current attributes. It simply makes a new List identical to that of CurrentAttrs. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: -  [INPUTS] Returns: TRUE if the currentattrs list has been copied FALSE if nothing has been copied Definition at line 607 of file filters.cpp. { return FilterSnapShot.CreateSnapShot(CurrentAttrs); }

void Filter::UnforceStatusExportMessage (   )  [static]

Resets the message override on export back to "no override". Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/96 See also: Filter::ForceStatusExportMessage; ExternalClipboard::GetDataSource Definition at line 1582 of file filters.cpp. { // Set this back to "no override". m_nForcedStatusExportMessage = 0; }

BOOL Filter::UpdateExportedNodeCount (  UINT32  NumNodesSaved = 1  )

Update the progress display according to the number passed in. The NumNodes parameter indicates how many nodes have just been saved. Most nodes won't call this when exporting as they are only '1' node. Nodes such as blenders or bitmaps may call this to update the progress more smoothly. E.g. a bitmap might say that it is 20 nodes if it has 20 scanlines. It could then call this function after each scanline is saved with the value 1. It should not call it with more than the number of nodes it claims to be, e.g. the example bitmap above should only ever call with NumNodes in the range 1 to 20. And the cumulative total of NumNodesSaved passed in by one node should never be more than the number of nodes it claims to be either. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: NumNodes  - number of nodes just saved. [INPUTS] Returns: TRUE if the progress display was updated ok; FALSE if not (i.e. the user pressed Esc to cancel the operation). See also: Node::GetSizeOfExport Definition at line 2472 of file filters.cpp. { #ifdef DO_EXPORT // Work out how many nodes have been saved in total. NumNodes += NumNodesSaved; // Make sure we remain within the legal range of values if (NumNodes > CurrentProgressLimit) { #if _DEBUG // Only report an error once for each sub-section otherwise it's too annoying. static UINT32 LastError = 0; if (LastError != CurrentProgressLimit) { if (Error::IsUserName("Tim")) { ERROR3("Filter::UpdateExportedNodeCount() called with an out of range value!"); } LastError = CurrentProgressLimit; } #endif // Ignore the error in retail builds - it's not serious (but limit the value) NumNodes = CurrentProgressLimit; } // Check to see if it's worth updating yet. if (NumNodes > (LastExportProgressUpdate + UpdateEvery)) { LastExportProgressUpdate = NumNodes; if (!ContinueSlowJob(NumNodes)) { return FALSE; } } #endif // Everything is ok if we get here return TRUE; }

void Filter::UpdateFilterProgress (  UINT32  increment  )  [protected, virtual]

Shuts down the export render process. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> (from Neville's original code) Date: 12/4/00 Parameters: pRegion  - the render region to export to. [INPUTS] 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: Filter::ExportRender, Filter::ExportRenderNodes Definition at line 2340 of file filters.cpp. { // Limit the progress display to legal values if (increment>0) CurrentProgressLimit = NumNodes + increment; // Update node count accordingly NumNodes = CurrentProgressLimit; if (NumNodes > (LastExportProgressUpdate + UpdateEvery)) LastExportProgressUpdate = NumNodes; }

BOOL Filter::WillAcceptExistingFile (  PathName  pthToReplace  )  [virtual]

Checks to see if this filter will accept an existing file to export to. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/5/97 Returns: TRUE if this filter is willing to accept this existing file FALSE otherwise This base version will simply ask the user if she wants to overwrite the file. But ImagemapFilter::WillAcceptExistingFile will override this so the user can insert an imagemap into an existing HTML file. Reimplemented in ImagemapFilter. Definition at line 4486 of file filters.cpp. { PORTNOTETRACE("filter","Filter::WillAcceptExistingFile - do nothing"); #ifndef EXCLUDE_FROM_XARALX //We're going to put up a message box to ask the user if she wants to //replace the existing file. //So first get the truncated path name String_256 strToReplace = pthToReplace.GetTruncatedPath(50); //Now create a string to put our error message in String_256 strError; //And make the error message up using the file name strError.MakeMsg(_R(IDM_EXPORT_OVERWRITE), &strToReplace); //Now, set that error message as the next one to display Error::SetError( 0, strError, 0 ); //And set up the message help context SetNextMsgHelpContext(_R(IDM_EXPORT_OVERWRITE)); //Now set up the buttons ErrorInfo Info; Info.Button[0] = _R(IDB_OVERWRITE); Info.Button[1] = _R(IDS_CANCEL); //Make "cancel" the default Info.OK = Info.Cancel = 2; //And put the error box up switch (AskQuestion( &Info )) { case _R(IDS_CANCEL): return FALSE; case _R(IDB_OVERWRITE): default: return TRUE; } #endif return false; }

BOOL Filter::WriteNodes (  RenderRegion *  pRegion, ExportDC *  pDC, BOOL  VisibleLayersOnly, BOOL  SelectedOnly, BOOL  ShowProgress )  [protected, 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. Assumes that either a progress bar has been started and will be ended by the caller or that it should start and end the progress bar itself. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> (from Neville's original code) Date: 12/4/00 Parameters: pRegion  - the render region to export to. [INPUTS] pDc - device context to use, can be NULL. 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: Filter::ExportRender, Filter::ExportRenderNodes Reimplemented in AIEPSFilter, and FlashFilter. Definition at line 2282 of file filters.cpp. { #ifdef DO_EXPORT // Find the first node that we should export from this spread Node *pNode = pRegion->GetRenderSpread (); // Cycle through all exportable nodes, and render (export) them. // Export the file, but catch any file errors. //TRY { // BOOL IsPageBackGroundAnd32BitAlpha = FALSE; // BOOL LookForPageBackgrounds = TRUE; FilterRenderCallback MyCallback(this, FALSE, VisibleLayersOnly, SelectedOnly); // Not counting this time! pRegion->RenderTree(pNode, FALSE, FALSE, &MyCallback); pRegion->ResetRender(); } #if 0 CATCH ( CFileException, e ) { // Didn't work - report failure to caller. if ( pDC ) pDC->ExportFile->SetThrowExceptions ( FALSE ); pRegion->StopRender (); if ( ShowProgress ) EndSlowJob (); return FALSE; } END_CATCH #endif // All OK return TRUE; #else return FALSE; #endif }

---

Friends And Related Function Documentation

friend class FilterRenderCallback [friend]

Definition at line 449 of file filters.h.

---

Member Data Documentation

BOOL Filter::AddUnnamedColours = FALSE [static]

If it is TRUE then any colours used in the imported file but not explicitly named by whatever colour table structure the file uses will be created as named colours (usu. of the form Unnamed 1, Unnamed 2 and so on). If FALSE, immediate colours will be used, and will not appear on the document's colour bar. Defaults to FALSE. Preference: AddUnnamedColours Section: Filters Range: TRUE or FALSE See also: MinLineWidth Definition at line 816 of file filters.h.

BOOL Filter::bDontWarnBitmapNonMixTransp = FALSE [static]

Controls how bitmap files are opened/imported: TRUE => each bitmap is placed on a new layer. FALSE => each bitmaps is placed on the current layer. Applies to multiple format bitmaps such as animated GIFs. Preference: bDontWarnBitmapNonMixTransp Section: Filters Range: TRUE or FALSE. Definition at line 828 of file filters.h.

AttributeEntry* Filter::CurrentAttrs [protected]

Definition at line 778 of file filters.h.

UINT32 Filter::CurrentProgressLimit = 0 [static, protected]

Definition at line 847 of file filters.h.

UINT32 Filter::ExportMsgID [protected]

Definition at line 589 of file filters.h.

AttributeEntry Filter::FillAttr [protected]

Definition at line 784 of file filters.h.

UINT32 Filter::FilterID

Definition at line 551 of file filters.h.

String_256 Filter::FilterInfo

Definition at line 550 of file filters.h.

List Filter::FilterList [static, private]

Definition at line 792 of file filters.h.

String_256 Filter::FilterName

Definition at line 549 of file filters.h.

SnapShotList Filter::FilterSnapShot [protected]

Definition at line 781 of file filters.h.

FilterFlags Filter::Flags [protected]

Definition at line 576 of file filters.h.

BOOL Filter::ImportBitmapsOntoLayers = TRUE [static]

Controls how bitmap files are opened/imported: TRUE => each bitmap is placed on a new layer. FALSE => each bitmaps is placed on the current layer. Applies to multiple format bitmaps such as animated GIFs. Preference: ImportBitmapsOntoLayers Section: Filters Range: TRUE or FALSE. Definition at line 826 of file filters.h.

UINT32 Filter::ImportMsgID [protected]

Definition at line 596 of file filters.h.

INT32 Filter::ImportWithLayers = 2 [static]

Controls how files are imported: TRUE => Layers are imported/created as necessary when importing. FALSE => Layers are ignore when importing, and the whole imported file is placed in the document as a group. Preference: ImportWithLayers Section: Filters Range: TRUE or FALSE. See also: Filter Definition at line 819 of file filters.h.

UINT32 Filter::LastExportProgressUpdate = 0 [static, protected]

Definition at line 846 of file filters.h.

UINT32 Filter::m__StripStart = 0 [static, protected]

Definition at line 850 of file filters.h.

ID Filter::m_NextFilterID = 1099 + 1 [static, private]

Definition at line 795 of file filters.h.

UINT32 Filter::m_nForcedStatusExportMessage = 0 [static, protected]

Definition at line 570 of file filters.h.

Layer* Filter::m_pSoleLayer [protected]

Definition at line 601 of file filters.h.

String_64 Filter::m_StrToAddToProgress [protected]

Definition at line 657 of file filters.h.

INT32 Filter::MinLineWidth = 250 [static, protected]

Controls how line widths are handled - if a line width thinner than the value of this preference is found, then the line width is forced to be this width. E.g. set it to 500 to make all imported lines be at least 0.5 points wide. (It defaults to 0.25pt). Preference: MinLineWidth Section: Filters Range: Between 0 and 10,000. See also: AddUnnamedColours Definition at line 799 of file filters.h.

UINT32 Filter::NumNodes = 0 [static, protected]

Definition at line 844 of file filters.h.

BOOL Filter::OpenWithLayers = TRUE [static]

Controls how files are opened: TRUE => Layers are imported/created as necessary when opening a file. FALSE => Layers are ignore when importing, and the whole opened file is placed in the document as a group. Note: Does not affect v2 Native file formats such as xar and web. Preference: OpenWithLayers Section: Filters Range: TRUE or FALSE. Definition at line 822 of file filters.h.

BOOL Filter::PathFilled [protected]

Definition at line 785 of file filters.h.

GenericFilter * Filter::pGenericFilter = NULL [static, private]

Definition at line 789 of file filters.h.

OILFilter* Filter::pOILFilter

Definition at line 552 of file filters.h.

UINT32 Filter::ProgressOffset = 0 [static, protected]

Definition at line 849 of file filters.h.

BOOL Filter::SaveAttributes [protected]

Definition at line 599 of file filters.h.

UINT32 Filter::StopExportMsgID [protected]

Definition at line 593 of file filters.h.

Document* Filter::TheDocument [protected]

Definition at line 579 of file filters.h.

UINT32 Filter::UpdateEvery = 1 [static, protected]

Definition at line 845 of file filters.h.

BOOL Filter::WantPreviewBmp [protected]

Definition at line 573 of file filters.h.

---

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

• Kernel/filters.h (r1785/r1476)
• Kernel/filters.cpp (r1785/r1760)

---