/////////////////////////////////////////////////////////////////////////////
//
// ENTRY:
//
// PURPOSE: Save the VKey Ctrl/Alt/Shift based on the check box settings
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
SaveVKey( zVIEW vSubtask )
{
zVIEW vHotkey;
zACCEL_DEF ac;
zLONG lVKey;
zmemset( &ac, 0, sizeof( zACCEL_DEF ) );
GetViewByName( &vHotkey, "KZHKEYSO", vSubtask, zLEVEL_ANY );
GetIntegerFromAttribute( &lVKey, vHotkey, "Hotkey", "VKey" );
ac.uVK = (zUSHORT) lVKey;
ac.fCtrl = (zUSHORT) GetCtrlState( vSubtask, "Ctrl",
zCONTROL_STATUS_CHECKED );
ac.fAlt = (zUSHORT) GetCtrlState( vSubtask, "Alt",
zCONTROL_STATUS_CHECKED );
ac.fShift = (zUSHORT) GetCtrlState( vSubtask, "Shift",
zCONTROL_STATUS_CHECKED );
SetAttributeFromBlob( vHotkey, "Hotkey", "KeyCombo",
&ac, sizeof( zACCEL_DEF ) );
// if ( CheckExistenceOfEntity( vHotkey, "Operation" ) > zCURSOR_UNCHANGED )
// {
// zCHAR szText[ 64 ];
//
// GetCtrlText( vSubtask, "DLL_Name", szText, sizeof( szText ) );
// SetAttributeFromString( vHotkey, "Operation", "DLL_Name", 0 );
// }
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: fnPushMsgQ_State
//
// PURPOSE: This routine sets the state of the message queue object
// and pushes the state on the stack. The stack is organized
// as follows:
//
// zLONG lCurrentState;
// zSHORT nEntryCnt;
// zSHORT nEntryMax;
// zLONG lState[ 1 ];
// zLONG lState[ 2 ];
// .
// .
// .
//
// zLONG lState[ n ]; // same as lCurrentState
//
/////////////////////////////////////////////////////////////////////////////
void
fnPushMsgQ_State( zVIEW vMsgQ,
zLONG lState )
{
zPCHAR pStack; // blob containing Status Stack
zUSHORT uCnt;
zUSHORT uMax;
#ifdef zREMOTE_SERVER
// Protect this with a semaphore!!!
SysMutexLock( vSubtask, "ZDm", 0, 0 );
// TraceLineS( "PushMsgQ_State Lock Mutex ZDm", "" );
// DisplayObjectInstance( vMsgQ, 0, 0 );
// ::MessageBox( 0, "PushMsgQ", "ZDr", MB_OK );
#endif
GetAddrForAttribute( (zPCHAR *) &pStack, vMsgQ, szlTask, szlStatus );
if ( pStack )
{
uCnt = *((zPSHORT) (pStack + sizeof( zLONG )));
uMax = *((zPSHORT) (pStack + sizeof( zLONG ) + sizeof( zSHORT )));
// If there is no more room on the stack ... make more room.
if ( uCnt >= uMax )
{
zULONG ulBlobLth;
zULONG ulLth;
uMax += 10;
ulLth = sizeof( zLONG ) + 2 * sizeof( zSHORT ) + uMax * sizeof( zLONG );
ulBlobLth = ulLth;
zPCHAR pch = new char[ ulLth ];
GetBlobFromAttribute( pch, &ulBlobLth, vMsgQ, szlTask, szlStatus );
if ( ulLth != ulBlobLth + 10 * sizeof( zLONG ) )
OperatorSend( 0, szlDrvr, "PushMsgQ_State", TRUE );
else
TraceLineI( "Message queue stack expanded to ", ulLth );
SetAttributeFromBlob( vMsgQ, szlTask, szlStatus, pch, ulLth );
GetAddrForAttribute( (zPCHAR *) &pStack, vMsgQ, szlTask, szlStatus );
*((zPSHORT) (pStack + sizeof( zLONG ) + sizeof( zSHORT ))) = uMax;
delete [] pch;
}
(*((zPSHORT) (pStack + sizeof( zLONG ))))++; // increment EntryCnt
*((zPLONG) pStack) = lState; // set CurrentState
*((zPLONG) (pStack + sizeof( zLONG ) + // set State[ n ]
2 * sizeof( zSHORT ) +
uCnt * sizeof( zLONG ))) = lState; // (not incrementing
// uCnt since not
// used hereafter)
}
else
{
TraceLineS( "PushMsgQ_State Lock Mutex ZDm: ", "NULL Status?" );
DisplayObjectInstance( vMsgQ, 0, 0 );
::MessageBox( 0, "PushMsgQ_State NULL Status?", "ZDr Error", MB_OK );
}
#ifdef zREMOTE_SERVER
// TraceLineS( "PushMsgQ_State Unlock Mutex ZDm", "" );
SysMutexUnlock( vSubtask, "ZDm", 0 );
#endif
}
/////////////////////////////////////////////////////////////////////////////
//
// ENTRY:
//
// PURPOSE: Save the HK object(both Source & Executable???)
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
zwTZHKEYAD_SaveHK_ForLPLR( zVIEW vSubtask )
{
zPCHAR lpGlobalHotkey;
zUSHORT usGlobalHotkeyLth;
LPACCEL_TABLE lpAT;
LPACCEL_TABLE lpAT_Start;
zCHAR szFileSpec[ zMAX_FILESPEC_LTH + 1 ];
zVIEW vKZHKEYSO;
zVIEW vKZHKEYXO;
zVIEW vTaskLPLR;
zULONG ulMaxLth;
zSHORT nRC;
GetViewByName( &vKZHKEYSO, "KZHKEYSO", vSubtask, zLEVEL_ANY );
// Get the directory.
GetViewByName( &vTaskLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK );
if ( vTaskLPLR == 0 )
{
MessageSend( vSubtask, "HK00102", "Hot Keys",
"Can't locate LPLR?",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( 0 );
}
GetStringFromAttribute( szFileSpec, vTaskLPLR, "LPLR", "MetaSrcDir" );
zstrcat( szFileSpec, "\\ZEIDON.PHK" );
MiSetOI_ReleaseForView( vKZHKEYSO, szlReleaseCurrent );
CommitOI_ToFile( vKZHKEYSO, szFileSpec, zASCII | zENCODE_BLOBS | zNO_NULL_STRING_TERM );
SfAllocTaskMemory( vSubtask, (zCOREMEM) &lpGlobalHotkey, 65000 );
lpAT = (LPACCEL_TABLE) SfLockTaskMemory( lpGlobalHotkey );
lpAT_Start = lpAT;
usGlobalHotkeyLth = 0;
SfActivateSysEmptyOI( &vKZHKEYXO, "KZHKEYXO", vSubtask,
zSINGLE | zLEVEL_APPLICATION );
CreateEntity( vKZHKEYXO, "App", zPOS_AFTER );
nRC = SetEntityCursor( vKZHKEYSO, "Hotkey", 0, zPOS_FIRST,
0, 0, 0, 0, 0, 0 );
while ( nRC >= 0 )
{
CreateEntity( vKZHKEYXO, "Hotkey", zPOS_AFTER );
SetMatchingAttributesByName( vKZHKEYXO, "Hotkey",
vKZHKEYSO, "Hotkey", zSET_ALL );
SetAttributeFromAttribute( vKZHKEYXO, "Hotkey", "COP",
vKZHKEYSO, "Operation", "Name" );
SetAttributeFromAttribute( vKZHKEYXO, "Hotkey", "DLL",
vKZHKEYSO, "Hotkey", "DLL_Name" );
lpAT->chType = zACCEL_HOTKEY;
ulMaxLth = sizeof( zACCEL_DEF );
GetBlobFromAttribute( &(lpAT->ac), &ulMaxLth,
vKZHKEYSO, "Hotkey", "KeyCombo" );
lpAT->nID = (zSHORT) GetRelativeEntityNumber( vKZHKEYSO,
"Hotkey", 0, 0L );
usGlobalHotkeyLth += sizeof( zACCEL_TABLE );
lpAT++;
nRC = SetCursorNextEntity( vKZHKEYSO, "Hotkey", 0 );
}
zmemset( lpAT, 0xFF, sizeof( zACCEL_TABLE ) ); // terminator
usGlobalHotkeyLth += sizeof( zACCEL_TABLE );
lpAT = lpAT_Start;
SetAttributeFromBlob( vKZHKEYXO, "App", "Hotkey",
lpAT, usGlobalHotkeyLth );
SfUnlockTaskMemory( lpAT );
SfFreeTaskMemory( lpGlobalHotkey );
GetStringFromAttribute( szFileSpec, vTaskLPLR, "LPLR", "ExecDir" );
zstrcat( szFileSpec, "\\ZEIDON.XKY" );
CommitOI_ToFile( vKZHKEYXO, szFileSpec, zASCII );
return( 0 );
}
zOPER_EXPORT zLONG OPERATION
InvokeInterp( zVIEW lpInterpSubtask, // Interpretor's subtask
zVIEW lpAppSubtask, // application's subtask
zPCHAR szSrcDLLName, // name of the dialog
zPCHAR szOperationName, // operation to interp
zPLONG plRC )
{
zVIEW vXChecker;
zSHORT nRC;
zLONG lStepRC;
zVIEW vStackObject; // view to the stack object
zVIEW vS_View;
zVIEW vZ_View;
zVIEW vSO;
zVIEW vSubtask = 0;
zVIEW vTaskLPLR;
zPVOID hWRKS = NULL;
// Check to make sure the LPLR is active.
GetViewByName( &vTaskLPLR, "TaskLPLR", lpAppSubtask, zLEVEL_TASK );
if ( vTaskLPLR == 0 )
InitializeLPLR( lpInterpSubtask, "" );
aInterpreterSave[ lMultiple ].vSubtask = lpInterpSubtask;
if ( lMultiple > 0 )
{
if ( lMultiple >= MAX_INTEPRETER_ENTRY )
{
// Error, because number of recursive entries
// is greater than MAX_INTEPRETER_ENTRY
return( -99 );
}
vSubtask = aInterpreterSave[ lMultiple -1 ].vSubtask;
// save the global variables
aInterpreterSave[ lMultiple -1 ].nStackPtr = g_nStackPtr;
g_nStackPtr = 0;
memcpy( aInterpreterSave[ lMultiple -1 ].nCallStack,
g_nCallStack, zsizeof( g_nCallStack ) );
memset( g_nCallStack, 0, zsizeof( g_nCallStack ) );
aInterpreterSave[ lMultiple -1 ].vXPGView = g_vXPGView;
g_vXPGView = 0;
GetViewByName( &g_vStatementView, "StatementView",
vSubtask, zLEVEL_SUBTASK );
aInterpreterSave[ lMultiple -1 ].vStatementView = g_vStatementView;
g_vStatementView = 0;
GetViewByName( &vSO, "StackObject",
vSubtask, zLEVEL_SUBTASK );
aInterpreterSave[ lMultiple -1 ].vStackObject = vSO;
memcpy( aInterpreterSave[ lMultiple -1 ].sValueStack,
sValueStack, zsizeof( sValueStack ) );
memset( sValueStack, 0, zsizeof( sValueStack ) );
}
lMultiple++;
// see if we can load the XPG. if not, don't parse for now, exit out
nRC = InitInterp( lpInterpSubtask, lpAppSubtask, szSrcDLLName );
if ( nRC < 0 )
{
lStepRC = 1; // if the init failed return.
goto EndOfInvokeInterp;
}
// Initialize the Working Storage Manager
if ( WRKS_Init( &hWRKS ) < 0 )
{
// Error in WRKS system
MessageSend( vSubtask, "VM03002", "VML Interpretor",
"Error Initializing Work Storage",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
TraceLineS( "VML Interpreter Error ","Initializing Work Storage" );
lStepRC = 1; // if the init failed return.
goto EndOfInvokeInterp;
}
if ( setjmp( g_jbWRKS ) != 0 )
{
// Error return from longjmp
WRKS_Close( &hWRKS );
lStepRC = 1;
goto EndOfInvokeInterp;
}
// get the program object as it was loaded by the init function.
GetViewByName( &g_vXPGView, "XPG", lpInterpSubtask, zLEVEL_SUBTASK );
// try to position at the correct operation in the Subtask
nRC = SetCursorFirstEntityByString( g_vXPGView, "Operation",
"Name", szOperationName, "" );
if ( nRC != zCURSOR_SET )
{
// no error message here, as we assume that the operation
// to be called is a C operation.
// Returning -1, the driver will try to load it from the DLL
lStepRC = -1;
goto EndOfInvokeInterp;
}
SetCursorFirstEntityByEntityCsr( g_vXPGView,
"SourceFile",
g_vXPGView,
"SourceFileOfOperation", "" );
SetCursorFirstEntityByEntityCsr( g_vXPGView,
"OperationSource",
g_vXPGView,
"Operation", "" );
SetCursorFirstEntity( g_vXPGView, "OperationText", "" );
SetCursorFirstEntity( g_vXPGView, "Statement", "" );
CreateViewFromViewForTask( &g_vStatementView, g_vXPGView, 0 );
// Create all of the entities needed in the stack object
SetStackObjectFromViews( lpInterpSubtask,
g_vXPGView, // View to the XPG
g_vStatementView, // View to the statement
0 ); // index into the expression
// Get the stack object as it was loaded with the XPG
GetViewByName( &vStackObject,
"StackObject",
lpInterpSubtask,
zLEVEL_SUBTASK );
// ###blob SetAttributeFromInteger( vStackObject,
// "Variable", "Value", (zLONG)lpAppSubtask );
SetAttributeFromBlob( vStackObject, "Variable", "Value", &lpAppSubtask, sizeof( void * ) );
SetNameForView( g_vStatementView, "StatementView", lpInterpSubtask, zLEVEL_SUBTASK );
SetNameForView( lpAppSubtask, "ApplicationView", lpInterpSubtask, zLEVEL_SUBTASK );
GetViewByName( &vXChecker, "TZVSXCOO", lpInterpSubtask, zLEVEL_APPLICATION );
if ( vXChecker != 0 )
{
nRC = SetCursorFirstEntityByString( vXChecker, "DialogOperation", "Name", szOperationName, "" );
if ( nRC == zCURSOR_SET )
{
GetViewByName( &vZ_View, "ZeidonVML", vSubtask, zLEVEL_TASK );
GetViewByName( &vS_View, "XPG", vZ_View, zLEVEL_SUBTASK );
SetAttributeFromString( vS_View, "Operation", "CurrentDebugFlag", "Y" );
lStepRC = zXC_SETUP_DEBUGGER;
goto EndOfInvokeInterp;
}
}
// lStepRC = zXC_STEP_EXECUTED;
#if 0
OperationCount( 3 );
OperationCount( 1 );
#endif
// Loop through each statement using the Go function.
lStepRC = Go( lpAppSubtask, hWRKS, plRC );
EndOfInvokeInterp:
// close work storage manager
if ( hWRKS )
WRKS_Close( &hWRKS );
lMultiple--;
if ( lMultiple > 0 )
{
vSubtask = aInterpreterSave[ lMultiple - 1 ].vSubtask;
// restore the global variables
g_nStackPtr = aInterpreterSave[ lMultiple - 1 ].nStackPtr;
memcpy( g_nCallStack, aInterpreterSave[ lMultiple -1 ].nCallStack, zsizeof( g_nCallStack ) );
g_vXPGView = aInterpreterSave[ lMultiple - 1 ].vXPGView;
SetNameForView( g_vXPGView, "XPG", vSubtask, zLEVEL_SUBTASK );
g_vStatementView = aInterpreterSave[ lMultiple - 1 ].vStatementView;
SetNameForView( g_vStatementView, "StatementView", vSubtask, zLEVEL_SUBTASK );
vSO = aInterpreterSave[ lMultiple - 1 ].vStackObject;
SetNameForView( vSO, "StackObject", vSubtask, zLEVEL_SUBTASK );
memcpy( sValueStack, aInterpreterSave[ lMultiple - 1 ].sValueStack, zsizeof( sValueStack ) );
}
return( lStepRC );
}
