//-------------------------------------------------------------------------------
//
// DoPrepare
//
// Almost identical to DoParameters. Make sure we have valid Data and Parameters
// handle(s) and lock and initialize as necessary. Sets the bufferSpace and
// maxSpace variables in the gFilterRecord so memory is used at an optimum.
//
// NOTE:
// The fields in the gFilterRecord are not all valid at this stage. We will take a
// guess at the actual tile size information.
//
//-------------------------------------------------------------------------------
void DoPrepare(void)
{
if (gFilterRecord->parameters != NULL && (*gDataHandle) != 0)
LockHandles();
else
{
if (gFilterRecord->parameters == NULL)
CreateParametersHandle();
if ((*gDataHandle) == 0)
CreateDataHandle();
if (*gResult == noErr)
{
LockHandles();
InitParameters();
InitData();
}
}
// we don't need any buffer space
gFilterRecord->bufferSpace = 0;
// give as much memory back to Photoshop as you can
// we only need a tile per plane plus the maskData
// inTileHeight and inTileWidth are invalid at this
// point. Assume the tile size is 256 max.
VRect filterRect = GetFilterRect();
int32 tileHeight = filterRect.bottom - filterRect.top;
int32 tileWidth = filterRect.right - filterRect.left;
if (tileHeight > 256)
tileHeight = 256;
if (tileWidth > 256)
tileWidth = 256;
int32 tileSize = tileHeight * tileWidth;
int32 planes = gFilterRecord->planes;
if (gFilterRecord->maskData != NULL)
planes++;
// duplicate because we have two copies, inData and outData
planes *= 2;
int32 totalSize = tileSize * planes;
// this is worst case and can be dropped considerably
if (gFilterRecord->maxSpace > totalSize)
gFilterRecord->maxSpace = totalSize;
}
//-------------------------------------------------------------------------------
//
// DoParameters
//
// Makes sure we have valid Data and Parameters handle(s). Locks and initializes
// these items.
//
// NOTE:
// This routine is NOT guaranteed to be called by Photoshop. If a user enters the
// CTRL-F keyboard shortcut to invoke the last filter command this routine will
// NOT be called. If the filter is ran by the actions pallete or an automation
// plug in this routine will NOT be called.
//
// NOTE:
// The fields in the gFilterRecord are not all valid at this stage.
//-------------------------------------------------------------------------------
void DoParameters(void)
{
if (gFilterRecord->parameters == NULL)
CreateParametersHandle();
if ((*gDataHandle) == 0)
CreateDataHandle();
if (*gResult == noErr)
{
LockHandles();
InitParameters();
InitData();
}
}
//-------------------------------------------------------------------------------
//
// DoStart
//
// The main filtering routine for this plug in. See if we have any registry
// parameters from the last time we ran. Determine if the UI needs to be
// displayed by reading the script parameters. Save the last dialog parameters
// in case something goes wrong or the user cancels.
//
//-------------------------------------------------------------------------------
void DoStart(void)
{
LockHandles();
// see if we have any information in the Photoshop registry
ReadRegistryParameters();
// save parameters
int16 lastDisposition = gParams->disposition;
int16 lastPercent = gParams->percent;
Boolean lastIgnoreSelection = gParams->ignoreSelection;
// does the user want a dialog
Boolean isOK = true;
Boolean displayDialog;
OSErr err = ReadScriptParameters(&displayDialog);
err; // turn off compiler warning for now
// run the dialog on the specific OS
if (!err && displayDialog)
isOK = DoUI();
// we know we have enough information to run without next time
gData->queryForParameters = false;
if (isOK)
{
// the main processing routine
DoFilter();
}
else
{
// restore if the user hit cancel
gParams->disposition = lastDisposition;
gParams->percent = lastPercent;
gParams->ignoreSelection = lastIgnoreSelection;
*gResult = userCanceledErr;
}
}
NTSTATUS NTAPI
AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
NTSTATUS Status = STATUS_NO_MEMORY;
PAFD_FCB FCB;
PFILE_OBJECT FileObject;
PAFD_POLL_INFO PollReq = Irp->AssociatedIrp.SystemBuffer;
PAFD_DEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
KIRQL OldIrql;
UINT i, Signalled = 0;
ULONG Exclusive = PollReq->Exclusive;
UNREFERENCED_PARAMETER(IrpSp);
AFD_DbgPrint(MID_TRACE,("Called (HandleCount %u Timeout %d)\n",
PollReq->HandleCount,
(INT)(PollReq->Timeout.QuadPart)));
SET_AFD_HANDLES(PollReq,
LockHandles( PollReq->Handles, PollReq->HandleCount ));
if( !AFD_HANDLES(PollReq) ) {
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
return STATUS_NO_MEMORY;
}
if( Exclusive ) {
for( i = 0; i < PollReq->HandleCount; i++ ) {
if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
KillSelectsForFCB( DeviceExt,
(PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle,
TRUE );
}
}
KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
for( i = 0; i < PollReq->HandleCount; i++ ) {
if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
FCB = FileObject->FsContext;
AFD_DbgPrint(MID_TRACE, ("AFD: Select Events: "));
PrintEvents( PollReq->Handles[i].Events );
AFD_DbgPrint(MID_TRACE,("\n"));
PollReq->Handles[i].Status =
PollReq->Handles[i].Events & FCB->PollState;
if( PollReq->Handles[i].Status ) {
AFD_DbgPrint(MID_TRACE,("Signalling %p with %x\n",
FCB, FCB->PollState));
Signalled++;
}
}
if( Signalled ) {
Status = STATUS_SUCCESS;
Irp->IoStatus.Status = Status;
SignalSocket( NULL, Irp, PollReq, Status );
} else {
PAFD_ACTIVE_POLL Poll = NULL;
Poll = ExAllocatePool( NonPagedPool, sizeof(AFD_ACTIVE_POLL) );
if (Poll){
Poll->Irp = Irp;
Poll->DeviceExt = DeviceExt;
Poll->Exclusive = Exclusive;
KeInitializeTimerEx( &Poll->Timer, NotificationTimer );
KeInitializeDpc( (PRKDPC)&Poll->TimeoutDpc, SelectTimeout, Poll );
InsertTailList( &DeviceExt->Polls, &Poll->ListEntry );
KeSetTimer( &Poll->Timer, PollReq->Timeout, &Poll->TimeoutDpc );
Status = STATUS_PENDING;
IoMarkIrpPending( Irp );
(void)IoSetCancelRoutine(Irp, AfdCancelHandler);
} else {
AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
Status = STATUS_NO_MEMORY;
}
}
KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
return Status;
}
//-------------------------------------------------------------------------------
//
// DoFinish
//
// Everything went as planned and the pixels have been modified. Now record
// scripting parameters and put our information in the Photoshop Registry for the
// next time we get called. The Registry saves us from keeping a preferences file.
//
//-------------------------------------------------------------------------------
void DoFinish(void)
{
LockHandles();
WriteScriptParameters();
WriteRegistryParameters();
}
