///////////////////////////////////////////////////////////////////////////// // // 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 ); }