zOPER_EXPORT zSHORT OPERATION
PrebuildLogin( zVIEW vSubtask )
{
zVIEW vAccount;
zSHORT nRC;
nRC = ActivateOI_FromFile( &vAccount, "ACCOUNT", vSubtask,
"CARLSON.PSV", zMULTIPLE );
SetNameForView( vAccount, "ACCOUNTLST", vSubtask, zLEVEL_TASK );
nRC = ActivateOI_FromFile( &vAccount, "ACCOUNT", vSubtask,
"CARLSON.POR", zMULTIPLE );
SetNameForView( vAccount, "ACCOUNT", vSubtask, zLEVEL_TASK );
return( 0 );
}
//
// OPERATION: InitializeInterpretor
//
// DESCRIPTION: InitializeInterpretor does all of the set up for the VML
// interpretor. Loads the XPG File. Next be sure that we have access to
// the global as well as Zeidon operation lists. Also Init two Globals.
//
zOPER_EXPORT zSHORT OPERATION
InitInterp( zVIEW lpInterpSubtask,
zVIEW lpAppSubtask,
zPCHAR szSrcDLLName )
{
zVIEW vStackObject;
// zVIEW vViewObject;
zVIEW vTZOPGRPO;
zCHAR szExecDir[ zMAX_FILESPEC_LTH + 1 ]; // dir string
zSHORT nRC;
nRC = LoadXPG( lpInterpSubtask, lpAppSubtask, szSrcDLLName, "C" );
if ( nRC != 0 ) // failed
return( -1 );
if ( GetViewByName( &vStackObject, "StackObject", lpInterpSubtask, zLEVEL_SUBTASK ) != zLEVEL_SUBTASK )
{
// activate an empty stack object.
ActivateEmptyObjectInstance( &vStackObject, "TZVSRTOO", lpInterpSubtask, zSINGLE );
// create the root of the stack object.
CreateEntity( vStackObject, "StackObject", zPOS_AFTER );
// Name the Stack Object
SetNameForView( vStackObject, "StackObject", lpInterpSubtask, zLEVEL_SUBTASK );
}
#if 0 // DGC The following to OIs do not appear to be used anywhere so I'm
// removing them so that we don't need an LPLR to be active.
// get access to the global operation list and the Zeidon operation list
nRC = RetrieveViewForMetaList( vSubtask, &lpGOListView, zREFER_GO_META );
if ( nRC < 0 ) // failed
lpGOListView = 0;
// get a view to the Task LPLR
if ( GetViewByName( &vViewObject, "TaskLPLR", vSubtask, zLEVEL_TASK ) != zLEVEL_TASK )
return( -1 );
#endif
if ( GetViewByName( &vTZOPGRPO, "TZOPSIGK.Interp", lpInterpSubtask, zLEVEL_TASK ) != zLEVEL_TASK )
{
// get the exec directory
zgGetZeidonToolsDir( lpAppSubtask, szExecDir, zAPPL_DIR_OBJECT );
// concat the name. and the .XGO extention
strcat_s( szExecDir, zsizeof( szExecDir ), "TZOPSIGK.XGO" );
nRC = ActivateOI_FromFile( &vTZOPGRPO, "TZOPGRPO", lpInterpSubtask, szExecDir, zSINGLE );
if ( nRC < 0 ) // failed
vTZOPGRPO = 0;
else
SetNameForView( vTZOPGRPO, "TZOPSIGK.Interp", lpInterpSubtask, zLEVEL_TASK );
}
g_nStackPtr = 0;
g_nCallStack[ 0 ] = 1;
return( 0 );
}
zOPER_EXPORT zSHORT OPERATION
oTZCMWKSO_ActivateWorkStation( zPVIEW vTZCMWKSO, zVIEW vQual, zLONG lControl )
{
zCHAR szZeidonWKS[ 256 ];
if ( oTZCMWKSO_GetWKS_FileName( szZeidonWKS, zsizeof( szZeidonWKS ) ) == 0 )
return( ActivateOI_FromFile( vTZCMWKSO, "TZCMWKSO", vQual, szZeidonWKS, lControl ) );
return( -1 );
}
zOPER_EXPORT zLONG OPERATION
GetExecModeByZKey( zVIEW lpInterpSubtask,
zVIEW lpAppSubtask,
zLONG lZKey )
{
zVIEW vXChecker;
zVIEW CM_List;
zCHAR szExecDir[ zMAX_FILESPEC_LTH + 1 ];
zSHORT nRC;
nRC = GetViewByName( &vXChecker, "TZVSXCOO", lpInterpSubtask, zLEVEL_APPLICATION );
if ( nRC != zLEVEL_APPLICATION )
{
nRC = GetViewByName( &CM_List, "TZCMWKSO", lpInterpSubtask, zLEVEL_APPLICATION );
nRC = GetStringFromAttribute( szExecDir, zsizeof( szExecDir ), CM_List, "LPLR", "ExecDir" );
ZeidonStringConcat( szExecDir, 1, 0, "\\TZVSXC01.POR", 1, 0, zMAX_FILESPEC_LTH + 1 );
nRC = ActivateOI_FromFile( &vXChecker, "TZVSXCOO", lpAppSubtask, szExecDir, zSINGLE | zIGNORE_ATTRIB_ERRORS );
if ( nRC != 0 )
return( -1 );
}
nRC = SetCursorFirstEntityByInteger( vXChecker, "DialogOperation", "ZKey", lZKey, "APPLICATION" );
#if 0
if ( nRC != zCURSOR_SET )
return( -1 );
#else
if ( nRC < zCURSOR_SET )
nRC = SetCursorFirstEntityByInteger( vXChecker, "LOD_Operation", "ZKey", lZKey, "APPLICATION" );
if ( nRC < zCURSOR_SET )
nRC = SetCursorFirstEntityByInteger( vXChecker, "Operation", "ZKey", lZKey, "APPLICATION" );
// why do this???
if ( nRC < zCURSOR_SET )
return( -1 );
#endif
if ( nRC >= zCURSOR_SET )
{
nRC = SetAttributeFromInteger( vXChecker, "APPLICATION", "CurrentMode", zXC_SETUP_DEBUGGER );
return( zXC_SETUP_DEBUGGER );
}
else
{
nRC = SetAttributeFromInteger( vXChecker, "APPLICATION", "CurrentMode", 1 );
return( zXC_OPERATION_STAGED );
}
}
zOPER_EXPORT zSHORT OPERATION
UpgradeDialog1( zVIEW vSubtask,
zVIEW OrigW )
{
#if 0
zVIEW OrigWC;
zVIEW vPE;
zVIEW vType;
zVIEW LOD_List;
zSHORT nZRetCode;
zLONG lTempInteger_0;
zSHORT RESULT;
nZRetCode = RetrieveViewForMetaList( vSubtask, &LOD_List, 2013 );
nZRetCode = ActivateMetaOI( vSubtask, &vPE, LOD_List, 2013, zSINGLE );
nZRetCode = ActivateOI_FromFile( &vType, "TZPACTLO", vSubtask, "c:\\10c\\W\\BIN\\SYS\\TZPACTLI.POR", zSINGLE );
lTempInteger_0 = CheckExistenceOfEntity( OrigW, "SourceFile" );
if ( lTempInteger_0 < 0 )
{
nZRetCode = CreateMetaEntity( vSubtask, OrigW, "SourceFile", zPOS_AFTER );
SetAttributeFromAttribute( OrigW, "SourceFile", "Name", OrigW, "Dialog", "Tag" );
}
SetNameForView( vType, "vType", vSubtask, zLEVEL_TASK );
SetNameForView( vPE, "vPE", vSubtask, zLEVEL_TASK );
RESULT = SetCursorFirstEntity( OrigW, "Window", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
nZRetCode = CreateViewFromViewForTask( &OrigWC, OrigW, 0 );
nZRetCode = SetNameForView( OrigWC, "OrigWC", vSubtask, zLEVEL_TASK );
RESULT = SetCursorFirstEntity( OrigW, "Action", "" );
// while ( RESULT > zLEVEL_TASK )
while ( RESULT >= 0 )
{
nZRetCode = UpgradeAction( vSubtask, OrigW );
RESULT = SetCursorNextEntity( OrigW, "Action", "" );
}
RESULT = SetCursorFirstEntity( OrigWC, "Control", "" );
while ( RESULT >= 0 )
{
nZRetCode = UpgradeControl( vSubtask, OrigW, OrigWC, vType, vPE );
RESULT = SetCursorNextEntity( OrigWC, "Control", "" );
}
nZRetCode = DropView( OrigWC );
RESULT = SetCursorNextEntity( OrigW, "Window", "" );
}
#endif
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// OPERATION: oTZDMXGPO_GetViewForXDM
//
// PURPOSE: Get access to XDM View. Activate if not loaded
// and get at application level if loaded.
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
oTZDMXGPO_GetViewForXDM( zVIEW vSubtask,
zPVIEW pvTZDMXGPO,
zSHORT nCurrentOrReload )
{
zVIEW vT;
zVIEW vTask;
zCHAR szXDM_FileName[ zMAX_FILESPEC_LTH + 1 ];
zCHAR szAppViewName[ 66 ] = "dmDOMAINS.";
zSHORT nRScope;
zSHORT nRC;
// Set up the XDM File Name and the View Name
GetViewByName( &vTask, "TaskLPLR", vSubtask, zLEVEL_TASK );
GetStringFromAttribute( &szAppViewName[ 10 ], vTask, "LPLR", "Name" );
GetStringFromAttribute( szXDM_FileName, vTask, "LPLR", "ExecDir" );
zstrcat( szXDM_FileName, "\\zeidon.xdm" );
// See if XDM View is at the Application level
nRScope = GetViewByName( &vT, szAppViewName, vTask, zLEVEL_APPLICATION );
if ( nRScope == zCALL_ERROR )
return( zCALL_ERROR );
if ( nRScope == zLEVEL_APPLICATION && nCurrentOrReload == zFORCE_RELOAD )
{
nRC = DropObjectInstance( vT );
nRScope = -1;
}
if ( nRScope != zLEVEL_APPLICATION )
{
// Load it from a file or create a new one if file is missing.
if ( ActivateOI_FromFile( &vT, "TZDMXGPO", vTask, szXDM_FileName,
zSINGLE | zLEVEL_APPLICATION | zNOI_OKAY ) != 0 )
{
ActivateEmptyObjectInstance( &vT, "TZDMXGPO", vTask,
zSINGLE | zLEVEL_APPLICATION );
CreateEntity( vT, "DomainGroup", zPOS_AFTER );
SetAttributeFromString( vT, "DomainGroup", "Name",
&szAppViewName[ 10 ] );
SetNameForView( vT, szAppViewName, 0, zLEVEL_APPLICATION );
CommitOI_ToFile( vT, szXDM_FileName, zASCII );
// MessageSend( vT, "DM00201", "Domain Management",
// "The Executable Domain File was not found. "
// "An empty one is being created. You may want "
// "to save all Domains OR re-Initialze the LPLR.",
// zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP );
nRC = 1;
}
else
{
SetNameForView( vT, szAppViewName, 0, zLEVEL_APPLICATION );
nRC = 0;
}
}
else
{
nRC = 0;
}
CreateViewFromViewForTask( pvTZDMXGPO, vT, 0 );
return( nRC );
}
/////////////////////////////////////////////////////////////////////////////
//
// ENTRY:
//
// PURPOSE: Create a HK if one doesn't exist for current LPLR.
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
zwTZHKEYAD_InitHK_ForLPLR( zVIEW vSubtask )
{
zVIEW vCM_List;
zVIEW vKZHKEYSO;
zVIEW vTaskLPLR;
zCHAR szFileSpec[ zMAX_FILESPEC_LTH + 1 ];
// zSHORT nRC;
RetrieveViewForMetaList( vSubtask, &vCM_List, zREFER_GO_META );
SetNameForView( vCM_List, "CM_List", vSubtask, zLEVEL_TASK );
#if 0
// Get File list of Presentation Environments (only one).
nRC = RetrieveViewForMetaList( vSubtask, &vCM_List, zREFER_HKEY_META );
// Always have a Named List of PPE's (even though there can only be One)!
// This is done to be consistent with other dialogs. The only time the
// that the named List will not exist is during a SwithLPLR.
// This fact is used a "flag" to the ReturnFromSubWnd logic.
nRC = SetNameForView( vCM_List, "CM_HK_List", vSubtask, zLEVEL_TASK );
// See if one exists.
nRC = SetCursorFirstEntity( vCM_List, "W_MetaDef", "" );
// If not, create one, else open it.
if ( nRC == zCURSOR_NULL )
{
// oTZPESRCO_GrayOptions( vSubtask );
}
else
{
nRC = ActivateMetaOI( vSubtask, &vKZHKEYSO, vCM_List, zREFER_HKEY_META, zSINGLE );
SetNameForView( vKZHKEYSO, "TZPESRCV", vSubtask, zLEVEL_TASK );
CreateViewFromViewForTask( &vCtrlList, vKZHKEYSO, 0 );
SetNameForView( vCtrlList, "TZPECTRL", vSubtask, zLEVEL_TASK );
SetAttributeFromInteger( vKZHKEYSO, "ApplHKyDef", "CtrlFontDel", 0 );
}
#endif
// Get the directory.
GetViewByName( &vTaskLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK );
if ( vTaskLPLR == 0 )
{
MessageSend( vSubtask, "HK00101", "Hot Keys",
"Can't locate LPLR?",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( 0 );
}
GetStringFromAttribute( szFileSpec, vTaskLPLR, "LPLR", "MetaSrcDir" );
zstrcat( szFileSpec, "\\ZEIDON.PHK" );
TraceLineS( "Hotkey Dialog opening file: ", szFileSpec );
// Load the HKEY object.
if ( ActivateOI_FromFile( &vKZHKEYSO, "KZHKEYSO", vSubtask, szFileSpec,
zIGNORE_ERRORS | zSINGLE | zLEVEL_APPLICATION | zNOI_OKAY ) < 0 )
{
CreateEntity( vKZHKEYSO, "Application", zPOS_AFTER );
CommitOI_ToFile( vKZHKEYSO, szFileSpec, zASCII );
}
SetNameForView( vKZHKEYSO, "KZHKEYSO", vSubtask, zLEVEL_TASK );
return( 0 );
}
///////////////////////////////////////////////////////////////////////////////
//
// OPERATION: TZZAPPSD_SendServerExecs
//
// PURPOSE: This Entry takes the zeidon.xdm and all xod object instances
// and sends them to the Server for running the application on
// the server.
//
////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
TZZAPP2D_SendServerExecs( zVIEW vSubtask )
{
zVIEW vZApp;
zVIEW vLPLR;
zVIEW vMeta;
zSHORT nRC;
zCHAR szFileName[ zMAX_FILESPEC_LTH + 1 ];
zCHAR szMetaName[ 13 ];
zCHAR szAppName[ 32 ];
zCHAR szServerSubDir[ 33 ];
zCHAR szLPLR_Path[ zMAX_FILESPEC_LTH + 1 ];
zCHAR szMsg[ zSHORT_MESSAGE_LTH + 1 ];
zVIEW vApplSubtask;
zCHAR szServer[ 33 ];
// get XLP for selceted application
GetViewByName( &vZApp, "KZAPPLOO", vSubtask, zLEVEL_TASK );
GetStringFromAttribute( szAppName, vZApp, "APPLICATION", "APP_NAME" );
GetStringFromAttribute( szLPLR_Path, vZApp, "APPLICATION", "APP_ADOBIN" );
SysAppendcDirSep( szLPLR_Path );
zstrcpy( szFileName, szLPLR_Path );
zstrcat( szFileName, szAppName );
zstrcat( szFileName, ".XLP" );
// open Task LPLR
nRC = ActivateOI_FromFile( &vLPLR, "TZCMLPLO", vSubtask, szFileName,
zMULTIPLE );
if ( nRC )
{
MessageSend( vSubtask, "CM00285", "Configuration Management",
"Can't activate XLP for task.",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( -1 );
}
SetNameForView( vLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK);
zmemset (szServer,0,sizeof(szServer));
// GetViewByName( &vLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK );
// Start the network if necessary. Use zeidon and hzkzoe as constants for now.
nRC = NetStatus( "zeidon" );
if ( nRC == 0 )
{
nRC = NetStartup( "zeidon", "hzkzoe" );
if ( nRC )
{
MessageSend( vSubtask, "CM00285", "Configuration Management",
"Network cannot be started.",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( 0 );
}
}
// First get the application name and make sure it exists in the
// zeidon.app object on the server. If it isn't there, add it.
GetStringFromAttribute( szAppName, vLPLR, "LPLR", "Name" );
zstrcpy( szFileName, "zeidon.app" );
SfCreateSubtask( &vApplSubtask, vSubtask, "Zeidon System" );
nRC = NetActivateOI_FromFile( 0, szServer, &vMeta, "KZAPPLOO",
vApplSubtask, szFileName, zSINGLE );
if ( nRC >= 0 )
{
nRC = SetCursorFirstEntityByString( vMeta, "APPLICATION",
"APP_NAME", szAppName, 0 );
if ( nRC >= zCURSOR_SET )
DropObjectInstance( vMeta );
else
{
CreateEntity( vMeta, "APPLICATION", zPOS_LAST );
SetAttributeFromString( vMeta, "APPLICATION", "APP_NAME", szAppName );
zstrcpy( szServerSubDir, szAppName );
zstrcat( szServerSubDir, "/" );
SetAttributeFromString( vMeta, "APPLICATION",
"APP_DLL", szServerSubDir );
SetAttributeFromString( vMeta, "APPLICATION",
"APP_ADOBIN", szServerSubDir );
SetAttributeFromString( vMeta, "APPLICATION",
"APP_LOCAL", szServerSubDir );
TraceLineS( "*** Committing server file: ", szFileName );
zstrcpy( szMsg, "Sending ZEIDON.APP: " );
MB_SetMessage( vSubtask, 1, szMsg );
// Send OI to server.
NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII );
DropObjectInstance( vMeta );
}
}
else
{
SfDropSubtask( vApplSubtask, 0 );
MessageSend( vSubtask, "CM00286", "Configuration Management",
"ZEIDON.APP cannot be activated.",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( 0 );
}
SfDropSubtask( vApplSubtask, 0 );
// Send the XDM before all the xods.
// First format the file name for activation on the client and then
// format it for commit on the server.
// GetStringFromAttribute( szFileName, vLPLR, "LPLR", "ExecDir" );
zstrcpy( szFileName, szLPLR_Path );
zstrcpy( szMetaName, "ZEIDON.XDM" );
zstrcat( szFileName, szMetaName );
TraceLineS( "*** Activating client file: ", szFileName );
nRC = ActivateOI_FromFile( &vMeta, "TZDMXGPO", vSubtask,
szFileName, zSINGLE );
if ( nRC >= 0 )
{
// Filename includes Directory-prefix **HH**
GetStringFromAttribute( szFileName, vLPLR, "LPLR", "Name" );
zstrcat( szFileName, "/" );
zstrcat( szFileName, szMetaName );
TraceLineS( "*** Committing server file: ", szFileName );
MB_SetMessage( vSubtask, 1, "Sending XDM" );
// Send OI to server.
NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII );
}
// Next loop through all the LODs, activating each XOD and sending
// it to the server.
SetCursorFirstEntityByInteger( vLPLR, "W_MetaType", "Type",
zREFER_LOD_META, 0 );
nRC = SetCursorFirstEntity( vLPLR, "W_MetaDef", 0 );
while ( nRC >= zCURSOR_SET )
{
zstrcpy( szFileName, szLPLR_Path );
GetStringFromAttribute( szMetaName, vLPLR, "W_MetaDef", "Name" );
zstrcat( szFileName, szMetaName );
zstrcat( szFileName, ".XOD" );
TraceLineS( "*** Activating client file: ", szFileName );
nRC = ActivateOI_FromFile( &vMeta, "TZZOXODO", vSubtask,
szFileName, zSINGLE );
if ( nRC >= 0 )
{
// Filename includes Directory-prefix **HH**
GetStringFromAttribute( szFileName, vLPLR, "LPLR", "Name" );
zstrcat( szFileName, "/" );
zstrcat( szFileName, szMetaName );
zstrcat( szFileName, ".XOD" );
TraceLineS( "*** Committing server file: ", szFileName );
zstrcpy( szMsg, "Sending XOD: " );
zstrcat( szMsg, szMetaName );
MB_SetMessage( vSubtask, 1, szMsg );
// Send OI to server.
NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII );
}
nRC = SetCursorNextEntity( vLPLR, "W_MetaDef", 0 );
}
MB_SetMessage( vSubtask, 1, "Transmission Complete" );
return( 0 );
}
//
// OPERATION: LoadXPG
//
// DESCRIPTION: LoadXPG Gets the executable directory from the TaskLPLR.
// It then creates a file name from which to load the pared instance file.
// If the load is successful then the view is names in the interp
// subtask as XPG.
//
zOPER_EXPORT zSHORT OPERATION
LoadXPG( zVIEW lpInterpSubtask, // interpretor subtask
zVIEW vSubtask, // application subtask
zPCHAR szSrcDLLName, // source dllname
zCPCHAR cpcGenLang )
{
zVIEW vViewObject; // task view
zCHAR szExecDir[ zMAX_FILESPEC_LTH + 1 ]; // dir string
zCHAR szMessage[ zMAX_MESSAGE_LTH + 1 ];
zLONG lParserVersion = 0;
zSHORT nLth; // string length
zSHORT nRC;
// First check to see if it already exists.
GetViewByName( &g_vXPGView, "XPG", lpInterpSubtask, zLEVEL_SUBTASK );
if ( g_vXPGView != 0 )
return( 0 );
// get a view to the Task LPLR
if ( GetViewByName( &vViewObject, "TaskLPLR", vSubtask, zLEVEL_TASK ) != zLEVEL_TASK )
{
return( -1 );
}
// get the exec directory
GetStringFromAttribute( szExecDir, zsizeof( szExecDir ), vViewObject, "LPLR", "ExecDir" );
// be sure it was terminated with a '\'
nLth = (zSHORT) zstrlen( szExecDir );
if ( szExecDir[ nLth ] != '\\' )
{
szExecDir[ nLth ] = '\\';
szExecDir[ nLth + 1 ] = 0;
}
// concat the name. and the .XPG extention
strcat_s( szExecDir, zsizeof( szExecDir ), szSrcDLLName );
if ( cpcGenLang[ 0 ] == 'J' )
strcat_s( szExecDir, zsizeof( szExecDir ), ".XPJ" );
else
strcat_s( szExecDir, zsizeof( szExecDir ), ".XPG" );
// activate the file
nRC = ActivateOI_FromFile( &g_vXPGView,
"TZVSPOOO",
lpInterpSubtask,
szExecDir,
zSINGLE | zNOI_OKAY |
zIGNORE_ATTRIB_ERRORS );
if ( nRC != 0 ) // failed
{
strcpy_s( szMessage, zsizeof( szMessage ), "Source VML :" );
strcat_s( szMessage, zsizeof( szMessage ), szSrcDLLName );
strcat_s( szMessage, zsizeof( szMessage ), " must be parsed prior to execution" );
MessageSend( lpInterpSubtask, "VM03002", "VML Interpretor",
szMessage,
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
TraceLineS( "Could Not Load ", szExecDir );
return( -1 );
}
// do the Parser Version Compatibility Check
#define PARSER_VERSION_REQUIRED 1
nRC = GetIntegerFromAttribute( &lParserVersion, g_vXPGView,
"VML_XSource", "ParserVersion" );
if ( nRC != 0 || lParserVersion < PARSER_VERSION_REQUIRED )
{
// the XPG is too old, and not compatible with the current
// interpreter.
strcpy_s( szMessage, zsizeof( szMessage ), "Source VML :" );
strcat_s( szMessage, zsizeof( szMessage ), szSrcDLLName );
strcat_s( szMessage, zsizeof( szMessage ),
" is outdated and must be re-parsed prior to execution" );
MessageSend( lpInterpSubtask, "VM03002", "VML Interpretor",
szMessage,
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
TraceLineS( "Program File Outdated : ", szExecDir );
return( -1 );
}
// name the view to the interpretor subtask
SetNameForView( g_vXPGView, "XPG", lpInterpSubtask, zLEVEL_SUBTASK );
return( 0 );
}
zOPER_EXPORT zLONG OPERATION
GetExecMode( zVIEW lpInterpSubtask,
zVIEW lpAppSubtask,
zPCHAR szSrcDLLName,
zPCHAR szOperationName,
zPCHAR szMetaType )
{
zVIEW vXChecker;
zVIEW CM_List;
zCHAR szExecDir[ zMAX_FILESPEC_LTH + 1 ];
zCHAR szScopeMeta[ 33 ];
zCHAR szSourceFileMeta1[ 33 ];
zCHAR szSourceFileMeta2[ 33 ];
zCHAR szOperationMeta[ 33 ];
zSHORT nRC;
if ( !szMetaType || !*szMetaType )
return( -1 );
nRC = GetViewByName( &vXChecker, "TZVSXCOO",
lpInterpSubtask, zLEVEL_APPLICATION );
if ( nRC != zLEVEL_APPLICATION )
{
GetViewByName( &CM_List, "TZCMWKSO", lpInterpSubtask, zLEVEL_APPLICATION );
// If CM_List is 0 then we must have been called from Core at runtime.
// In this case all operations are run natively so don't bother checking
// the exec mode.
if ( CM_List == 0 )
return( -1 );
GetStringFromAttribute( szExecDir, zsizeof( szExecDir ), CM_List, "LPLR", "ExecDir" );
ZeidonStringConcat( szExecDir, 1, 0, "\\TZVSXC01.POR", 1, 0, zMAX_FILESPEC_LTH+1 );
nRC = ActivateOI_FromFile( &vXChecker, "TZVSXCOO",
lpAppSubtask, szExecDir,
zSINGLE | zIGNORE_ATTRIB_ERRORS );
if ( nRC != 0 )
return( -1 );
}
// set up the Operation Meta Name
if ( zstrcmp( szMetaType, "Dialog" ) == 0 )
{
strcpy_s( szSourceFileMeta1, zsizeof( szSourceFileMeta1 ), "DialogSourceFile" );
strcpy_s( szSourceFileMeta2, zsizeof( szSourceFileMeta2 ), "Dialog" );
strcpy_s( szOperationMeta, zsizeof( szOperationMeta ), "DialogOperation" );
strcpy_s( szScopeMeta, zsizeof( szScopeMeta), "Dialogs" );
}
else
if ( zstrcmp( szMetaType, "LOD" ) == 0 )
{
strcpy_s( szSourceFileMeta1, zsizeof( szSourceFileMeta1 ), "LODSourceFile" );
strcpy_s( szSourceFileMeta2, zsizeof( szSourceFileMeta2 ), "LOD" );
strcpy_s( szOperationMeta, zsizeof( szOperationMeta ), "LOD_Operation" );
strcpy_s( szScopeMeta, zsizeof( szScopeMeta), "LODs" );
}
else
{
strcpy_s( szSourceFileMeta1, zsizeof( szSourceFileMeta1 ), "GlobalSourceFile" );
strcpy_s( szSourceFileMeta2, zsizeof( szSourceFileMeta2 ), "GlobalOperation" );
strcpy_s( szOperationMeta, zsizeof( szOperationMeta ), "Operation" );
strcpy_s( szScopeMeta, zsizeof( szScopeMeta), "GlobalOperations" );
}
nRC = SetCursorFirstEntityByString( vXChecker, szSourceFileMeta1,
"Name", szSrcDLLName, szScopeMeta );
#if 0
if ( nRC < zCURSOR_SET )
{
nRC = SetCursorFirstEntityByString( vXChecker, szSourceFileMeta2,
"Name", szSrcDLLName, szScopeMeta );
if ( nRC == zCURSOR_SET )
{
nRC = SetAttributeFromInteger( vXChecker, "APPLICATION", "CurrentMode", 1 );
return( zXC_OPERATION_STAGED );
}
else
return( -1 );
}
#endif
if ( nRC < zCURSOR_SET )
return( -1 );
nRC = SetCursorFirstEntityByString( vXChecker, szOperationMeta, "Name", szOperationName, "" );
if ( nRC >= zCURSOR_SET )
{
nRC = SetAttributeFromInteger( vXChecker, "APPLICATION", "CurrentMode", zXC_SETUP_DEBUGGER );
return( zXC_SETUP_DEBUGGER );
}
else
{
nRC = SetAttributeFromInteger( vXChecker, "APPLICATION", "CurrentMode", 1 );
return( zXC_OPERATION_STAGED );
}
}
static void ProcessXods( HWND hWnd, zVIEW vSubtask,
zCHAR *cTE_Name, zCHAR *cLogFile, zCHAR cNet )
{
FILE *fLog=NULL;
zVIEW vTaskLPLR = NULL;
zCHAR szMsg[ 256 ];
zVIEW vTZTEDBLO, vDTE, vCM_List;
zVIEW vLOD, vLOD_List, vXOD;
zVIEW vTemp = NULL;
zVIEW vT=NULL;
zSHORT nRC;
RECT rect;
LPLIBRARY hLib = NULL;
zCHAR szLODName[ 32 ];
zCHAR szFileName[ 256 ];
zCHAR szNetwork[ 256 ];
if ( cLogFile && cLogFile[0] )
fLog = fopen( cLogFile, "w");
memset (szNetwork, 0, 256);
SysReadZeidonIni( -1, "[Zeidon]", "DefaultNetWork", szNetwork );
if (*szNetwork == 0)
{
strcpy( szMsg, "No default Network set" );
MessageBox( hWnd, szMsg,
"Error Running xodgen",
MB_OK | MB_ICONSTOP | MB_APPLMODAL );
zstrcat( szMsg, "\n" );
if ( fLog )
{
fputs( szMsg,fLog );
fclose (fLog);
}
return;
}
ActivateOI_FromFile( &vTZTEDBLO, "tztedblo", vSubtask, "tztedblo.xdl",
zMULTIPLE );
SetNameForView( vTZTEDBLO, "TZTEDBLO", 0, zLEVEL_TASK );
//oTZTENVRO_GetUpdViewForDTE_P
nRC = RetrieveViewForMetaList( vSubtask, vSubtask, &vCM_List, zSOURCE_DTE_META );
nRC = ActivateMetaOI( &vDTE, vCM_List, zSOURCE_DTE_META,
zSINGLE | zACTIVATE_ROOTONLY );
if ( nRC < 0 )
{
strcpy( szMsg, "Internal error activating TE" );
MessageBox( hWnd, szMsg,
"Error Running xodgen",
MB_OK | MB_ICONSTOP | MB_APPLMODAL );
zstrcat( szMsg, "\n" );
if ( fLog )
{
fputs( szMsg,fLog );
fclose (fLog);
}
return;
}
SetNameForView( vDTE, "TE_DB_Environ", vSubtask, zLEVEL_TASK );
// Position on given DBMS Source
nRC = SetCursorFirstEntityByString( vDTE,
"TE_DBMS_Source", "Name", cTE_Name, 0 );
if ( nRC < zCURSOR_SET )
{
strcpy( szMsg, "Invalid TE Name :");
strcat( szMsg, cTE_Name );
MessageBox( hWnd, szMsg,
"Error Running xodgen",
MB_OK | MB_ICONSTOP | MB_APPLMODAL );
zstrcat( szMsg, "\n" );
if ( fLog )
{
fputs( szMsg,fLog );
fclose (fLog);
}
return;
}
nRC = GetViewByName( &vTaskLPLR, "TaskLPLR", 0, zLEVEL_TASK );
assert(nRC >= 0 ) ;
// Check for network build
if ( cNet )
{
// Use default network for Ton Beller (DBMS = "Network Server")
SetCursorFirstEntityByString( vTZTEDBLO, "TE_DBMS_Source", "Network",
szNetwork, 0 );
SetAttributeFromAttribute( vDTE, "TE_DBMS_Source", "DBMS",
vTZTEDBLO, "TE_DBMS_Source", "DBMS" );
SetAttributeFromAttribute( vDTE, "TE_DBMS_Source", "Network",
vTZTEDBLO, "TE_DBMS_Source", "Network" );
}
else
{
// Position on corresponding DBMS entry in DB Handler object.
SetCursorFirstEntityByAttr( vTZTEDBLO, "TE_DBMS_Source", "DBMS",
vDTE, "TE_DBMS_Source", "DBMS", 0 );
}
//zwTZTEUPDD_BuildXODsOnLPLR( zVIEW vSubtask )
// Create a view that lists all LODs.
RetrieveViewForMetaList( vSubtask, vSubtask, &vLOD_List, zREFER_LOD_META );
OrderEntityForView( vLOD_List, "W_MetaDef", "Name A" );
SetNameForView( vLOD_List, "TZZOLFLO", vSubtask, zLEVEL_TASK );
// Loop through each of the LOD's
// WMetaType.Type= zREFER_LOD_META
//
for ( nRC = SetCursorFirstEntity( vLOD_List, "W_MetaDef", "" );
nRC >= zCURSOR_SET;
nRC = SetCursorNextEntity( vLOD_List, "W_MetaDef", "" ) )
{
GetStringFromAttribute( szLODName,
vLOD_List, "W_MetaDef", "Name" );
nRC = ActivateMetaOI( &vLOD, vLOD_List, zREFER_LOD_META, zCURRENT_OI );
if ( nRC < 0 )
{
zstrcpy( szMsg, "Could not Activate LOD: " );
zstrcat( szMsg, szLODName );
zstrcat( szMsg, ".\nAborting Build" );
MessageBox( hWnd,
szMsg,
"Error Running xodgen",
MB_OK | MB_ICONSTOP | MB_APPLMODAL );
zstrcat( szMsg, "\n" );
if ( fLog )
{
fputs( szMsg,fLog );
fclose (fLog);
}
return ;
}
else
{
// Send message that we are building the LOD.
strcpy( szMsg, "Building executable for LOD: " );
strcat( szMsg, szLODName );
strcat( szMsg, "." );
strcpy( szOutLine, szMsg );
GetClientRect( hWnd, &rect );
InvalidateRect( hWnd, &rect, TRUE );
UpdateWindow( hWnd );
if ( fLog )
{
zstrcat( szMsg, "\n" );
fputs( szMsg,fLog );
}
else
TraceLineS( szMsg, "" );
// Make sure the TE_SourceZKey attribute is set because it determines
// what DBMS_Source is used in building the XOD.
if ( CheckExistenceOfEntity( vLOD, "POD" ) >= zCURSOR_SET )
SetAttributeFromAttribute ( vLOD, "POD", "TE_SourceZKey",
vDTE, "TE_DBMS_Source", "ZKey" );
// Build the XOD in memory
oTZZOXODO_SaveXOD( vLOD );
SetNameForView( vLOD, "TZZOLODO", 0, zLEVEL_TASK );
DropMetaOI( vSubtask, vLOD );
// Commit the XOD to LPLR file.
GetViewByName( &vXOD, "TZZOXODO", 0, zLEVEL_TASK );
GetStringFromAttribute( szFileName,
vTaskLPLR, "LPLR", "ExecDir" );
ofnTZCMWKSO_AppendSlash( szFileName );
zstrcat( szFileName, szLODName );
zstrcat( szFileName, ".XOD" );
CommitOI_ToFile( vXOD, szFileName, zSINGLE );
}
}
if (fLog)
fclose (fLog);
else
TraceLineS( "Completed XOD build", "" );
return;
}
//:VIEW OperationXOG BASED ON LOD TZZOXOGO
zOPER_EXPORT zSHORT OPERATION
oTZOGSRCO_GenerateXOG( zVIEW OperationGroup )
{
zVIEW OperationXOG = 0;
//:VIEW OperationGroupT BASED ON LOD TZOGSRCO
zVIEW OperationGroupT = 0;
//:VIEW CurrentLPLR BASED ON LOD TZCMLPLO
zVIEW CurrentLPLR = 0;
//:STRING ( 513 ) XOG_FileName
zCHAR XOG_FileName[ 514 ] = { 0 };
//:STRING ( 513 ) POG_FileName
zCHAR POG_FileName[ 514 ] = { 0 };
//:STRING ( 200 ) szMsg
zCHAR szMsg[ 201 ] = { 0 };
//:INTEGER lFile
zLONG lFile = 0;
//:SHORT nRC
zSHORT nRC = 0;
zSHORT RESULT;
zCHAR szTempString_0[ 33 ];
zCHAR szTempString_1[ 33 ];
//:// Build the executable Global Object executable for all Operations in the LPLR.
//:// Activate or initialize the XOG executable object.
//:GET VIEW CurrentLPLR NAMED "TaskLPLR"
RESULT = GetViewByName( &CurrentLPLR, "TaskLPLR", OperationGroup, zLEVEL_TASK );
//:XOG_FileName = CurrentLPLR.LPLR.ExecDir + "\" + CurrentLPLR.LPLR.Name + ".XOG"
GetStringFromAttribute( XOG_FileName, CurrentLPLR, "LPLR", "ExecDir" );
ZeidonStringConcat( XOG_FileName, 1, 0, "\\", 1, 0, 514 );
GetVariableFromAttribute( szTempString_0, 0, 'S', 33, CurrentLPLR, "LPLR", "Name", "", 0 );
ZeidonStringConcat( XOG_FileName, 1, 0, szTempString_0, 1, 0, 514 );
ZeidonStringConcat( XOG_FileName, 1, 0, ".XOG", 1, 0, 514 );
//:lFile = SysOpenFile( OperationGroup, XOG_FileName, COREFILE_READ )
lFile = SysOpenFile( OperationGroup, XOG_FileName, COREFILE_READ );
//:IF lFile < 0
if ( lFile < 0 )
{
//:// Executable has not yet been generated.
//:ACTIVATE OperationXOG EMPTY
RESULT = ActivateEmptyObjectInstance( &OperationXOG, "TZZOXOGO", OperationGroup, zSINGLE );
//:CREATE ENTITY OperationXOG.TZZOXOGO
RESULT = CreateEntity( OperationXOG, "TZZOXOGO", zPOS_AFTER );
//:OperationXOG.TZZOXOGO.NAME = CurrentLPLR.LPLR.Name
SetAttributeFromAttribute( OperationXOG, "TZZOXOGO", "NAME", CurrentLPLR, "LPLR", "Name" );
//:ELSE
}
else
{
//:SysCloseFile( OperationGroup, lFile, 0 )
SysCloseFile( OperationGroup, lFile, 0 );
//:// Get current executable File.
//:ActivateOI_FromFile( OperationXOG, "TZZOXOGO", OperationGroup, XOG_FileName, zSINGLE )
ActivateOI_FromFile( &OperationXOG, "TZZOXOGO", OperationGroup, XOG_FileName, zSINGLE );
//:// Delete current source file entries.
//:FOR EACH OperationXOG.GLOBALOPERATIONSOURCEFILE
RESULT = SetCursorFirstEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:DELETE ENTITY OperationXOG.GLOBALOPERATIONSOURCEFILE NONE
RESULT = DeleteEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", zREPOS_NONE );
RESULT = SetCursorNextEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "" );
}
//:END
}
//:END
//:NAME VIEW OperationXOG "OperationXOG"
SetNameForView( OperationXOG, "OperationXOG", 0, zLEVEL_TASK );
//:// Build the executable components from each POG Operation.
//:SET CURSOR FIRST CurrentLPLR.W_MetaType WHERE CurrentLPLR.W_MetaType.Type = 14 // 14 is Global Operation Group
RESULT = SetCursorFirstEntityByInteger( CurrentLPLR, "W_MetaType", "Type", 14, "" );
//:FOR EACH CurrentLPLR.W_MetaDef
RESULT = SetCursorFirstEntity( CurrentLPLR, "W_MetaDef", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:POG_FileName = CurrentLPLR.LPLR.MetaSrcDir + "\" + CurrentLPLR.W_MetaDef.Name + ".POG"
GetStringFromAttribute( POG_FileName, CurrentLPLR, "LPLR", "MetaSrcDir" );
ZeidonStringConcat( POG_FileName, 1, 0, "\\", 1, 0, 514 );
GetVariableFromAttribute( szTempString_1, 0, 'S', 33, CurrentLPLR, "W_MetaDef", "Name", "", 0 );
ZeidonStringConcat( POG_FileName, 1, 0, szTempString_1, 1, 0, 514 );
ZeidonStringConcat( POG_FileName, 1, 0, ".POG", 1, 0, 514 );
//:nRC = ActivateOI_FromFile( OperationGroupT, "TZOGSRCO", OperationGroup, POG_FileName, zSINGLE + 8192 )
nRC = ActivateOI_FromFile( &OperationGroupT, "TZOGSRCO", OperationGroup, POG_FileName, zSINGLE + 8192 );
//:IF nRC < 0
if ( nRC < 0 )
{
//:szMsg = "Can't open POG file, " + POG_FileName
ZeidonStringCopy( szMsg, 1, 0, "Can't open POG file, ", 1, 0, 201 );
ZeidonStringConcat( szMsg, 1, 0, POG_FileName, 1, 0, 201 );
//:IssueError( OperationGroup,0,0, szMsg )
IssueError( OperationGroup, 0, 0, szMsg );
//:RETURN -1
return( -1 );
}
//:END
//:// Create Source file entry.
//:CREATE ENTITY OperationXOG.GLOBALOPERATIONSOURCEFILE
RESULT = CreateEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", zPOS_AFTER );
//:OperationXOG.GLOBALOPERATIONSOURCEFILE.NAME = OperationGroupT.GlobalOperationGroup.Name
SetAttributeFromAttribute( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "NAME", OperationGroupT, "GlobalOperationGroup", "Name" );
//:OperationXOG.GLOBALOPERATIONSOURCEFILE.LANGUAGETYPE = OperationGroupT.GlobalOperationGroup.LanguageType
SetAttributeFromAttribute( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "LANGUAGETYPE", OperationGroupT, "GlobalOperationGroup", "LanguageType" );
//:// Create each Operation entry.
//:FOR EACH OperationGroupT.Operation
RESULT = SetCursorFirstEntity( OperationGroupT, "Operation", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:CREATE ENTITY OperationXOG.OPERATION
RESULT = CreateEntity( OperationXOG, "OPERATION", zPOS_AFTER );
//:OperationXOG.OPERATION.NAME = OperationGroupT.Operation.Name
SetAttributeFromAttribute( OperationXOG, "OPERATION", "NAME", OperationGroupT, "Operation", "Name" );
//:OperationXOG.OPERATION.TYPE = OperationGroupT.Operation.Type
SetAttributeFromAttribute( OperationXOG, "OPERATION", "TYPE", OperationGroupT, "Operation", "Type" );
//:FOR EACH OperationGroupT.Parameter
RESULT = SetCursorFirstEntity( OperationGroupT, "Parameter", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:CREATE ENTITY OperationXOG.PARAMETER
RESULT = CreateEntity( OperationXOG, "PARAMETER", zPOS_AFTER );
//:OperationXOG.PARAMETER.NAME = OperationGroupT.Parameter.ShortDesc
SetAttributeFromAttribute( OperationXOG, "PARAMETER", "NAME", OperationGroupT, "Parameter", "ShortDesc" );
//:OperationXOG.PARAMETER.DATATYPE = OperationGroupT.Parameter.DataType
SetAttributeFromAttribute( OperationXOG, "PARAMETER", "DATATYPE", OperationGroupT, "Parameter", "DataType" );
RESULT = SetCursorNextEntity( OperationGroupT, "Parameter", "" );
}
RESULT = SetCursorNextEntity( OperationGroupT, "Operation", "" );
//:END
}
RESULT = SetCursorNextEntity( CurrentLPLR, "W_MetaDef", "" );
//:END
}
//:END
//:CommitOI_ToFile( OperationXOG, XOG_FileName, zASCII )
CommitOI_ToFile( OperationXOG, XOG_FileName, zASCII );
//:DropObjectInstance( OperationXOG )
DropObjectInstance( OperationXOG );
return( 0 );
// END
}
//: VIEW OldOperGrp BASED ON LOD TZOGSRCO
zOPER_EXPORT zSHORT OPERATION
oTZOGSRCO_GlobalOperGrpMigrate( zVIEW NewOperGrp,
zPCHAR OperGroupMetaName,
zVIEW SourceLPLR,
zVIEW vSubtask )
{
zVIEW OldOperGrp = 0;
//:VIEW CurrentLPLR BASED ON LOD TZCMLPLO
zVIEW CurrentLPLR = 0;
//:STRING ( 513 ) SourceFileName // size according to zMAX_FILESPEC+1
zCHAR SourceFileName[ 514 ] = { 0 };
//:STRING ( 513 ) SourceFileName2 // size according to zMAX_FILESPEC+1
zCHAR SourceFileName2[ 514 ] = { 0 };
//:STRING ( 36 ) SourceName
zCHAR SourceName[ 37 ] = { 0 };
zSHORT lTempInteger_0;
zSHORT RESULT;
zCHAR szTempString_0[ 33 ];
//:// Activate existing source meta OldOperGroup
//:SourceFileName = SourceLPLR.LPLR.MetaSrcDir + "\" + OperGroupMetaName + ".POG"
GetStringFromAttribute( SourceFileName, SourceLPLR, "LPLR", "MetaSrcDir" );
ZeidonStringConcat( SourceFileName, 1, 0, "\\", 1, 0, 514 );
ZeidonStringConcat( SourceFileName, 1, 0, OperGroupMetaName, 1, 0, 514 );
ZeidonStringConcat( SourceFileName, 1, 0, ".POG", 1, 0, 514 );
//:// zIGNORE_ATTRIB_ERRORS=8192
//:ActivateOI_FromFile( OldOperGrp, "TZOGSRCO", SourceLPLR,
//: SourceFileName, zSINGLE + 8192 )
ActivateOI_FromFile( &OldOperGrp, "TZOGSRCO", SourceLPLR, SourceFileName, zSINGLE + 8192 );
//:NAME VIEW OldOperGrp "OldOperGrp"
SetNameForView( OldOperGrp, "OldOperGrp", 0, zLEVEL_TASK );
//://ActivateEmptyMetaOI( vSubtask, NewOperGrp, 14, zSINGLE ) // 14 is zSOURCE_GOPGRP_META
//://NAME VIEW NewOperGrp "NewOperGrp"
//:IF NewOperGrp.GlobalOperationGroup DOES NOT EXIST
lTempInteger_0 = CheckExistenceOfEntity( NewOperGrp, "GlobalOperationGroup" );
if ( lTempInteger_0 != 0 )
{
//:// The Global Operation Group does not exist in the target, so simply copy everything over.
//:CreateMetaEntity( vSubtask, NewOperGrp, "GlobalOperationGroup", zPOS_AFTER )
CreateMetaEntity( vSubtask, NewOperGrp, "GlobalOperationGroup", zPOS_AFTER );
//:SetMatchingAttributesByName( NewOperGrp, "GlobalOperationGroup", OldOperGrp, "GlobalOperationGroup", zSET_NULL )
SetMatchingAttributesByName( NewOperGrp, "GlobalOperationGroup", OldOperGrp, "GlobalOperationGroup", zSET_NULL );
//:// Copy over the source file to the new LPLR directory, if there is a source file.
//:// We will assume a source file exists if the SourceFile.Extension is not null. If there
//:// is actually no source file, the CopyFile does no harm.
//:IF OldOperGrp.GlobalOperationGroup.Extension != ""
if ( CompareAttributeToString( OldOperGrp, "GlobalOperationGroup", "Extension", "" ) != 0 )
{
//:RetrieveViewForMetaList( vSubtask, CurrentLPLR, zSOURCE_ERD_META ) // Get view for directory info.
RetrieveViewForMetaList( vSubtask, &CurrentLPLR, zSOURCE_ERD_META );
//:ResetViewFromSubobject( CurrentLPLR )
ResetViewFromSubobject( CurrentLPLR );
//:IF OldOperGrp.GlobalOperationGroup.Extension = "C"
if ( CompareAttributeToString( OldOperGrp, "GlobalOperationGroup", "Extension", "C" ) == 0 )
{
//:SourceName = OperGroupMetaName + ".C"
ZeidonStringCopy( SourceName, 1, 0, OperGroupMetaName, 1, 0, 37 );
ZeidonStringConcat( SourceName, 1, 0, ".C", 1, 0, 37 );
//:ELSE
}
else
{
//:SourceName = OperGroupMetaName + ".VML"
ZeidonStringCopy( SourceName, 1, 0, OperGroupMetaName, 1, 0, 37 );
ZeidonStringConcat( SourceName, 1, 0, ".VML", 1, 0, 37 );
}
//:END
//:SourceFileName = SourceLPLR.LPLR.PgmSrcDir + "\" + SourceName
GetStringFromAttribute( SourceFileName, SourceLPLR, "LPLR", "PgmSrcDir" );
ZeidonStringConcat( SourceFileName, 1, 0, "\\", 1, 0, 514 );
ZeidonStringConcat( SourceFileName, 1, 0, SourceName, 1, 0, 514 );
//:SourceFileName2 = CurrentLPLR.LPLR.PgmSrcDir + "\" + SourceName
GetStringFromAttribute( SourceFileName2, CurrentLPLR, "LPLR", "PgmSrcDir" );
ZeidonStringConcat( SourceFileName2, 1, 0, "\\", 1, 0, 514 );
ZeidonStringConcat( SourceFileName2, 1, 0, SourceName, 1, 0, 514 );
//:SysCopyFile( vSubtask, SourceFileName, SourceFileName2, TRUE )
SysCopyFile( vSubtask, SourceFileName, SourceFileName2, TRUE );
//:DropMetaOI( vSubtask, CurrentLPLR )
DropMetaOI( vSubtask, CurrentLPLR );
}
//:END
//:FOR EACH OldOperGrp.Operation
RESULT = SetCursorFirstEntity( OldOperGrp, "Operation", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER )
CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER );
//:SetMatchingAttributesByName ( NewOperGrp, "Operation", OldOperGrp,
//: "Operation", zSET_NULL )
SetMatchingAttributesByName( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL );
//:FOR EACH OldOperGrp.Parameter
RESULT = SetCursorFirstEntity( OldOperGrp, "Parameter", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:// Make sure the ShortDesc in the Parameter is not null.
//:IF OldOperGrp.Parameter.ShortDesc = ""
if ( CompareAttributeToString( OldOperGrp, "Parameter", "ShortDesc", "" ) == 0 )
{
//:OldOperGrp.Parameter.ShortDesc = "Parm"
SetAttributeFromString( OldOperGrp, "Parameter", "ShortDesc", "Parm" );
}
//:END
//:CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER )
CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER );
//:SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp,
//: "Parameter", zSET_NULL )
SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL );
RESULT = SetCursorNextEntity( OldOperGrp, "Parameter", "" );
}
RESULT = SetCursorNextEntity( OldOperGrp, "Operation", "" );
//:END
}
//:END
//:ELSE
}
else
{
//:// The Global Operation Group exists in the target, so merge in any new Operations.
//:// We will force over any Operations (both prototype and code) for any Operations not flagged as modified in target LPLR.
//:FOR EACH OldOperGrp.Operation
RESULT = SetCursorFirstEntity( OldOperGrp, "Operation", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:SET CURSOR FIRST NewOperGrp.Operation WHERE NewOperGrp.Operation.Name = OldOperGrp.Operation.Name
GetStringFromAttribute( szTempString_0, OldOperGrp, "Operation", "Name" );
RESULT = SetCursorFirstEntityByString( NewOperGrp, "Operation", "Name", szTempString_0, "" );
//:IF RESULT < zCURSOR_SET
if ( RESULT < zCURSOR_SET )
{
//:CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER )
CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER );
//:SetMatchingAttributesByName ( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL )
SetMatchingAttributesByName( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL );
}
//:END
//:// If the operation is new or modifiable, set new parameters and operation code.
//:IF NewOperGrp.Operation.DoNotMergeFlag = ""
if ( CompareAttributeToString( NewOperGrp, "Operation", "DoNotMergeFlag", "" ) == 0 )
{
//:FOR EACH NewOperGrp.Parameter
RESULT = SetCursorFirstEntity( NewOperGrp, "Parameter", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:DELETE ENTITY NewOperGrp.Parameter NONE
RESULT = DeleteEntity( NewOperGrp, "Parameter", zREPOS_NONE );
RESULT = SetCursorNextEntity( NewOperGrp, "Parameter", "" );
}
//:END
//:FOR EACH OldOperGrp.Parameter
RESULT = SetCursorFirstEntity( OldOperGrp, "Parameter", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
//:// Make sure the ShortDesc in the Parameter is not null.
//:IF OldOperGrp.Parameter.ShortDesc = ""
if ( CompareAttributeToString( OldOperGrp, "Parameter", "ShortDesc", "" ) == 0 )
{
//:OldOperGrp.Parameter.ShortDesc = "Parm"
SetAttributeFromString( OldOperGrp, "Parameter", "ShortDesc", "Parm" );
}
//:END
//:CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER )
CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER );
//:SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL )
SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL );
RESULT = SetCursorNextEntity( OldOperGrp, "Parameter", "" );
}
//:END
}
RESULT = SetCursorNextEntity( OldOperGrp, "Operation", "" );
//: // Add new Operation Code.
//: // CopyOperationCode
//:END
}
//:END
}
//:END
//:DropObjectInstance( OldOperGrp )
DropObjectInstance( OldOperGrp );
//:CommitMetaOI( vSubtask, NewOperGrp, 14 ) // 14 is zSOURCE_GOPGRP_META
CommitMetaOI( vSubtask, NewOperGrp, 14 );
//:// Build the prototypes in zeidon.h file.
//:RetrieveViewForMetaList( vSubtask, CurrentLPLR, zSOURCE_GOPGRP_META ) // Get view for Merge oper.
RetrieveViewForMetaList( vSubtask, &CurrentLPLR, zSOURCE_GOPGRP_META );
//:ResetViewFromSubobject( CurrentLPLR )
ResetViewFromSubobject( CurrentLPLR );
//:MergeGlobalPrototypes( NewOperGrp,
//: NewOperGrp.GlobalOperationGroup.Name,
//: "GlobalOperationGroup",
//: CurrentLPLR )
GetStringFromAttribute( szTempString_0, NewOperGrp, "GlobalOperationGroup", "Name" );
MergeGlobalPrototypes( NewOperGrp, szTempString_0, "GlobalOperationGroup", CurrentLPLR );
//:DropMetaOI( vSubtask, CurrentLPLR )
DropMetaOI( vSubtask, CurrentLPLR );
return( 0 );
// END
}
