zOPER_EXPORT zSHORT OPERATION
zwTZVSDBAD_SpawnObjectBrowser( zVIEW vSubtask )
{
zVIEW StackObject;
zVIEW lpZeidonVML;
zVIEW v;
zLONG lDataLth;
zSHORT nZRetCode;
nZRetCode = GetViewByName( &lpZeidonVML, "ZeidonVML", vSubtask, zLEVEL_TASK );
nZRetCode = GetViewByName( &StackObject, "StackObject", lpZeidonVML, zLEVEL_SUBTASK );
lDataLth = 4;
GetBlobFromAttribute( &v, &lDataLth,
StackObject, "Variable", "Value" );
if ( v != 0 )
{
nZRetCode = StageBrowser( vSubtask, v );
}
if ( nZRetCode == -1 )
{
MessageSend( vSubtask, "VS00201", "Launcher",
"View is not yet valid",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
}
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// ENTRY:
//
// PURPOSE: Set the VKey Ctrl/Alt/Shift check boxes
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
PostBSetVKey( zVIEW vSubtask )
{
zULONG ulLth = sizeof( zACCEL_DEF );
zVIEW vHotkey;
zACCEL_DEF ac;
GetViewByName( &vHotkey, "KZHKEYSO", vSubtask, zLEVEL_ANY );
if ( vHotkey &&
CheckExistenceOfEntity( vHotkey, "Hotkey" ) > zCURSOR_UNCHANGED )
{
GetBlobFromAttribute( &ac, &ulLth, vHotkey, "Hotkey", "KeyCombo" );
SetCtrlState( vSubtask, "Ctrl", zCONTROL_STATUS_CHECKED, ac.fCtrl );
SetCtrlState( vSubtask, "Alt", zCONTROL_STATUS_CHECKED, ac.fAlt );
SetCtrlState( vSubtask, "Shift", zCONTROL_STATUS_CHECKED, ac.fShift );
// if ( CheckExistenceOfEntity( vHotkey, "Operation" ) > zCURSOR_UNCHANGED )
// {
// zPCHAR pch;
//
// GetAddrForAttribute( &pch, vHotkey, "Operation", "DLL_Name" );
// SetCtrlText( vSubtask, "DLL_Name", pch );
// }
}
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// CONSTRUCTOR: Tab/Notebook control
//
/////////////////////////////////////////////////////////////////////////////
// ctor
TZNoteBook::TZNoteBook( TZPainterWindow *pPainterWindow,
TZPainterCtrl *pCtrlParent,
CWnd *pWndParent,
CRect& rect,
zVIEW vCtrl,
zLONG lType,
zBOOL bPlaceHolder,
zLONG lZKey,
zLONG lTabStopNbr,
zLONG lCtrlID,
zPCHAR pchTag,
zPCHAR pchText ) :
CTabCtrl( ),
TZPainterCtrl( pPainterWindow, pCtrlParent, pWndParent,
rect, vCtrl, this, pchTag, pchText,
lType, bPlaceHolder, lZKey, lTabStopNbr, lCtrlID )
{
#ifdef DEBUG_ALL
TraceLineS( "TZNoteBook::ctor ", m_csTag );
#endif
zLONG lTabsPerRow = 0;
m_bDeletable = TRUE; // mark it as deletable
m_bInitialized = FALSE;
m_pZNotePage = 0;
m_nPageCnt = 0;
m_nTabNbrMax = 1;
Attr.Style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
if ( vCtrl )
{
OrderEntityForView( vCtrl, szlCtrlCtrl, "Type A" );
zCHAR szBlob[ 5 * sizeof( zLONG ) ];
zULONG ulLth = zsizeof( szBlob );
GetBlobFromAttribute( szBlob, &ulLth, vCtrl, "Control", "CtrlBOI" );
// TraceLineI( "TZNoteBook ctor Blob Lth = ", ulLth );
if ( ulLth >= 3 * sizeof( zLONG ) )
{
lTabsPerRow = *((zPLONG) (szBlob + sizeof( zLONG ) * 2));
}
}
// if ( lTabsPerRow )
// Attr.Style |= TCS_MULTILINE,
CreateZ( );
ShowWindow( SW_SHOW );
#if 0
CRect r;
r.top = GetClientTop( );
r.left = GetClientLeft( );
r.right = r.left + GetClientWidth( );
r.bottom = r.top + GetClientHeight( );
TraceRect( "TZNoteBook ctor Client Rect:", r );
#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 );
}
/////////////////////////////////////////////////////////////////////////////
//
// 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
}
/*************************************************************************************************
**
** OPERATION: SetRptShapeFromBlob
**
*************************************************************************************************/
zOPER_EXPORT zLONG /*GLOBAL */ OPERATION
SetRptShapeFromBlob( zVIEW vReportDef )
{
zCHAR szBlob[ 8 + (6 * sizeof( zLONG )) ];
// zVIEW vReport;
// zLONG lSubtype;
zULONG ulPenColor = 0xFF000000;
zULONG ulShapeColor = 0xFF000000;
zULONG ulLth = sizeof( szBlob );
zmemset( szBlob, 0, ulLth );
GetBlobFromAttribute( szBlob, &ulLth, vReportDef, "Control", "CtrlBOI" );
// TraceLineI( "Shape control blob lth = ", ulLth );
if ( ulLth == sizeof( szBlob ) ||
ulLth == sizeof( szBlob ) - (1 * sizeof( zLONG )) || // remove this soon
ulLth == sizeof( szBlob ) - (2 * sizeof( zLONG )) )
{
zLONG lPenWidth;
zLONG lPenType;
zLONG lRoundValue;
zLONG lFlags = 0;
if ( szBlob[ 4 ] == TRUE )
{
TraceLineI( "**** Horizontal Line **** ", szBlob[ 4 ] );
SetAttributeFromInteger( vReportDef, "Control", "BorderBottom", szBlob[ 4 ] );
}
/*
SetCtrlState( vSubtask, "Rectangle", zCONTROL_STATUS_CHECKED,
szBlob[ 0 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "RoundRect", zCONTROL_STATUS_CHECKED,
szBlob[ 1 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "Ellipse", zCONTROL_STATUS_CHECKED,
szBlob[ 2 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "Diamond", zCONTROL_STATUS_CHECKED,
szBlob[ 3 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "HorizontalLine", zCONTROL_STATUS_CHECKED,
szBlob[ 4 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "VerticalLine", zCONTROL_STATUS_CHECKED,
szBlob[ 5 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "DiagonalDescend", zCONTROL_STATUS_CHECKED,
szBlob[ 6 ] ? TRUE : FALSE );
SetCtrlState( vSubtask, "DiagonalAscend", zCONTROL_STATUS_CHECKED,
szBlob[ 7 ] ? TRUE : FALSE );
*/
lPenWidth = *((zPLONG) (szBlob + 8));
lPenType = *((zPLONG) (szBlob + 8 + sizeof( zLONG )));
ulPenColor = *((zPLONG) (szBlob + 8 + (2 * sizeof( zLONG ))));
lRoundValue = *((zPLONG) (szBlob + 8 + (3 * sizeof( zLONG ))));
if ( ulLth == sizeof( szBlob ) )
{
ulShapeColor = *((zPULONG) (szBlob + 8 + (4 * sizeof( zLONG ))));
lFlags = *((zPLONG) (szBlob + 8 + (5 * sizeof( zLONG ))));
}
zltoa( ulPenColor, szBlob );
SetAttributeFromString( vReportDef, "Control", "wLineColorText", szBlob );
SetAttributeFromInteger( vReportDef, "Control", "wLineColorInt", ulPenColor );
SetAttributeFromInteger( vReportDef, "Control", "BorderWidth", lPenWidth );
switch ( lPenType )
{
case 1:
SetAttributeFromInteger( vReportDef, "Control", "BorderStyle", 1 );
break;
case 2:
SetAttributeFromInteger( vReportDef, "Control", "BorderStyle", 2 );
break;
case 3:
SetAttributeFromInteger( vReportDef, "Control", "BorderStyle", 3 );
break;
case 4:
SetAttributeFromInteger( vReportDef, "Control", "BorderStyle", 4 );
break;
default:
SetAttributeFromInteger( vReportDef, "Control", "BorderStyle", 0 );
break;
}
zltoa( lRoundValue, szBlob );
//SetCtrlText( vSubtask, "RoundValue", szBlob );
}
else
{
//SetCtrlState( vSubtask, "Rectangle", zCONTROL_STATUS_CHECKED, TRUE );
//SetCtrlText( vSubtask, "PenWidth", "1" );
}
/*
SetCtrlProperty( vSubtask, "__ColorLine",
zCONTROL_PROPERTY_INTEGER_DATA,
ulPenColor, 0 );
SetCtrlProperty( vSubtask, "__ColorShape",
zCONTROL_PROPERTY_INTEGER_DATA,
ulShapeColor, 0 );
*/
return( 0 );
} // SetRptShapeFromBlob