inline void Finish() {
try {
Flush();
} catch (...) {
try {
DoFinish();
} catch (...) {
}
throw;
}
DoFinish();
}
//-------------------------------------------------------------------------------
//
// PluginMain
//
// All calls to the plug in module come through this routine.
//
// Inputs:
// const int16 selector Host provides selector indicating what
// command to do.
//
// Inputs and Outputs:
// FilterRecord *filterRecord Host provides a pointer to parameter block
// containing pertinent data and callbacks.
// See PIFilter.h
//
// intptr_t *data Use this to store a handle or pointer to our global
// data structure, which is maintained by the
// host between calls to the plug in.
//
// Outputs:
// int16 *result Returns error result. Some errors are handled
// by the host, some are silent, and some you
// must handle. See PIGeneral.h.
//
//-------------------------------------------------------------------------------
DLLExport MACPASCAL void PluginMain(const int16 selector,
FilterRecordPtr filterRecord,
intptr_t * data,
int16 * result)
{
// update our global parameters
gFilterRecord = filterRecord;
gDataHandle = data;
gResult = result;
if (selector == filterSelectorAbout)
{
sSPBasic = ((AboutRecord*)gFilterRecord)->sSPBasic;
}
else
{
sSPBasic = gFilterRecord->sSPBasic;
if (gFilterRecord->bigDocumentData != NULL)
gFilterRecord->bigDocumentData->PluginUsing32BitCoordinates = true;
}
// do the command according to the selector
switch (selector)
{
case filterSelectorAbout:
DoAbout();
break;
case filterSelectorParameters:
DoParameters();
break;
case filterSelectorPrepare:
DoPrepare();
break;
case filterSelectorStart:
DoStart();
break;
case filterSelectorContinue:
DoContinue();
break;
case filterSelectorFinish:
DoFinish();
break;
default:
break;
}
// unlock our handles used by gData and gParams
if (selector != filterSelectorAbout)
UnlockHandles();
}
DLLExport SPAPI void PluginMain(const int16 selector,
FilterRecordPtr filterRecord,
intptr_t * data,
int16 * result)
{
gData = data;
gResult = result;
if (selector == filterSelectorAbout)
{
sSPBasic = ((AboutRecordPtr)filterRecord)->sSPBasic;
}
else
{
gFilterRecord = filterRecord;
sSPBasic = gFilterRecord->sSPBasic;
if (gFilterRecord->bigDocumentData != NULL)
gFilterRecord->bigDocumentData->PluginUsing32BitCoordinates = true;
}
switch (selector)
{
case filterSelectorAbout:
DoAbout();
break;
case filterSelectorParameters:
DoParameters();
break;
case filterSelectorPrepare:
DoPrepare();
break;
case filterSelectorStart:
DoStart();
break;
case filterSelectorContinue:
DoContinue();
break;
case filterSelectorFinish:
DoFinish();
break;
default:
*gResult = filterBadParameters;
break;
}
}
DLLExport MACPASCAL void PluginMain (const int16 selector,
FilterRecordPtr filterParamBlock,
intptr_t *data,
int16 *result)
{
//---------------------------------------------------------------------------
// (1) Check for about box request.
//
// The about box is a special request; the parameter block is not filled
// out, none of the callbacks or standard data is available. Instead,
// the parameter block points to an AboutRecord, which is used
// on Windows.
//---------------------------------------------------------------------------
if (selector == filterSelectorAbout)
{
sSPBasic = ((AboutRecordPtr)filterParamBlock)->sSPBasic;
DoAbout((AboutRecordPtr)filterParamBlock);
}
else
{ // do the rest of the process as normal:
sSPBasic = ((FilterRecordPtr)filterParamBlock)->sSPBasic;
Ptr globalPtr = NULL; // Pointer for global structure
GPtr globals = NULL; // actual globals
//-----------------------------------------------------------------------
// (2) Allocate and initalize globals.
//
// AllocateGlobals requires the pointer to result, the pointer to the
// parameter block, a pointer to the handle procs, the size of our local
// "Globals" structure, a pointer to the long *data, a Function
// Proc (FProcP) to the InitGlobals routine. It automatically sets-up,
// initializes the globals (if necessary), results result to 0, and
// returns with a valid pointer to the locked globals handle or NULL.
//-----------------------------------------------------------------------
globalPtr = AllocateGlobals (result,
filterParamBlock,
filterParamBlock->handleProcs,
sizeof(Globals),
data,
InitGlobals);
if (globalPtr == NULL)
{ // Something bad happened if we couldn't allocate our pointer.
// Fortunately, everything's already been cleaned up,
// so all we have to do is report an error.
*result = memFullErr;
return;
}
// Get our "globals" variable assigned as a Global Pointer struct with the
// data we've returned:
globals = (GPtr)globalPtr;
//-----------------------------------------------------------------------
// (3) Dispatch selector.
//-----------------------------------------------------------------------
switch (selector)
{
case filterSelectorParameters:
DoParameters(globals);
break;
case filterSelectorPrepare:
DoPrepare(globals);
break;
case filterSelectorStart:
DoStart(globals);
break;
case filterSelectorContinue:
DoContinue(globals);
break;
case filterSelectorFinish:
DoFinish(globals);
break;
}
//-----------------------------------------------------------------------
// (4) Unlock data, and exit resource.
//
// Result is automatically returned in *result, which is
// pointed to by gResult.
//-----------------------------------------------------------------------
// unlock handle pointing to parameter block and data so it can move
// if memory gets shuffled:
if (*data != 0 /* NULL */ )
PIUnlockHandle((Handle)*data);
} // about selector special
} // end PluginMain
void Finish() { if (!m_Finished) { DoFinish(); m_Finished = true; } }