ImagemapFilter Class Reference

The imagemap export filter class. More...

#include <filtimag.h>

Inheritance diagram for ImagemapFilter:

List of all members.

Public Member Functions
	ImagemapFilter ()
	Default constructor.
virtual BOOL	Init ()
	Initializes the ImagemapFilter.
	~ImagemapFilter ()
	Destructor. Deletes the render region pointer.
virtual BOOL	DoExport (Operation *pOp, CCLexFile *pFile, PathName *pPath, Document *pDoc, BOOL ShowOptions)
	This function is called when the user has gone to the Export... dialog box, chosen the imagemap filter and clicked the Export button.
BOOL	PrepareAndWriteData (Document *pDoc)
	Calculates an imagemap based on the file pDoc and the current set of ImagemapFilterOptions. Then writes this out to either a file or the clipboard (as specified in the options).
BOOL	PrepareData (Document *pDoc)
	Sets up the imagemap data in the render region.
BOOL	WriteData ()
	Writes the data in the ImagemapRenderRegion either to a file or to the clipboard, as specified in the ImagemapFilterOptions.
BOOL	GetOptionsFromUser (ImagemapFilterOptions *pifoDefault, PathName *ppthFile, CCLexFile *pFile)
	Puts up the Export Options... dialog box to get a set of ImagemapFilterOptions from the user.
BOOL	WillAcceptExistingFile (PathName pthToReplace)
	Checks if the user wants to export to this existing file.
void	SearchFileForImagemaps (const PathName &pthSearch, List *plstToAdd)
	Goes through the file pointed to by pthSearch.
void	SetFilterOptions (ImagemapFilterOptions ifoOptions)
	Sets ifoOptions as current within the filter.
ImagemapFilterOptions	GetFilterOptions ()
	Returns the current set of imagemap filter options.
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.
Protected Member Functions
void	Write (CCLexFile *pfileToWrite)
	Writes out the imagemap to a file or a text buffer or both. This works as follows:.
BOOL	PrepareRenderRegion (Document *pDoc)
	a. Creates a new render region with the current set of options b. Attaches a device to that render region
void	ForceBackgroundRedrawOff (DocView *pView)
	Switches background rendering off in pView.
void	RestoreBackgroundRedraw (DocView *pView)
	Restores pView's background redraw state.
BOOL	OpenImagemapFile (CCLexFile *pFile, PathName *pPath)
	Opens the export file.
BOOL	CloseImagemapFile (CCLexFile *pFile)
	Closes the export file.
INT32	WriteHelper (CCLexFile *pfileToWrite=NULL, TCHAR *pcBuffer=NULL)
	This function will be called twice:.
INT32	WriteBitmapHTML (CCLexFile *pfileToWrite=NULL, TCHAR *pcBuffer=NULL)
INT32	WriteImagemapHTML (CCLexFile *pfileToWrite=NULL, TCHAR *pcBuffer=NULL)
	Writes the bitmap HTML.Writes the imagemap HTML.
INT32	WritePreamble (TCHAR *pcBuffer)
	Helper for writing imagemaps - this function will write the 'preamble' to pcBuffer. The 'preamble' consists of the image source, dimensions, which map it is bound to, and a tag indicating the border has 0 width.
void	CopyToClipboard (TCHAR *pcBuffer=NULL)
	Puts the text on the clipboard.
BOOL	WriteDataToExistingFile (CCLexFile *pFile, PathName *pPath)
	Writes the data in the imagemap region into an existing file and/or to the clipboard.
BOOL	WriteDataToNewFile (CCLexFile *pFile, PathName *pPath)
	Writes the data in the imagemap region into a new file and/or to the clipboard.
BOOL	WriteExistingDataHelper (CCLexFile *pfileTo, CCLexFile *pfileFrom, PathName *pPath)
	This function does most of the hard work in writing an imagemap into an existing file.
BOOL	ContainsSameImagemapName (CCLexFile *pfileSearch)
void	BuildMapNamesList (CCLexFile *pfileSearch, PathName *ppthSearch, List *plstToAdd)
	Goes through the file pointed to by pfileSearch.
Protected Attributes
ImagemapRenderRegion *	m_pRegion
DocView *	pView
BOOL	BackgroundRedrawStateSet
BOOL	BackgroundRedrawState
Static Protected Attributes
static ImagemapFilterOptions	ms_Options = ImagemapFilterOptions()
Private Member Functions
	CC_DECLARE_MEMDUMP (ImagemapFilter)
Static Private Attributes
static TCHAR	ms_strApprox [] = _T("ExportImagemap\\CurveApproximation")
static TCHAR	ms_strAllRectangles [] = _T("ExportImagemap\\AllRectangles")
static TCHAR	ms_strClipboard [] = _T("ExportImagemap\\Clipboard")
static TCHAR	ms_strFile [] = _T("ExportImagemap\\File")
static TCHAR	ms_strInsert [] = _T("ExportImagemap\\Insert")

---

Detailed Description

The imagemap export filter class.

Author:

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

Date:

9/4/97

This code contained in this class is called when

a. The user selects the Imagemap filter class in the Export... dialog box.

b. The user tells one of the bitmap filters to export an imagemap at the same time as it exports the bitmap

Definition at line 129 of file filtimag.h.

---

Constructor & Destructor Documentation

ImagemapFilter::ImagemapFilter (   )

Default constructor. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Definition at line 159 of file filtimag.cpp. { //First set up the members of the filter class ExportMsgID = _R(IDS_EXPORTMSG_IMAGEMAP); Flags.CanImport = FALSE; Flags.CanExport = TRUE; Flags.CanExportMultipleImages = FALSE; Flags.ShowFilter = TRUE; FilterID = FILTERID_IMAGEMAP; //Set the pointer to our render region as NULL m_pRegion=NULL; //And set up our options to a set of default values ImagemapFilter::ms_Options=ImagemapFilterOptions(); BackgroundRedrawStateSet=FALSE; BackgroundRedrawState=FALSE; }

ImagemapFilter::~ImagemapFilter (   )

Destructor. Deletes the render region pointer. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Definition at line 235 of file filtimag.cpp. { //Delete our render region pointer if it's pointing to something m_pRegion=NULL; }

---

Member Function Documentation

void ImagemapFilter::BuildMapNamesList (  CCLexFile *  pfileSearch, PathName *  ppthSearch, List *  plstToAdd )  [protected]

Goes through the file pointed to by pfileSearch. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/97 Parameters: plstToAdd  Pointer to the list to add the names to [INPUTS] pfileSearch Pointer to the file to search ppthSearch Pointer to the path of the file to search Returns: - Each time it finds an imagemap tag <MAP name="xxx>">, it adds the value of the NAME parameter into the list pointed to by plstToAdd. This may seem a strange function to be an "entry point" to the filter, but it's here so that the file parsing code is available to BaseBitmapFilter. Definition at line 1557 of file filtimag.cpp. { PORTNOTETRACE("other","ImagemapFilter::BuildMapNamesList - Do nothing"); #ifndef EXCLUDE_FROM_XARALX //First we must open the file for reading CCDiskFile* pDiskFile=(CCDiskFile*) pfileSearch; pDiskFile->open(*ppthSearch, ios::in | ios::binary); //Initialise the HTML lexer pfileSearch->InitLexer(); //Set up two strings which we will search for String_256 strMap("MAP"); String_256 strName("NAME"); //And until we reach the end of the file while(!pfileSearch->IsEndOfHTMLFile()) { //Get the next HTML token in the file pfileSearch->GetHTMLToken(TRUE, FALSE); //And if the token is an HTML MAP tag if (pfileSearch->GetHTMLTagName()==strMap) { //Then add the value of the NAME parameter to the list String_256 strToAdd=pfileSearch->GetHTMLParameterValue(strName, FALSE); StringListItem* psliToAdd=new StringListItem(strToAdd); plstToAdd->AddTail(psliToAdd); } } //And deinitialise the lexer pfileSearch->DeinitLexer(); //Then close the file pDiskFile->close(); #endif }

ImagemapFilter::CC_DECLARE_MEMDUMP (  ImagemapFilter   )  [private]

BOOL ImagemapFilter::CloseImagemapFile (  CCLexFile *  pFile  )  [protected]

Closes the export file. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/97 Parameters: pFile  - the file to close [INPUTS] Returns: TRUE if successful (no way of erroring at present) Definition at line 830 of file filtimag.cpp. { if (pFile->isOpen()) pFile->close(); return TRUE; }

BOOL ImagemapFilter::ContainsSameImagemapName (  CCLexFile *  pfileSearch  )  [protected]

void ImagemapFilter::CopyToClipboard (  TCHAR *  pcBuffer = NULL  )  [protected]

Puts the text on the clipboard. > void ImagemapFilter::CopyToClipboard(TCHAR* pcBuffer=NULL) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: pcBuffer  The text to put on the clipboard [INPUTS] Definition at line 1120 of file filtimag.cpp. { //Put the text on the clipboard InternalClipboard::CopyText(pcBuffer); }

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

This function is called when the user has gone to the Export... dialog box, chosen the imagemap filter and clicked the Export button. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the export was OK FALSE if there were any errors This function simply calls three member functions in turn in order to: Put up a dialog box to get some options from the user Set those options as current within the filter Export the file using those options Reimplemented from Filter. Definition at line 275 of file filtimag.cpp. { //First we need to get some ImagemapFilterOptions from the user //To do this, create a blank set of ImagemapFilterOptions ImagemapFilterOptions ifoNew=ms_Options; //And specify within those options that we want to //export to a file ifoNew.m_fFile=TRUE; //And specify the name of that file as being the path we have been given ifoNew.m_pthFile=*pPath; //And specify a pointer to that file ifoNew.m_pfileFile=pFile; //And remember we're reporting errors ifoNew.m_fReportErrors=TRUE; //And call up the dialog box to fill them in //If this function returns FALSE, the user has cancelled the dialog if (GetOptionsFromUser(&ifoNew, pPath, pFile)) { //Set those options as current within the filter SetFilterOptions(ifoNew); //And export to the file using those options return PrepareAndWriteData(pDoc); } else //If the user has cancelled the dialog, return TRUE anyway return TRUE; }

BOOL ImagemapFilter::ExportSelectionOnly (  BOOL  MaskedRender = FALSE  )  [inline, 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 from Filter. Definition at line 171 of file filtimag.h. { return (ms_Options.m_stExportArea==SELECTION); }

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

Switches background rendering off in pView. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/97 - Britain deserves better! Parameters: pView  [INPUTS] Returns: - Definition at line 753 of file filtimag.cpp. { // We wan't to make sure we only remember the old state once ... if (!BackgroundRedrawStateSet) { BackgroundRedrawState = pView->GetForeBackMode(); BackgroundRedrawStateSet = TRUE; // So we don't do this more than once } pView->SetForeBackMode(FALSE); }

ImagemapFilterOptions ImagemapFilter::GetFilterOptions (   )

Returns the current set of imagemap filter options. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Parameters: -  [INPUTS] Returns: The current set of imagemap filter options Definition at line 612 of file filtimag.cpp. { //Return the filter options return ms_Options; }

BOOL ImagemapFilter::GetOptionsFromUser (  ImagemapFilterOptions *  pifoDefault, PathName *  ppthFile, CCLexFile *  pFile )

Puts up the Export Options... dialog box to get a set of ImagemapFilterOptions from the user. BOOL ImagemapFilter::GetOptionsFromUser(ImagemapFilterOptions* pifoDefault, PathName* pPath, CCLexFile* pFile) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Parameters: pifoDefault  A set of ImagemapFilterOptions that [INPUTS] will appear in the dialog box when it starts pPath Path to the file we are writing to pFile The file we are writing to A  set of ImagemapFilterOptions from the user [OUTPUTS] Returns: FALSE if the dialog was cancelled Definition at line 646 of file filtimag.cpp. { ERROR2IF (pifoDefault==NULL, FALSE, "ImagemapFilter::GetOptionsFromUser - NULL parameter"); PORTNOTETRACE("other","ImagemapFilter::GetOptionsFromUser - Do nothing"); #ifndef EXCLUDE_FROM_XARALX //Now, if the file we are writing to exists already, and if //we are writing to that file if (SGLibOil::FileExists(ppthFile) && ms_Options.Insert()) { //Then we want to create a list of all the imagemap names in the existing file //This variable will hold the list List lstNames; //Then go through the file and get a list of all the imagemap names //in the file BuildMapNamesList(pFile, ppthFile, &lstNames); //Then put up the modal dialog with that list of names shown //in the map name combo box BOOL ok=ImagemapDlg::InvokeDialog(pifoDefault, &lstNames); //Delete the list of names lstNames.DeleteAll(); //And return return ok; } else { //Put up the dialog box with nothing shown in the map name //combo box //The dialog will start with the inital values of pifoReturn //in it. When the dialog closes, it will put the values that the user //chose back into *pifoDefault return ImagemapDlg::InvokeDialog(pifoDefault); } #endif return FALSE; }

BOOL ImagemapFilter::Init (  void   )  [virtual]

Initializes the ImagemapFilter. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the filter was initialized ok FALSE otherwise Implements Filter. Definition at line 193 of file filtimag.cpp. { // Set up our associated oil filter pOILFilter = new ImagemapOILFilter(this); //If we failed to set it up, return FALSE if (pOILFilter==NULL) return FALSE; // Load the description strings FilterName.Load(_R(IDS_FILTERNAME_IMAGEMAP)); FilterInfo.Load(_R(IDS_FILTERINFO_IMAGEMAP)); //And declare those variables which we want to save in the registry if (DeclareFilterPreferenceSection()) { Camelot.DeclarePref( NULL, ms_strApprox, (INT32*) &ms_Options.m_ffApprox, FF_VERYCLOSELY, FF_NOTATALL); Camelot.DeclarePref( NULL, ms_strAllRectangles, &ms_Options.m_fAllRectangles, FALSE, TRUE); Camelot.DeclarePref( NULL, ms_strClipboard, &ms_Options.m_fClipboard, FALSE, TRUE); Camelot.DeclarePref( NULL, ms_strFile, &ms_Options.m_fFile, FALSE, TRUE); Camelot.DeclarePref( NULL, ms_strInsert, &ms_Options.m_fInsert, FALSE, TRUE); } PORTNOTE("other","Remove ImagemapDlg usage - not defined yet"); #ifndef EXCLUDE_FROM_XARALX //Initialise the ExportOptions dialog ImagemapDlg::Init(); #endif //And return return TRUE; }

BOOL ImagemapFilter::OpenImagemapFile (  CCLexFile *  pFile, PathName *  pPath )  [protected]

Opens the export file. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/97 Parameters: pFile,pPath  - the file to export to [INPUTS] Returns: TRUE if successful FALSE if there was an error Definition at line 797 of file filtimag.cpp. { BOOL ok; if (!pFile->isOpen()) { if (pFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { ok = OpenExportFile((CCDiskFile*) pFile, pPath); if (!ok) return FALSE; } else { TRACEUSER( "JustinF", _T("Tried to open non-CCDiskFile in ImagemapFilter::DoExport\n")); return FALSE; } } return TRUE; }

BOOL ImagemapFilter::PrepareAndWriteData (  Document *  pDoc  )

Calculates an imagemap based on the file pDoc and the current set of ImagemapFilterOptions. Then writes this out to either a file or the clipboard (as specified in the options). Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the export was OK FALSE if there were any errors This function is called by both ImagemapFilter::DoExport and the BaseBitmapFilter class. Definition at line 334 of file filtimag.cpp. { //This variable will keep track of any problems BOOL ok=TRUE; //First set up the data to export ok=PrepareData(pDoc); // if there was a problem, or the region is empty if (!ok || m_pRegion->IsEmpty()) { //delete the render region if (m_pRegion) delete m_pRegion; m_pRegion = NULL; //If there was a problem, return FALSE if (!ok) return FALSE; //If there is no data, and we are reporting errors, put up a message box to say so if (ms_Options.m_fReportErrors) { ERROR1(TRUE, _R(IDE_IMAGEMAP_NODATA)); } else return TRUE; } //Otherwise, export the data ok=WriteData(); //And delete the render region if (m_pRegion) delete m_pRegion; m_pRegion = NULL; return ok; }

BOOL ImagemapFilter::PrepareData (  Document *  pdocToExport  )

Sets up the imagemap data in the render region. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/97 Returns: TRUE if successful Does not export that data to the file. Definition at line 389 of file filtimag.cpp. { //Set up the render region BOOL ok=PrepareRenderRegion(pdocToExport); //If that worked... if (ok) { //Render into our ImagemapRenderRegion //to set the data ExportRender(m_pRegion); //Restore the settings of the render region RestoreBackgroundRedraw(pView); } //And return return ok; }

BOOL ImagemapFilter::PrepareRenderRegion (  Document *  pDoc  )  [protected]

a. Creates a new render region with the current set of options b. Attaches a device to that render region Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/97 Parameters: pDoc  - The document to export [INPUTS] Returns: TRUE if successful FALSE if there was an error Definition at line 711 of file filtimag.cpp. { PORTNOTETRACE("other","ImagemapFilter::PrepareRenderRegion - Do nothing"); #ifndef EXCLUDE_FROM_XARALX // First, create the render region from our current options if (m_pRegion) delete m_pRegion; m_pRegion = new ImagemapRenderRegion(ms_Options); //Now we must attach a device to our render region //For this, we must find the current view and spread pView = DocView::GetCurrent(); Spread* pSpread = Filter::GetFirstSpread(pDoc); ERROR2IF(pView==NULL, FALSE, "ImagemapFilter::PrepareToExport - no current view!"); ERROR2IF(pSpread==NULL, FALSE, "ImagemapFilter::PrepareToExport - no current spread!"); //And attach the device to our render region //The middle parameter is the device context, which we set as NULL m_pRegion->AttachDevice(pView, NULL, pSpread); //We also need to switch background rendering off in the view ForceBackgroundRedrawOff(pView); #endif return TRUE; }

void ImagemapFilter::RestoreBackgroundRedraw (  DocView *  pView  )  [protected]

Restores pView's background redraw state. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/97 - Tough on bugs, tough on the causes of bugs Parameters: pView  [INPUTS] Returns: - Definition at line 778 of file filtimag.cpp. { // We wan't to make sure we only remember the old state once ... pView->SetForeBackMode(BackgroundRedrawState); }

void ImagemapFilter::SearchFileForImagemaps (  const PathName &  pthSearch, List *  plstToAdd )

Goes through the file pointed to by pthSearch. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 4/7/97 Parameters: pthSearch  The path of the file to search [INPUTS] plstToAdd Pointer to a list to add the map names to Returns: - Each time it finds an imagemap tag <MAP name="xxx>">, it adds the value of the NAME parameter into the list pointed to by plstToAdd. It does this all by calling the function BuildMapNamesList. See Also: ImagemapFilter::BuildMapNamesList(); Definition at line 552 of file filtimag.cpp. { //First create a disk file CCDiskFile fileOpen(1024, FALSE, TRUE); //Create a copy of the path name we've been given PathName pthOpen=pthSearch; //And call BuildMapNamesList to do all the work BuildMapNamesList(&fileOpen, &pthOpen, plstToAdd); }

void ImagemapFilter::SetFilterOptions (  ImagemapFilterOptions  ifoOptions  )

Sets ifoOptions as current within the filter. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Parameters: ifoOptions  The options to set as current within the filter [INPUTS] Returns: - Definition at line 593 of file filtimag.cpp. { //Simply copy the options into our static member variable ms_Options=ifoOptions; }

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

Checks if the user wants to export to this existing file. 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 To do this, we put up a message box with three options: Insert, Overwrite and Cancel. Reimplemented from Filter. Definition at line 487 of file filtimag.cpp. { //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_IMAGEMAP_INSERT), &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_IMAGEMAP_INSERT)); //Now set up the buttons ErrorInfo Info; Info.Button[0] = _R(IDB_IMAGEMAP_INSERT); Info.Button[1] = _R(IDB_IMAGEMAP_REPLACE); Info.Button[2] = _R(IDS_CANCEL); //Make Insert the default //and Cancel the cancel button Info.OK = 1; Info.Cancel = 3; //And put the error box up const UINT32 uResult = AskQuestion( &Info ); if( uResult == _R(IDB_IMAGEMAP_INSERT) ) ms_Options.m_fInsert=TRUE; else if( uResult == _R(IDB_IMAGEMAP_REPLACE) ) ms_Options.m_fInsert=FALSE; else if( uResult ==_R(IDS_CANCEL) ) return FALSE; return TRUE; }

void ImagemapFilter::Write (  CCLexFile *  pfileToWrite  )  [protected]

Writes out the imagemap to a file or a text buffer or both. This works as follows:. > void ImagemapFilter::Write(CCLexFile* pfileToWrite, TCHAR** ppcBuffer=NULL) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: pfileToWrite  - The file to write to [INPUTS] This may be NULL If pfileToWrite is not NULL, this function will write the imagemap to that file. If ms_Options.fClipboard is TRUE, this function will also set up a text buffer, write the imagemap to that text buffer and then copy the text buffer to the clipboard. This function calls our toolkit function WriteHelper to do most of the work. But what is actually written out? The only thing that will ever be written to the text buffer is the imagemap itself: <MAP> <AREA SHAPE=RECTANGLE ...> <AREA SHAPE=POLYGON ...> </MAP> What is written to the file depends on whether we have told that this imagemap is associated with a particular bitmap file. In other words, it depends on whether the Path To Bitmap File member variable of our ImagemapFilterOptions member variable is valid. If we have been given a bitmap file, then an entire HTML file embedding the bitmap will be written to the imagemap file: <HTML> ... </HTML> <MAP> ... </MAP> If not, only the portion between the <MAP> tags will be written. See also: ImagemapFilter::WriteHelper() Definition at line 896 of file filtimag.cpp. { //If we need to copy the imagemap to the clipboard, this variable //will point to a text buffer to store the string in. TCHAR* pBuffer=NULL; //Now, do we need to copy the imagemap to the clipboard? if (ms_Options.m_fClipboard) { //Yes. So we need to set up a text buffer. //First find out the length of this buffer by calling our helper //function with no parameters INT32 lBufferLength=WriteHelper(); //And set up a buffer of that length + length of hint line (determined by //calling WritePreamble()) - Matt 31/08/2000 if (lBufferLength>0) { lBufferLength += WritePreamble(NULL); pBuffer=new TCHAR[lBufferLength+1]; //And NULL terminate the buffer at the first character *pBuffer=0; //If we have a text buffer, then write to it if (pBuffer) { //Write to the buffer our hint... WritePreamble(pBuffer); } } } //And write the imagemap out to both the file and, if necessary, the //text buffer WriteHelper(pfileToWrite, pBuffer); //And finally, if we have a text buffer if (pBuffer) { //Copy it to the clipboard CopyToClipboard(pBuffer); //Then delete it delete pBuffer; } }

INT32 ImagemapFilter::WriteBitmapHTML (  CCLexFile *  pfileToWrite = NULL, TCHAR *  pcBuffer = NULL )  [protected]

BOOL ImagemapFilter::WriteData (   )

Writes the data in the ImagemapRenderRegion either to a file or to the clipboard, as specified in the ImagemapFilterOptions. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the export was OK FALSE if there were any errors Definition at line 424 of file filtimag.cpp. { //And this variable will keep track of errors BOOL ok=TRUE; //Now, should we be writing to a file? if (ms_Options.m_fFile) { //Yes, we should. So we should have been passed a path name //and a pointer to that file. So retrieve them. PathName pthExportFile=ms_Options.m_pthFile; CCLexFile* pfileExportFile=ms_Options.m_pfileFile; //Now, does this path name refer to an existing file? And if //it does refer to an existing file, then have we been told to insert //our imagemap into that file? if (SGLibOil::FileExists(&pthExportFile) && ms_Options.Insert()) { //Yes. So insert the data into the file ok=WriteDataToExistingFile(pfileExportFile, &pthExportFile); } else { //No, either it's a new file or we haven't been told to //insert our data into the file. So write to a new file //(and if the file does exist, it will be overwritten). ok=WriteDataToNewFile(pfileExportFile, &pthExportFile); } } else { //No. So should we be writing to the clipboard? if (ms_Options.m_fClipboard) { //Yes. So do that now. ok=WriteDataToNewFile(NULL, NULL); } } //And delete the render region if (m_pRegion) delete m_pRegion; m_pRegion=NULL; //And return return ok; }

BOOL ImagemapFilter::WriteDataToExistingFile (  CCLexFile *  pFile, PathName *  pPath )  [protected]

Writes the data in the imagemap region into an existing file and/or to the clipboard. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the export was OK FALSE if there were any errors Definition at line 1140 of file filtimag.cpp. { //Check parameters ERROR2IF (pFile==NULL || pPath==NULL, FALSE, "ImagemapFilter::WriteDataToExistingFile - null parameter"); PORTNOTETRACE("other","ImagemapFilter::WriteDataToExistingFile - Do nothing"); #ifndef EXCLUDE_FROM_XARALX //Now let's create a new Xara temporary file PathName pthTemp=FileUtil::GetTemporaryPathName(); //And open that temporary file for writing CCDiskFile fileTemp(1024, FALSE, TRUE); OpenImagemapFile(&fileTemp, &pthTemp); //Now write our existing file across to our temporary file, //parsing it as we do so, and inserting the imagemap data //in the appropriate position WriteExistingDataHelper(&fileTemp, pFile, pPath); //And close the files fileTemp.close(); //Finally, delete our existing file BOOL ok=SGLibOil::FileDelete(pPath); //Copy our temporary file across if (ok) SGLibOil::FileCopy(&pthTemp, pPath); //Then delete our temporary file if (ok) ok=SGLibOil::FileDelete(&pthTemp); //And return return ok; #endif return TRUE; }

BOOL ImagemapFilter::WriteDataToNewFile (  CCLexFile *  pFile, PathName *  pPath )  [protected]

Writes the data in the imagemap region into a new file and/or to the clipboard. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/97 Returns: TRUE if the export was OK FALSE if there were any errors matt - 25/08/2000 - added the following to ensure HTML has height and width data matt - 04/09/2000 - OK, this only works when the image is not resized during export Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); save the width and height data Temp = " width=\""; pFile << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pFile, NULL); Temp = "\""; pFile << Temp; Temp = " height=\""; pFile << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pFile, NULL); Temp = "\""; pFile << Temp; Definition at line 1195 of file filtimag.cpp. { //Have we been passed a file to write to? if (pFile!=NULL) { //Yes. So open it. if (!OpenImagemapFile(pFile, pPath)) return FALSE; } // add a header to the new file so that if a // dumb user looks at it it will show the image // this isn't in the "replace an image map" code // since that will already have an image file indicated // Note that it is valid for this function to be called with 2 NULL arguments ( exporting // to the clipboard only ). So, no use in testing for NULL arguments. // ASSERT(pPath); if( pFile != NULL ) // Only write information out to pFile if it exists. { String_256 Temp = "<img src=\"file:///"; *pFile << Temp; *pFile << ms_Options.m_GraphicPath.GetPath(); // the path and file name of the graphic Temp = "\""; *pFile << Temp; /********************************************************************************************* // matt - 25/08/2000 - added the following to ensure HTML has height and width data // matt - 04/09/2000 - OK, this only works when the image is not resized during export // Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); // use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); // save the width and height data Temp = " width=\""; *pFile << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pFile, NULL); Temp = "\""; *pFile << Temp; Temp = " height=\""; *pFile << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pFile, NULL); Temp = "\""; *pFile << Temp; **************************************************************************************************/ //Now write the remaining details Temp = " usemap=\"#"; *pFile << Temp; *pFile << ms_Options.GetImagemapName(); Temp = "\" border=\"0\">\r\n"; *pFile << Temp; } //Write the imagemap to the file and/or to the clipboard Write(pFile); //If we have been passed a file to write to if (pFile!=NULL) { //Then close it. CloseImagemapFile(pFile); } //Delete the render region delete m_pRegion; m_pRegion=NULL; return TRUE; }

BOOL ImagemapFilter::WriteExistingDataHelper (  CCLexFile *  pfileTo, CCLexFile *  pfileFrom, PathName *  ppathFrom )  [protected]

This function does most of the hard work in writing an imagemap into an existing file. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/97 Parameters: pfileTo  Ptr to the file to copy to [INPUTS] pfileFrom Ptr to the file to copy from ppathFrom Ptr to a pathname of the file to copy from Returns: TRUE if OK FALSE if there were any errors It takes the data from pfileFrom, parses it and writes it to pfileTo, but inserting the imagemap data in an appropriate place. The appropriate place is, in order of preference: 1. In place of an imagemap in pfileFrom that has the same map name as the imagemap we are writing 2. Before the </BODY> tag of pfileFrom has been written 3. After all the data from pfileFrom has been written Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); save the width and height data Temp = " width=\""; pfileTo << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; pfileTo << Temp; Temp = " height=\""; pfileTo << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; pfileTo << Temp; Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); save the width and height data Temp = " width=\""; pfileTo << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; pfileTo << Temp; Temp = " height=\""; pfileTo << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; pfileTo << Temp; Definition at line 1304 of file filtimag.cpp. { ERROR2IF(pfileTo == NULL,FALSE,"Bad params - pfileTo"); ERROR2IF(pfileFrom == NULL,FALSE,"Bad params - pfileFrom"); ERROR2IF(ppathFrom == NULL,FALSE,"Bad params - ppathFrom"); //Set up some strings which we will search for String_256 strMap("MAP"); String_256 strCloseMap("/MAP"); String_256 strName("NAME"); String_256 strCloseBody("/BODY"); String_256 strImagemapName=ms_Options.GetImagemapName(); strImagemapName.toUpper(); //First we're going to do a first pass through the file //This will determine two things: one, if the file contains an existing image map //with the same name as the one we were about to write out. If it does, //we will overwrite it //Two, if the file contains a closing </BODY> tag. If it does, and if //there is no existing image map in the file with the same name //as the one we were about to write out, we will write the imagemap //before that closing tag //Start off by assuming we're not going to overwrite an existing imagemap //and we're not going to insert the imagemap before the closing body tag BOOL fOverwriteExistingImageMap=FALSE; BOOL fInsertBeforeBodyTag=FALSE; //So open the file for reading CCDiskFile* pdiskfileFrom=(CCDiskFile*) pfileFrom; pdiskfileFrom->open(*ppathFrom, ios::in | ios::binary); //Initialise the HTML Lexer pfileFrom->InitLexer(); //And until we reach the end of the file while(!pfileFrom->IsEndOfHTMLFile()) { //Get the next HTML token in the file //This will either be a tag <xxxxxx> //or text (where text is in between tags) pfileFrom->GetHTMLToken(FALSE, FALSE); //Is that string a <MAP> tag with the same name as the //imagemap we are about to write out? if (pfileFrom->GetHTMLTagName()==strMap && pfileFrom->GetHTMLParameterValue(strName)==strImagemapName) { //Yes. So remember that we want to overwrite the //existing image map fOverwriteExistingImageMap=TRUE; } //Is that string a </BODY> tag? if (pfileFrom->GetHTMLTagName()==strCloseBody) { //Yes. So remember that we want to insert before the //closing body tag fInsertBeforeBodyTag=TRUE; } } //Finally, close the file and deinit the lexer pdiskfileFrom->close(); pfileFrom->DeinitLexer(); //Now go through the file again, and insert the imagemap in the correct place //So open the file for reading pdiskfileFrom->open(*ppathFrom, ios::in | ios::binary); //Initialise the HTML Lexer pfileFrom->InitLexer(); //And until we reach the end of the file while(!pfileFrom->IsEndOfHTMLFile()) { //Get the next HTML token in the file //This will either be a tag <xxxxxx> //or text (where text is in between tags) pfileFrom->GetHTMLToken(FALSE, FALSE); //Now, if that tag is a closing BODY tag, and we should be inserting //the imagemap before that closing body tag, and we are not replacing //an existing imagemap if (pfileFrom->GetHTMLTagName()==strCloseBody && fInsertBeforeBodyTag && !fOverwriteExistingImageMap) { //Then write out our imagemap & image details now - Matt 31/08/2000 String_256 Temp = "<img src=\"file:///"; *pfileTo << Temp; *pfileTo << ms_Options.m_GraphicPath.GetPath(); // the path and file name of the graphic Temp = "\""; *pfileTo << Temp; /***************************************************************************************************** // Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); // use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); // save the width and height data Temp = " width=\""; *pfileTo << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; *pfileTo << Temp; Temp = " height=\""; *pfileTo << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; *pfileTo << Temp; *************************************************************************************************/ //Now write the remaining details Temp = " usemap=\"#"; *pfileTo << Temp; *pfileTo << ms_Options.GetImagemapName(); Temp = "\" border=\"0\">\r\n"; *pfileTo << Temp; Write(pfileTo); } //If the tag is a MAP tag with the same //name as the map we are about to write out, and we should //be writing the imagemap in place of the existing imagemap if (pfileFrom->GetHTMLTagName()==strMap && pfileFrom->GetHTMLParameterValue(strName)==strImagemapName && fOverwriteExistingImageMap) { //Then write out our imagemap Write(pfileTo); //Now we want to carry on copying the file we are reading from, //starting from the closing </MAP> tag. So we must find that closing map //tag. //So read HTML tokens from the file until either we //find a </MAP> tag or we reach the end of the file while (pfileFrom->GetHTMLTagName()!=strCloseMap && !pfileFrom->IsEndOfHTMLFile()) { //Get the next HTML token pfileFrom->GetHTMLToken(FALSE, FALSE); } //And if we haven't reached the end of the file, get another token, //which we will write out if (!pfileFrom->IsEndOfHTMLFile()) pfileFrom->GetHTMLToken(FALSE, FALSE); } //Then get a pointer to the last HTML token we read char* pcBufferToWrite=pfileFrom->GetHTMLTokenBuffer(); //And write it out if (pcBufferToWrite) pfileTo->write(pcBufferToWrite, strlen(pcBufferToWrite)); } //Now, if we haven't inserted an imagemap before a closing body tag, //and we haven't replaced an existing image map, then we must write //out the imagemap now if (!fOverwriteExistingImageMap && !fInsertBeforeBodyTag) { //Then write out the imagemap now String_256 Temp = "<img src=\"file:///"; *pfileTo << Temp; *pfileTo << ms_Options.m_GraphicPath.GetPath(); // the path and file name of the graphic Temp = "\""; *pfileTo << Temp; /***************************************************************************************************** // Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); // use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); // save the width and height data Temp = " width=\""; *pfileTo << Temp; INT32 lToWrite = rectWinRect.right - rectWinRect.left; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; *pfileTo << Temp; Temp = " height=\""; *pfileTo << Temp; lToWrite = rectWinRect.bottom - rectWinRect.top; HTMLExportFilter::WriteNumber(lToWrite, pfileTo, NULL); Temp = "\""; *pfileTo << Temp; ******************************************************************************************************/ //Now write the remaining details Temp = " usemap=\"#"; *pfileTo << Temp; *pfileTo << ms_Options.GetImagemapName(); Temp = "\" border=\"0\">\r\n"; *pfileTo << Temp; Write(pfileTo); } //And finally close the file and deinit the lexer pdiskfileFrom->close(); pfileFrom->DeinitLexer(); return TRUE; }

INT32 ImagemapFilter::WriteHelper (  CCLexFile *  pfileToWrite = NULL, TCHAR *  pcBuffer = NULL )  [protected]

This function will be called twice:. > INT32 ImagemapFilter::WriteHelper(CCLexFile* pfileToWrite=NULL, TCHAR* pcBuffer=NULL) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: pfileToWrite  - The file to write to [INPUTS] pcBuffer - Pointer to a text buffer to write to Either of the above may be NULL. Returns: The number of TCHARs written. a. First with all parameters NULL, simply to calculate how INT32 the text buffer for the imagemap must be b. Secondly with the parameters pointing to a file, or a text buffer or both, to actually write the imagemap out. It's assumed that the text buffer is long enough for the imagemap. This function simply iterates through the list and calls on the members to write themselves out. See also: ImagemapFilter::WriteHelper() Definition at line 986 of file filtimag.cpp. { //Set up a variable to remember how many chars we have written INT32 lCharsWritten=0; //Write the imagemap HTML lCharsWritten+=WriteImagemapHTML(pfileToWrite, pcBuffer); //And return the number of characters written return lCharsWritten; }

INT32 ImagemapFilter::WriteImagemapHTML (  CCLexFile *  pfileToWrite = NULL, TCHAR *  pcBuffer = NULL )  [protected]

Writes the bitmap HTML.Writes the imagemap HTML. > INT32 ImagemapFilter::WriteImagemapHTML(CCLexFile* pfileToWrite=NULL, TCHAR* pcBuffer=NULL) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: pfileToWrite  - The file to write to [INPUTS] pcBuffer - Pointer to a text buffer to write to Either of the above may be NULL. Returns: The number of TCHARs written. See also: ImagemapFilter::WriteHelper(), ImagemapRenderRegion::Write() Definition at line 1072 of file filtimag.cpp. { //Keep a count of the characters we write out INT32 lCharsWritten=0; PORTNOTETRACE("other","ImagemapFilter::WriteImagemapHTML - Do nothing"); #ifndef EXCLUDE_FROM_XARALX //Do we have an imagemap render region member? if (m_pRegion) { //Yes. So we write out the imagemap //First write out <MAP NAME="MyMap"> lCharsWritten+=WriteStartOfTag(_R(IDS_HTMLEXPORT_MAP), pfileToWrite, pcBuffer); lCharsWritten+=WriteParameterInQuotes(_R(IDS_HTMLEXPORT_NAME), ms_Options.m_strName, pfileToWrite, pcBuffer); lCharsWritten+=WriteEndOfTag(pfileToWrite, pcBuffer); lCharsWritten+=WriteEOL(pfileToWrite,pcBuffer); //And write the imagemap itself lCharsWritten+=m_pRegion->Write(pfileToWrite, pcBuffer); //Then write out </MAP> lCharsWritten+=WriteCloseTag(_R(IDS_HTMLEXPORT_MAP), pfileToWrite, pcBuffer); //And a new line //lCharsWritten+=WriteEOL(pfileToWrite, pcBuffer); } #endif //And return the number of characters written return lCharsWritten; }

INT32 ImagemapFilter::WritePreamble (  TCHAR *  pcBuffer  )  [protected]

Helper for writing imagemaps - this function will write the 'preamble' to pcBuffer. The 'preamble' consists of the image source, dimensions, which map it is bound to, and a tag indicating the border has 0 width. Author: Priestley (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/2000 Parameters: pcBuffer  The text buffer to write to (may be NULL) [INPUTS] Returns: The number of TCHARs written to the text buffer If this function is called with pcBuffer as NULL, it will return the length of text buffer required to write the current preamble information Notes: pcBuffer is assumed to be null terminated Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); Image Width and Height... nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(" width=\"")); INT32 tempLong = rectWinRect.right - rectWinRect.left; nChars = camStrlen(pcBuffer); Format the INT32 as a string temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(temp)); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\"")); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(" height=\"")); tempLong = rectWinRect.bottom - rectWinRect.top; nChars = camStrlen(pcBuffer); Format the INT32 as a string temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(temp)); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\"")); Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); Image Width and Height... nChars += camStrlen(_T(" width=\"")); INT32 tempLong = rectWinRect.right - rectWinRect.left; Format our INT32 temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); nChars += camStrlen(temp); nChars += camStrlen(_T("\"")); nChars += camStrlen(_T(" height=\"")); tempLong = rectWinRect.bottom - rectWinRect.top; Format our INT32 temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); nChars += camStrlen(temp); nChars += camStrlen(_T("\"")); Definition at line 1624 of file filtimag.cpp. { String_256 temp; INT32 nChars = 0; temp = "<!-- HINT : The next line describes the file used for this image map. It can be deleted if you have already included this information in your HTML page. -->\r\n"; if (pcBuffer) { //Hint line for novice users nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), temp); //Image Path and filename... nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("<img src=\"file:///")); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), ms_Options.m_GraphicPath.GetPath() ); // the path and file name of the graphic nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\"")); /******************************************************************************************************************************* // Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); // use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); //Image Width and Height... nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(" width=\"")); INT32 tempLong = rectWinRect.right - rectWinRect.left; nChars = camStrlen(pcBuffer); //Format the INT32 as a string temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(temp)); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\"")); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(" height=\"")); tempLong = rectWinRect.bottom - rectWinRect.top; nChars = camStrlen(pcBuffer); //Format the INT32 as a string temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(temp)); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\"")); ************************************************************************************************************/ //Now the remaining details... nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T(" usemap=\"#")); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), ms_Options.GetImagemapName() ); nChars = camStrlen(pcBuffer); camStrcpy(pcBuffer+nChars*sizeof(TCHAR), _T("\" border=\"0\">\r\n")); nChars = camStrlen(pcBuffer); return nChars; } //Hint line for novice users nChars += camStrlen(temp); //Image Path and filename... nChars += camStrlen(_T("<img src=\"file:///")); nChars += camStrlen( ms_Options.m_GraphicPath.GetPath() ); // the path and file name of the graphic nChars += camStrlen(_T("\"")); /************************************************************************************ // Get the dimensions of the image map area DocRect rectDocRect; rectDocRect = ms_Options.GetSizeOfExportArea(ms_Options.m_stExportArea); // use the matrix to work out the pixel values of height and width Matrix Identity; WinRect rectWinRect = OSRenderRegion::BitmapDocRectToWin( Identity, rectDocRect, 96.0 ); //Image Width and Height... nChars += camStrlen(_T(" width=\"")); INT32 tempLong = rectWinRect.right - rectWinRect.left; //Format our INT32 temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); nChars += camStrlen(temp); nChars += camStrlen(_T("\"")); nChars += camStrlen(_T(" height=\"")); tempLong = rectWinRect.bottom - rectWinRect.top; //Format our INT32 temp.MakeMsg(_R(IDS_HTMLEXPORT_NUMBERFORMAT), tempLong); nChars += camStrlen(temp); nChars += camStrlen(_T("\"")); ************************************************************************************/ //Now the remaining details... nChars += camStrlen(_T(" usemap=\"#")); nChars += camStrlen( ms_Options.GetImagemapName() ); nChars += camStrlen(_T("\" border=\"0\">\r\n")); return nChars*sizeof(TCHAR); }

---

Member Data Documentation

BOOL ImagemapFilter::BackgroundRedrawState [protected]

Definition at line 222 of file filtimag.h.

BOOL ImagemapFilter::BackgroundRedrawStateSet [protected]

Definition at line 221 of file filtimag.h.

ImagemapRenderRegion* ImagemapFilter::m_pRegion [protected]

Definition at line 217 of file filtimag.h.

ImagemapFilterOptions ImagemapFilter::ms_Options = ImagemapFilterOptions() [static, protected]

Definition at line 214 of file filtimag.h.

TCHAR ImagemapFilter::ms_strAllRectangles = _T("ExportImagemap\\AllRectangles") [static, private]

Definition at line 228 of file filtimag.h.

TCHAR ImagemapFilter::ms_strApprox = _T("ExportImagemap\\CurveApproximation") [static, private]

Definition at line 227 of file filtimag.h.

TCHAR ImagemapFilter::ms_strClipboard = _T("ExportImagemap\\Clipboard") [static, private]

Definition at line 229 of file filtimag.h.

TCHAR ImagemapFilter::ms_strFile = _T("ExportImagemap\\File") [static, private]

Definition at line 230 of file filtimag.h.

TCHAR ImagemapFilter::ms_strInsert = _T("ExportImagemap\\Insert") [static, private]

Definition at line 231 of file filtimag.h.

DocView* ImagemapFilter::pView [protected]

Definition at line 220 of file filtimag.h.

---

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

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

---