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
UpdateStackObjectFromViews( zVIEW lpInterpSubtask, // interp subtask
zVIEW vXPG, // View to the XPG
zVIEW vStmtView, // View to the statement
zSHORT nIndex, // index into the expression
zSHORT nStackOffset ) // index into the expression
{
zSHORT nRC; // a Return code
zVIEW vStackObject; // view to the stack object
// Get the stack object as it was loaded with the XPG
nRC =
GetViewByName( &vStackObject,
"StackObject",
lpInterpSubtask,
zLEVEL_SUBTASK );
if ( nRC != zLEVEL_SUBTASK )
{
return( -1 );
}
SfLockView( vXPG );
SfLockView( vStmtView );
// set the views
nRC =
SetAttributeFromInteger( vStackObject,
"OperationCall",
"XPGView",
(zLONG)vXPG );
nRC =
SetAttributeFromInteger( vStackObject,
"OperationCall",
"StackOffset",
nStackOffset );
// set the views
nRC =
SetAttributeFromInteger( vStackObject,
"OperationCall",
"StatementView",
(zLONG)vStmtView );
// set the offset
nRC =
SetAttributeFromInteger( vStackObject,
"OperationCall",
"StatementOffset",
nIndex );
return( 0 );
}
zOPER_EXPORT zSHORT OPERATION
ofnTZWDLGSO_AssignTag( zVIEW vSubtask,
zVIEW vDialog,
zVIEW vControl,
zPCHAR szType )
{
zVIEW vTmpDlg;
zLONG lIdx;
zSHORT nLth;
zCHAR szTag[ 25 ];
zstrcpy( szTag, szType );
nLth = zstrlen( szTag );
// Use a temp view for Dialog to make sure we are positioned on the
// Window itself for getting ControlTagCounter and not on a subcontrol.
CreateViewFromViewForTask( &vTmpDlg, vControl, 0 );
ResetView( vTmpDlg );
// Select next integer to make control tag unique.
GetIntegerFromAttribute( &lIdx, vTmpDlg, "Window", "ControlTagCounter" );
lIdx++;
SetAttributeFromInteger( vTmpDlg, "Window", "ControlTagCounter", lIdx );
zltoa( lIdx, &szTag[ nLth ] );
DropView( vTmpDlg );
SetAttributeFromString( vControl, "Control", "Tag", szTag );
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// OPERATION: zwTZERRORD_WriteErrorMsg
//
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT /*LOCAL */ OPERATION
zwTZERRORD_WriteErrorMsg( zVIEW vSubtask,
zVIEW vMetaView,
zPCHAR szMetaEntity,
zPCHAR szMetaAttribute,
zPCHAR szErrorMsg,
zSHORT nError )
{
zVIEW vTZERROR;
zCHAR szMsg[ 255 ];
if ( GetViewByName( &vTZERROR, "TZERROR", vSubtask, zLEVEL_TASK ) < 0 )
{
zwTZERRORD_LoadErrorList( vSubtask );
GetViewByName( &vTZERROR, "TZERROR", vSubtask, zLEVEL_TASK );
}
CreateEntity( vTZERROR, "ErrorMsg", zPOS_LAST );
SetAttributeFromAttribute( vTZERROR, "ErrorMsg", "Name",
vMetaView, szMetaEntity, szMetaAttribute );
if ( nError == 1 )
zstrcpy( szMsg, "Error: " );
else
if ( nError == 0 )
zstrcpy( szMsg, "Warning: " );
zstrcat( szMsg, szErrorMsg );
SetAttributeFromString( vTZERROR, "ErrorMsg", "ErrorText", szMsg );
SetAttributeFromInteger( vTZERROR, "ErrorMsg", "Error", nError );
return( 0 );
} // zwTZERRORD_WriteErrorMsg
///////////////////////////////////////////////////////////////////////
//
// PURPOSE: This function paints the list attributes from the user spec
// into the existing partition.
//
////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zLONG OPERATION
ofnTZWDLGSO_AutoPntFldPartWLits( zVIEW vSubtask,
zVIEW vUserSpec,
zVIEW vNewDialog,
zPCHAR szListType )
{
zVIEW vAutoDesWk;
zVIEW vSubobject;
zVIEW vTempStyle;
zVIEW vCtrlDef;
zLONG k, j;
zLONG lCC, lCL;
zLONG lMaxLines;
zLONG lLine, lFirstPaintLine, lFieldsPainted, lColumn;
zLONG lMaxFieldDLG_X, lMaxText, lPush;
zLONG lGroupDLG_X, lGroupDLG_Y;
zSHORT RESULT;
zLONG lLastPaintLine, lLastWindowLine, lMaxLength;
// zCHAR cUsage[ 1 ];
zCHAR szMapEntity[ 33 ];
zCHAR szMapAttribute[ 33 ];
zCHAR szType[ 33 ];
zCHAR szWorkString[ 256 ];
zCHAR X_LOD_Attribute[ 16 ];
zCHAR X_ER_Attribute[ 15 ];
// TraceLineS( "IN", " AutoPaintPartitionWithFields" );
// Set up variables to either I_LOD listbox or L_LOD listbox.
if ( szListType[ 0 ] == 'I' )
{
zstrcpy( X_LOD_Attribute, "I_LOD_Attribute" );
zstrcpy( X_ER_Attribute, "I_ER_Attribute" );
}
else
{
zstrcpy( X_LOD_Attribute, "L_LOD_Attribute" );
zstrcpy( X_ER_Attribute, "L_ER_Attribute" );
}
// TraceLineS( "IN", " AutoPaintPartitionWithFields" );
GetViewByName( &vCtrlDef, "TZADCTLD", vNewDialog, zLEVEL_TASK );
GetViewByName( &vAutoDesWk, "TZADWWKO", vNewDialog, zLEVEL_TASK );
CreateViewFromViewForTask( &vSubobject, vNewDialog, 0 );
lCL = 12;
lCC = 5;
/* Create a new view that will point to the UIS_ViewObjRef entity
in the user spec object. Sometimes vUserSpec is pointing to a
recursive subobject and UI_ViewObjRef cannot be accessed. */
CreateViewFromViewForTask( &vTempStyle, vUserSpec, 0 );
ResetView( vTempStyle );
SetViewToSubobject( vSubobject, "CtrlCtrl" );
/* Delete any existing fields in the listbox */
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
RESULT = DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
}
GetIntegerFromAttribute( &lMaxLines, vNewDialog, "Control", "SZDLG_Y" );
szMapEntity[ 0 ] = 0;
lFirstPaintLine = 0;
lLastPaintLine = 1;
lLine = 1;
lMaxFieldDLG_X = 0;
lMaxLength = 0;
lMaxText = 0;
lPush = 0;
lFieldsPainted = 0;
// cUsage[ 0 ] = 'U';
/* If there is a paint object, loop through its attributes */
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
/* The last line painted was at this posititon */
lLastPaintLine = lLine;
lColumn = 1;
/* Create the Text Field for the Attribute */
CreateMetaEntity( vSubtask, vSubobject, "Control", zPOS_AFTER );
SetAttributeFromInteger( vSubobject, "Control",
"PSDLG_Y", lLine );
if ( lFirstPaintLine == 0 )
lFirstPaintLine = lLine;
SetAttributeFromInteger( vSubobject, "Control",
"PSDLG_X", lColumn );
/* Creating text field. */
SetCursorFirstEntityByString( vCtrlDef, "ControlDef",
"Tag", "Text", "" );
IncludeSubobjectFromSubobject( vSubobject, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
// Remove the text border.
SetAttributeFromInteger( vSubobject, "Control", "Subtype",
zCONTROL_BORDEROFF | zCONTROL_NOTABSTOP );
GetStringFromAttribute( szWorkString, vUserSpec,
X_ER_Attribute, "ListPaintLit" );
GetStringFromAttribute( szMapAttribute, vUserSpec,
X_ER_Attribute, "Name" );
// If there is no paint literal for this attribute then
// use the attribute name as the paint literal.
if ( szWorkString[ 0 ] == 0 )
zstrcpy( szWorkString, szMapAttribute );
SetAttributeFromString( vSubobject, "Control", "Text", szWorkString );
j = zstrlen( szWorkString );
j = j * lCC;
// Determine the size of the longest paint literal.
if ( j > lMaxText )
lMaxText = j;
SetAttributeFromInteger( vSubobject, "Control", "SZDLG_X", j );
SetAttributeFromInteger( vSubobject, "Control", "SZDLG_Y", lCL );
/* Add the length of the longest paint literal
to the column so the attribute field will be
painted there */
lColumn += j;
lColumn = lColumn + lCC;
// If there is no paint length for the field, then
// use the field's length.
j = ofnTZWDLGSO_GetSizeForListAttr( vSubtask, vUserSpec, szListType );
j = j * lCC;
// If there is no paint length for the field, then
// use the field's length.
if ( j > 100 )
j = 100;
else
if ( j < 25 )
j = 25;
// Create the appropriate Data Field for the Attribute.
CreateMetaEntity( vSubtask, vSubobject, "Control", zPOS_AFTER );
SetAttributeFromInteger( vSubobject, "Control",
"PSDLG_Y", lLine );
SetAttributeFromInteger( vSubobject, "Control",
"PSDLG_X", lColumn );
SetAttributeFromInteger( vSubobject, "Control",
"SZDLG_X", j );
SetAttributeFromInteger( vSubobject, "Control",
"SZDLG_Y", lCL );
// Determine the maximum column length.
if ( lMaxFieldDLG_X < lColumn )
lMaxFieldDLG_X = lColumn;
lColumn += j;
lColumn = lColumn - 1 * lCC;
// Determine the maximum length of colum and literal.
if ( lMaxLength < lColumn )
lMaxLength = lColumn;
SetCursorFirstEntityByString( vCtrlDef, "ControlDef",
"Tag", "EditBox", "" );
IncludeSubobjectFromSubobject( vSubobject, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
// SetAttributeFromInteger( vSubobject, "Control", "Type", 1010 );
/*
if ( cUsage[ 0 ] == 'U' )
{
GetStringFromAttribute( cWork, vUserSpec,
X_LOD_Attribute, "DERIVEDF" );
if ( cWork[ 0 ] != 0 )
SetAttributeFromCharacter( vSubobject,
"Control", "Type", 1000 );
}
*/
/* setting the group and field's ENAME and ANAME */
CreateMetaEntity( vSubtask, vSubobject, "CtrlMap", zPOS_AFTER );
/* set the partitions OI name */
IncludeSubobjectFromSubobject( vSubobject, "CtrlMapView",
vTempStyle, "UIS_ViewObjRef", zPOS_AFTER );
IncludeSubobjectFromSubobject( vSubobject, "CtrlMapLOD_Attribute",
vUserSpec, X_LOD_Attribute, zPOS_AFTER );
lFieldsPainted++;
lLine = lLine + lCL;
RESULT = SetCursorNextEntity( vUserSpec, X_LOD_Attribute, "" );
}
lLastPaintLine = lLine;
/* Get the dimensions of the partition. */
GetIntegerFromAttribute( &lGroupDLG_X, vNewDialog, "Control", "SZDLG_X" );
GetIntegerFromAttribute( &lGroupDLG_Y, vNewDialog, "Control", "SZDLG_Y" );
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
GetIntegerFromAttribute( &lLine, vSubobject, "Control", "PSDLG_Y" );
if ( lLine >= lFirstPaintLine && lLine <= lLastPaintLine )
{
GetStringFromAttribute( szType, vSubobject, "ControlDef", "Tag" );
/* If the control is not a text control. */
if ( zstrcmp( szType, "Text" ) != 0 )
{
GetIntegerFromAttribute( &j, vSubobject, "Control", "PSDLG_X" );
GetIntegerFromAttribute( &k, vSubobject, "Control", "SZDLG_X" );
if ( j < lMaxFieldDLG_X )
{
j = lMaxFieldDLG_X - j;
if ( ( lMaxFieldDLG_X + k ) >
( lMaxLength + lCC ) )
{
if ( ( lMaxFieldDLG_X + k ) <= lGroupDLG_X )
{
lMaxLength = lMaxFieldDLG_X +( k - lCC );
}
else
{
j -=( ( lMaxFieldDLG_X + k ) -
lGroupDLG_X );
if ( j > 0 )
{
AddToAttributeFromInteger( vSubobject, "Control",
"PSDLG_X", j );
lMaxLength = lGroupDLG_X - lCC;
j = -1;
}
}
}
if ( j > 0 )
{
SetAttributeFromInteger( vSubobject, "Control",
"PSDLG_X", lMaxFieldDLG_X );
}
}
}
GetIntegerFromAttribute( &j, vSubobject, "Control", "PSDLG_X" );
GetIntegerFromAttribute( &k, vSubobject, "Control", "SZDLG_X" );
if ( ( j + k ) >= lGroupDLG_X )
{
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
RESULT = DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
}
MessageSend( vNewDialog, "AD10304", "Autodesigner",
"Partition too small( width )",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
/* the partition is not wide enough */
return( -1 );
}
///////////////////////////////////////////////////////////
// Code to truncate fields which extend over the partition to
// the right COMMENTED out. This is a 'too small' error as
// noted above.
// else
// if ( (j + k) >= lGroupDLG_X )
// {
// k =( lGroupDLG_X - 1 ) - j;
// SetAttributeFromInteger( vSubobject, "Control",
// "SZDLG_X", k );
// }
////////////////////////////////////////////////////////////
}
RESULT = SetCursorNextEntity( vSubobject, "Control", "" );
}
lLastWindowLine = lLine;
/* If the window painted has too many lines for the
terminal being used for painting. Attempt to
compress the window into a more manageable size by combining
painted fields which are located on separate lines */
/*
for ( i = 1; i < 8; i++ )
{
if ( lLastWindowLine + 12 <= lMaxLines )
{
break;
}
fnCompressPartition( vNewDialog, i, lFirstPaintLine, lMaxText,
lMaxLines,
&lLastPaintLine, &lLastWindowLine,
&lMaxLength );
}
*/
if ( ( lLastWindowLine + lCL ) > lMaxLines )
{
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
RESULT = DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
}
MessageSend( vNewDialog, "AD10305", "Autodesigner",
"Partition too small( height )",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( -1 );
}
// TraceLineS( "END", " AutoPaintPartitionWithFields" );
/* Return the last paint line for AutoDesign */
return( lLastPaintLine );
}
/////////////////////////////////////////////////////////////////////
//
// PURPOSE: This routine paints selected fields in a list box
// or partition (all the fields are on one line) and paints the
// field literals above the listbox or partition.
//
/////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
ofnTZWDLGSO_AutoPaintListBox( zVIEW vSubtask,
zVIEW vUserSpec,
zVIEW vNewDialog,
zPCHAR szListType )
{
zLONG lCC;
zLONG lCL;
zSHORT nRC;
zLONG lFieldRow;
zLONG lFieldCol;
zLONG lPartitionStartDLG_Y;
zLONG lPartitionStartDLG_X;
zLONG lPartitionSizeDLG_X;
zLONG lSubtype;
zCHAR szParentName[ 33 ];
zLONG lTempInteger_0;
zSHORT RESULT;
//BL zLONG lTempInteger_1;
zCHAR X_LOD_Attribute[ 16 ];
// TraceLineS("IN", "AutoPaintListBox W4" );
// Set up variables to either I_LOD listbox or L_LOD listbox.
if ( szListType[ 0 ] == 'I' )
zstrcpy( X_LOD_Attribute, "I_LOD_Attribute" );
else
zstrcpy( X_LOD_Attribute, "L_LOD_Attribute" );
lCL = 12;
lCC = 5;
zstrcpy( szParentName, "Window" );
lTempInteger_0 = zstrcmp( szParentName, "SECTION" );
/* If we are Autodesigning a ROD, set the lCL to 8 so line skips do
not tak place. */
if ( lTempInteger_0 == 0 )
{
lCL = 8;
}
else
{
lCL = 12;
}
// Set the Tag
ofnTZWDLGSO_AssignTag( vSubtask, vNewDialog, vNewDialog, "ListBox" );
// SetAttributeFromAttribute( vNewDialog, "Control", "Tag",
// vUserSpec, "LOD_Entity", "Name" );
/* Get the group's dimensions. */
GetIntegerFromAttribute( &lPartitionStartDLG_Y, vNewDialog,
"Control", "PSDLG_Y" );
GetIntegerFromAttribute( &lPartitionStartDLG_X, vNewDialog,
"Control", "PSDLG_X" );
GetIntegerFromAttribute( &lPartitionSizeDLG_X, vNewDialog,
"Control", "SZDLG_X" );
/* If the control is a group box not a listbox, then the output
fields should be placed lower down then the listbox's output fields. */
if ( CompareAttributeToString( vNewDialog, "ControlDef", "Tag",
"ListBox" ) == 0 )
lFieldRow = 2;
else
lFieldRow = 5;
lFieldCol = 1;
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
/* Paint the output fields into the listbox or partition. */
nRC = ofnTZWDLGSO_AutoPaintListPart( vSubtask, vUserSpec, vNewDialog,
lFieldRow, lFieldCol,
lPartitionSizeDLG_X, szListType );
#if 0
//* Eliminated 1999/04/23 for support of new listbox style.
/* If the fields fit and there was no other problem, paint the lits. */
if ( nRC > -1 )
{
/* The literals are going to be placed above the listbox
or partition. */
lFieldRow = lPartitionStartDLG_Y - nCL;
lFieldCol = lPartitionStartDLG_X + nCC;
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
/* Paint the literals above the listbox or partition. */
lTempInteger_1 = zstrcmp( szParentName, "Window" );
if ( lTempInteger_1 == 0 )
{
nRC = ofnTZWDLGSO_AutoPaintLstLitPart( vUserSpec, vNewDialog,
lFieldRow, lFieldCol,
lPartitionSizeDLG_X,
szListType );
if ( nRC == -1 )
return( -1 );
}
}
else
{
return( -1 );
}
#endif
// Set listbox to sort and disable first subcontrol.
GetIntegerFromAttribute( &lSubtype, vNewDialog, "Control", "Subtype" );
lSubtype |= zLISTBOX_SORTEDHEADERS;
SetAttributeFromInteger( vNewDialog, "Control", "Subtype", lSubtype );
SetCursorFirstEntity( vNewDialog, "CtrlCtrl", 0 );
GetIntegerFromAttribute( &lSubtype, vNewDialog, "CtrlCtrl", "Subtype" );
lSubtype |= zCONTROL_DISABLED;
SetAttributeFromInteger( vNewDialog, "CtrlCtrl", "Subtype", lSubtype );
// TraceLineS("END", "AutoPaintListBox W4" );
return( nRC );
}
/////////////////////////////////////////////////////////////////////////////
//
// PURPOSE: This function places selected attributes in an already
// existing partition without the attributes text literals.
//
// vNewDialog - handle to the partition
// lFieldRow - offset row in the group
// lFieldCol - offset column in the group
// PartitionSize - length size for the group
//
// Return Codes:
// 0 - Everything is O.K. and the fields were placed into the
// partition
// -1 - The field widths exceeded the partitions width
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
ofnTZWDLGSO_AutoPaintListPart( zVIEW vSubtask,
zVIEW vUserSpec,
zVIEW vNewDialog,
zLONG lFieldRow,
zLONG lFieldCol,
zLONG PartitionSize,
zPCHAR szListType )
{
zVIEW vAutoDesWk;
zVIEW vTempStyle;
zVIEW vSubobject;
zVIEW vCtrlDef;
zLONG lListAttributeLength;
zLONG lPaintLiteralLength;
zLONG lCC;
zLONG lCL;
zCHAR szControlType[ 33 ];
zCHAR szMapEntity[ 33 ];
zCHAR szParentName[ 33 ];
zCHAR szWorkString[ 65 ];
zCHAR szLiteralString[ 65 ];
zLONG lTempInteger_0;
zSHORT RESULT;
zSHORT lFieldsPainted;
zLONG lRC;
zCHAR X_LOD_Attribute[ 16 ];
zCHAR X_LOD_Entity[ 13 ];
zCHAR X_ER_Attribute[ 15 ];
// TraceLineS( "IN", "AutoPaintListPart W4" );
// Set up variables to either I_LOD listbox or L_LOD listbox.
if ( szListType[ 0 ] == 'I' )
{
zstrcpy( X_LOD_Attribute, "I_LOD_Attribute" );
zstrcpy( X_LOD_Entity, "I_LOD_Entity" );
zstrcpy( X_ER_Attribute, "I_ER_Attribute" );
}
else
{
zstrcpy( X_LOD_Attribute, "L_LOD_Attribute" );
zstrcpy( X_LOD_Entity, "L_LOD_Entity" );
zstrcpy( X_ER_Attribute, "L_ER_Attribute" );
}
lCL = 12;
lCC = 5;
GetViewByName( &vCtrlDef, "TZADCTLD", vNewDialog, zLEVEL_TASK );
GetViewByName( &vAutoDesWk, "TZADWWKO", vNewDialog, zLEVEL_TASK );
GetStringFromAttribute( szControlType, vNewDialog, "ControlDef", "Tag" );
/* It is important to know whether the parent is a WINDOW(WDODs)
or a SECTION(RODs). */
zstrcpy( szParentName, "Window" );
/* IF we are Autodesigning a ROD, set lCL to 8 so line
skips do not take place */
lTempInteger_0 = zstrcmp( szParentName, "SECTION" );
if ( lTempInteger_0 == 0 )
{
lCL = 8;
}
/* Create a view that will point to the controls under the listbox. */
CreateViewFromViewForTask( &vSubobject, vNewDialog, 0 );
/* Set handle to the fields under the group */
SetViewToSubobject( vSubobject, "CtrlCtrl" );
/* Delete any existing fields in the listbox */
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
RESULT = DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
}
/* Create a new view that will point to the UIS_ViewObjRef entity
in the user spec object. Sometimes vUserSpec is pointing to a
recursive subobject and UI_ViewObjRef cannot be accessed. */
CreateViewFromViewForTask( &vTempStyle, vUserSpec, 0 );
ResetView( vTempStyle );
lFieldsPainted = 0;
//// Paint the fields in the Partition //////////
/* IF Attributes have been found to paint, paint them */
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
// This gets the length of the field to be painted.
lListAttributeLength = ofnTZWDLGSO_GetSizeForListAttr( vSubtask,
vUserSpec,
szListType );
if ( lListAttributeLength == 0 )
lListAttributeLength = 4;
lListAttributeLength = lListAttributeLength * lCC;
if ( lListAttributeLength > 100 )
lListAttributeLength = 100;
if ( lListAttributeLength < 25 )
lListAttributeLength = 25;
/* If there isn't a paint literal then use the entity name
as the paint literal */
GetStringFromAttribute( szLiteralString, vUserSpec,
X_ER_Attribute, "ListPaintLit" );
if ( szLiteralString[ 0 ] == 0 )
GetStringFromAttribute( szLiteralString, vUserSpec,
X_ER_Attribute, "PromptPaintLit" );
lPaintLiteralLength = zstrlen( szLiteralString );
if ( szLiteralString[ 0 ] == 0 )
{
GetStringFromAttribute( szLiteralString, vUserSpec,
X_ER_Attribute, "Name" );
AddSpacesToString( szLiteralString );
lPaintLiteralLength = zstrlen( szLiteralString ) + 1;
}
lPaintLiteralLength = lPaintLiteralLength * lCC;
if ( lPaintLiteralLength > 100 )
lPaintLiteralLength = 100;
if ( lPaintLiteralLength < 25 )
lPaintLiteralLength = 25;
/* Do not continue to add fields into the partition if
the field sizes exceed the size of the partition */
/* If the field attribute length is greater than the text
literal length, then add the field attribute length
to lFieldCol. */
if ( lPaintLiteralLength < lListAttributeLength )
{
/* If the length of lFieldCol is greater than the
partition size, then delete all the fields that have
been added and give a message to the user. */
if ( lFieldCol + lListAttributeLength > PartitionSize )
{
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
RESULT = SetCursorNextEntity( vSubobject, "Control", "" );
}
DropView( vSubobject );
MessageSend( vUserSpec, "AD10302", "Autodesigner",
"Partition too small( width )",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( -1 );
}
}
else
{
/* If the text literal length is greater than the field
attribute length, then add the text literal length
to lFieldCol. */
/* If the length of lFieldCol is greater than the
partition size, then delete all the fields that have
been added and give a message to the user. */
if ( lFieldCol + lPaintLiteralLength > PartitionSize )
{
RESULT = SetCursorFirstEntity( vSubobject, "Control", "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
DeleteEntity( vSubobject, "Control", zREPOS_NEXT );
RESULT = SetCursorNextEntity( vSubobject, "Control", "" );
}
DropView( vSubobject );
MessageSend( vUserSpec, "AD10303", "Autodesigner",
"Partition too small( width )",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( -1 );
}
}
/* Create the partition's fields */
CreateMetaEntity( vSubtask, vSubobject, "Control", zPOS_AFTER );
SetAttributeFromString( vSubobject, "Control", "Text", szLiteralString );
if ( zstrcmp( szControlType, "ListBox" ) == 0 )
{
SetCursorFirstEntityByString( vCtrlDef, "ControlDef",
"Tag", "ListBoxCtl", "" );
IncludeSubobjectFromSubobject( vSubobject, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
}
else
{
SetCursorFirstEntityByString( vCtrlDef, "ControlDef",
"Tag", "Text", "" );
IncludeSubobjectFromSubobject( vSubobject, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
}
// Set the tag
ofnTZWDLGSO_AssignTag( vSubtask, vNewDialog, vSubobject, "ListCtrl" );
/* GetStringFromAttribute( szTag, vUserSpec, X_ER_Attribute, "Name" );
szTag[ 30 ] = 0;
lFieldsPainted = lFieldsPainted + 1;
zltoa( lFieldsPainted, szWork );
zstrcat( szTag, szWork );
SetAttributeFromString( vSubobject, "Control", "Tag", szTag );
*/
SetAttributeFromInteger( vSubobject, "Control", "SZDLG_X",
lListAttributeLength );
SetAttributeFromInteger( vSubobject, "Control", "SZDLG_Y", lCL );
/* If the domain is an integer or a long, then right justify. */
/*
IF vUserSpec.L_Domain.DerivedDataType = 'I' OR
vUserSpec.L_Domain.DerivedDataType = 'L' OR
vUserSpec.L_Domain.DerivedDataType = 'M'
vNewDialog.FLAGFLD.RJUST = 'Y'
END
*/
GetStringFromAttribute( szMapEntity, vUserSpec, "LOD_Entity", "Name" );
GetStringFromAttribute( szWorkString, vUserSpec, X_LOD_Entity, "Name" );
/* If this LISTATTRIB is from a different ENTITY than the
current ENTITY, then make sure the value gets mapped. */
lRC = zstrcmp( szWorkString, "" );
if ( lRC != 0 )
{
lRC = zstrcmp( szWorkString, szMapEntity );
if ( lRC == 0 )
{
zstrcpy( szMapEntity, szWorkString );
}
}
/* setting the group and field's ENAME and ANAME */
CreateMetaEntity( vSubtask, vSubobject, "CtrlMap", zPOS_AFTER );
/* set the partitions OI name */
if ( szListType[ 0 ] == 'I' )
IncludeSubobjectFromSubobject( vSubobject, "CtrlMapView",
vUserSpec, "ListViewObjRef", zPOS_AFTER );
else
IncludeSubobjectFromSubobject( vSubobject, "CtrlMapView",
vTempStyle, "UIS_ViewObjRef", zPOS_AFTER );
IncludeSubobjectFromSubobject( vSubobject, "CtrlMapLOD_Attribute",
vUserSpec, X_LOD_Attribute, zPOS_AFTER );
/* lFieldRow should always stay the same */
SetAttributeFromInteger( vSubobject, "Control", "PSDLG_X", lFieldCol );
SetAttributeFromInteger( vSubobject, "Control", "PSDLG_Y", lFieldRow );
/* If the field length is longer than the paint literal,
then position the next field by using the field length,
otherwise position the next field by using the paint
literal length */
if ( lPaintLiteralLength < lListAttributeLength )
{
lFieldCol = lFieldCol + lListAttributeLength + lCC;
}
else
{
lFieldCol = lFieldCol + lPaintLiteralLength + lCC;
}
RESULT = SetCursorNextEntity( vUserSpec, X_LOD_Attribute, "" );
}
DropView( vSubobject );
DropView( vTempStyle );
// TraceLineS("END", "AutoPaintListPart W4" );
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// PURPOSE: This function places the paint literals of selected
// attributes above the fields in a partition or list box.
//
// vNewDialog - handle to the group
// OffsetDLG_Y - offset row to the group
// OffsetDLG_X - offset column to the group
// PartitionSize - length size of the group
//
// Return Codes:
// 0 - Everything is O.K. and the literals were placed into the
// partition
// -1 - The literal widths exceeded the partitions width
//
////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
ofnTZWDLGSO_AutoPaintLstLitPart( zVIEW vSubtask,
zVIEW vUserSpec,
zVIEW vNewDialog,
zLONG OffsetDLG_Y,
zLONG OffsetDLG_X,
zLONG PartitionSize,
zPCHAR szListType )
{
zVIEW vCtrlDef;
zLONG lCC;
zLONG lCL;
zLONG lFieldCol;
zLONG lListAttributeLength;
zLONG lPaintLiteralLength;
zCHAR sPaintLiteral[ 65 ];
zSHORT RESULT;
zLONG lTempInteger_1;
zLONG lTempInteger_2;
zCHAR X_LOD_Attribute[ 16 ];
zCHAR X_ER_Attribute[ 15 ];
// TraceLineS("IN", "AutoPaintLstListPart W4" );
// Set up variables to either I_LOD listbox or L_LOD listbox.
if ( szListType[ 0 ] == 'I' )
{
zstrcpy( X_LOD_Attribute, "I_LOD_Attribute" );
zstrcpy( X_ER_Attribute, "I_ER_Attribute" );
}
else
{
zstrcpy( X_LOD_Attribute, "L_LOD_Attribute" );
zstrcpy( X_ER_Attribute, "L_ER_Attribute" );
}
lCC = 5;
lCL = 12;
GetViewByName( &vCtrlDef, "TZADCTLD", vNewDialog, zLEVEL_TASK );
lFieldCol = 1;
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
/* This gets the length of the field to be painted */
lListAttributeLength = ofnTZWDLGSO_GetSizeForListAttr( vSubtask,
vUserSpec,
szListType );
lListAttributeLength = lListAttributeLength * lCC;
/* Limit the size of the attribute length. */
if ( lListAttributeLength > 100 )
lListAttributeLength = 100;
if ( lListAttributeLength < 25 )
lListAttributeLength = 25;
/* Get the paint literal */
GetStringFromAttribute( sPaintLiteral, vUserSpec,
X_ER_Attribute, "ListPaintLit" );
if ( sPaintLiteral[ 0 ] == 0 )
GetStringFromAttribute( sPaintLiteral, vUserSpec,
X_ER_Attribute, "PromptPaintLit" );
if ( sPaintLiteral[ 0 ] == 0 )
{
GetStringFromAttribute( sPaintLiteral, vUserSpec,
X_ER_Attribute, "Name" );
/* Add a ':' to the end. */
zstrcat( sPaintLiteral, ":" );
/* Add spaces before any capital letters. */
AddSpacesToString( sPaintLiteral );
}
lPaintLiteralLength = zstrlen( sPaintLiteral );
lPaintLiteralLength = lPaintLiteralLength * lCC;
/* Limit the size of the literal length. */
if ( lPaintLiteralLength > 100 )
lPaintLiteralLength = 100;
if ( lPaintLiteralLength < 25 )
lPaintLiteralLength = 25;
/*
lTempInteger_1 = CheckForOverlappingFields( vNewDialog, OffsetDLG_Y,
OffsetDLG_Y + nCL,
lFieldCol + OffsetDLG_X - lCC, lFieldCol + OffsetDLG_X + lPaintLiteralLength - lCC );
*/
lTempInteger_1 = 0;
/* Check to see IF there is a field or group located above
the listbox that would be in the way of painting the literals */
if ( lTempInteger_1 == -1 )
{
/* Cannot place text fields above the listbox because of
either a field or a group */
/* InformationMessage( "Field literals can't fit because of FIELD or GROUP" ); */
MessageSend( vUserSpec, "AD10301", "Autodesigner",
"Field literals can't fit because of FIELD or GROUP",
zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP );
return( -1 );
}
/* Add the listbox literals at the end of the client fields.
This makes a difference in fnCompressWindow in autodesigning.*/
SetCursorLastEntity( vNewDialog, "Control", "" );
/* Do not continue to add fields into the list box if
the field sizes exceed the size of the list box */
/* If the field attribute length is greater than the text
literal length, then add the field attribute length
to lFieldCol. */
if ( lPaintLiteralLength < lListAttributeLength )
{
/* If the length of lFieldCol is greater than the
partition size, then RETURN */
if ( lFieldCol + lListAttributeLength > PartitionSize )
{
return( 1 );
}
}
else
{
/* If the length of lFieldCol is greater than the
partition size, then RETURN */
if ( lFieldCol + lPaintLiteralLength > PartitionSize )
{
return( 1 );
}
}
/* Create literals for the list box */
CreateMetaEntity( vSubtask, vNewDialog, "Control", zPOS_AFTER );
SetCursorFirstEntityByString( vCtrlDef, "ControlDef", "Tag", "Text", "" );
IncludeSubobjectFromSubobject( vNewDialog, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
/* Remove the text border. */
SetAttributeFromInteger( vNewDialog, "Control", "Subtype",
zCONTROL_BORDEROFF | zCONTROL_NOTABSTOP );
SetAttributeFromInteger( vNewDialog, "Control",
"PSDLG_Y", OffsetDLG_Y );
lTempInteger_2 = OffsetDLG_X + lFieldCol - lCC;
SetAttributeFromInteger( vNewDialog, "Control",
"PSDLG_X", lTempInteger_2 );
SetAttributeFromInteger( vNewDialog, "Control",
"SZDLG_X", lPaintLiteralLength );
SetAttributeFromInteger( vNewDialog, "Control",
"SZDLG_Y", 10 );
ofnTZWDLGSO_AssignTag( vSubtask, vNewDialog, vNewDialog, "ListText" );
SetAttributeFromString( vNewDialog, "Control",
"Text", sPaintLiteral );
/* If the field length is longer than the paint literal,
then position the next field by using the field length,
otherwise position the next field by using the paint
literal length */
if ( lPaintLiteralLength < lListAttributeLength )
{
lFieldCol = lFieldCol + lListAttributeLength + lCC;
}
else
{
lFieldCol = lFieldCol + lPaintLiteralLength + lCC;
}
RESULT = SetCursorNextEntity( vUserSpec, X_LOD_Attribute, "" );
}
// TraceLineS("END", "AutoPaintLstListPart W4" );
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// OPERATION: zofnTZSIXSKO_BldXSKChildEnt
//
// PURPOSE:
//
// TRIGGLODED BY:
// WINDOW: TZZOLODD
// ACTION: OPTION
// NAME: File_Save
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
zofnTZSIXSKO_BldXSKChildEnt ( zVIEW vKZSIXSKO_Root,
zVIEW vKZSIXSKO, zVIEW vTZZOXOD1,
zVIEW vTZTENVRO_REF,
zSHORT nEntityFlag )
{
zVIEW vTZTENVRO_Parent;
zSHORT nRC;
zSHORT nRC2;
zPCHAR szDBMS;
zSHORT nEntImpls;
zLONG lEntityZKey;
zSHORT nEntitySet = nEntityFlag;
zSHORT nSetViewToSubXsk = 0;
nRC = CreateViewFromViewForTask( &vTZTENVRO_Parent, vTZTENVRO_REF, 0 );
nRC = zCURSOR_SET;
while ( nRC >= zCURSOR_SET )
{
nRC = SetViewToSubobject( vTZZOXOD1, "CHILDENTITY" );
/* Check physik, if no, then do not process this entity */
if ( (nRC = CheckExistenceOfEntity ( vTZZOXOD1, "DATARECORD" )) >= zCURSOR_SET )
{
nRC = GetIntegerFromAttribute( &lEntityZKey, vTZZOXOD1,
"ENTITY", "ERENT_TOK" );
nRC = SetCursorFirstEntityByInteger( vTZTENVRO_Parent, "ER_Entity",
"ZKey", lEntityZKey,
"TE_DBMS_Source" );
if ( nRC < zCURSOR_SET )
{
GetAddrForAttribute( &szDBMS,
vTZTENVRO_Parent, "TE_DBMS_Source", "DBMS" );
nEntImpls = 0;
for ( nRC = SetCursorFirstEntityByInteger( vTZTENVRO_Parent, "ER_Entity",
"ZKey", lEntityZKey,
"TE_DB_Environ" );
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntityByInteger( vTZTENVRO_Parent, "ER_Entity",
"ZKey", lEntityZKey,
"TE_DB_Environ" ) )
{
if ( CompareAttributeToString( vTZTENVRO_Parent, "TE_DBMS_Source", "DBMS",
szDBMS ) == 0 )
{
nEntImpls++;
}
}
if ( nEntImpls == 1 )
{
nRC = zCURSOR_SET;
}
else
if ( nEntImpls > 1 )
{
for ( nRC = SetCursorFirstEntityByInteger( vTZTENVRO_Parent, "ER_Entity",
"ZKey", lEntityZKey,
"TE_DB_Environ" );
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntityByInteger( vTZTENVRO_Parent, "ER_Entity",
"ZKey", lEntityZKey,
"TE_DB_Environ" ) )
{
if ( CompareAttributeToString( vTZTENVRO_Parent, "TE_DBMS_Source", "DBMS",
szDBMS ) == 0 )
{
zstrcpy( szMsg, "Do you want to use Data Source '" );
GetAddrForAttribute( &szMsgName,
vTZTENVRO_Parent, "TE_DBMS_Source", "Name" );
zstrcat( szMsg, szMsgName );
zstrcat( szMsg, "' to implement ER Entity '" );
GetAddrForAttribute( &szMsgName,
vTZTENVRO_Parent, "ER_Entity", "Name" );
zstrcat( szMsg, szMsgName );
zstrcat( szMsg, "'?" );
nRC = MessagePrompt ( vTZTENVRO_Parent, "XOD_06", "TE Choice",
szMsg, 0, zBUTTONS_YESNO, 0, 0 );
if ( nRC == zRESPONSE_YES )
break; // found Entity implemented in same DBMS
}
}
}
if ( nRC < zCURSOR_SET )
{
zstrcpy( szMsg, "Unable to Find Entity in TE Data Source with same DBMS.\n\nEntity Name = " );
GetAddrForAttribute( &szMsgName, vTZZOXOD1, "ER_EntityRec", "Name" );
zstrcat( szMsg, szMsgName );
nRC = MessagePrompt( vTZZOXOD1, "XOD_06", "Internal LOD Error", szMsg, 0,
zBUTTONS_OK, 0, 0 );
nRC = DropView( vTZTENVRO_Parent );
return( 0 );
}
}
// new Entity found
// if SironGroup exists
// if SironKatalog exists
// create new Katalog
// create next ENTITY and ENTITYCOM entities
// create dependent ATTRIB and ATTRICOM entities
nRC = CheckExistenceOfEntity ( vTZTENVRO_Parent, "SironGroup" );
if ( nRC >= zCURSOR_SET )
{
nRC = CheckExistenceOfEntity ( vTZTENVRO_Parent, "SironKatalog" );
if ( nRC >= zCURSOR_SET )
{
// Go back to KATALOG entity
if ( nEntitySet )
{
while ( ResetViewFromSubobject( vKZSIXSKO_Root ) == 0 );
}
// Create new KATALOG entity
nRC = SetCursorLastEntity ( vKZSIXSKO_Root, "KATALOG", "" );
nRC = CreateEntity ( vKZSIXSKO_Root, "KATALOG", zPOS_AFTER );
SetMatchingAttributesByName(vKZSIXSKO_Root, "KATALOG",
vTZTENVRO_Parent, "SironKatalog", zSET_ALL );
for ( nRC = SetCursorFirstEntity( vTZTENVRO_Parent,
"KatalogComment", "SironKatalog");
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntity( vTZTENVRO_Parent,
"KatalogComment", "SironKatalog") )
{
CreateEntity ( vKZSIXSKO_Root, "KATCOM", zPOS_AFTER );
SetMatchingAttributesByName( vKZSIXSKO_Root, "KATCOM",
vTZTENVRO_Parent, "KatalogComment", zSET_ALL );
}
}
// ViewToSubobject only, if caller created an ENTITY entity
if ( nEntitySet )
{
if ( CheckExistenceOfEntity( vKZSIXSKO_Root, "ENTITY" )
>= zCURSOR_SET )
{
SetViewToSubobject( vKZSIXSKO_Root, "ENTITYCHILD" );
nSetViewToSubXsk = 1;
}
}
// Create next ENTITY entity
nRC = SetCursorLastEntity ( vKZSIXSKO_Root, "ENTITY", "" );
nRC = CreateEntity ( vKZSIXSKO_Root, "ENTITY", zPOS_AFTER );
nEntitySet = 1;
SetMatchingAttributesByName(vKZSIXSKO_Root, "ENTITY",
vTZTENVRO_Parent, "SironGroup", zSET_ALL );
SetAttributeFromInteger( vKZSIXSKO_Root, "ENTITY", "ERENT_TOK",
lEntityZKey );
for ( nRC = SetCursorFirstEntity( vTZTENVRO_Parent, "GroupComment", "SironGroup");
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntity( vTZTENVRO_Parent, "GroupComment", "SironGroup") )
{
CreateEntity ( vKZSIXSKO_Root, "ENTITYCOM", zPOS_AFTER );
SetMatchingAttributesByName( vKZSIXSKO_Root, "ENTITYCOM",
vTZTENVRO_Parent, "GroupComment", zSET_ALL );
}
// Create all dependent ATTRIB entities according to XOD ATTRIB
// entities
for ( nRC = SetCursorFirstEntity( vTZZOXOD1, "ATTRIB", "ENTITY");
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntity( vTZZOXOD1, "ATTRIB", "ENTITY") )
{
nRC = SetCursorFirstEntityByAttr( vTZTENVRO_Parent,
"TE_FieldDataRel","Name",
vTZZOXOD1, "ATTRIB", "NAME",
"TE_TablRec");
nRC = CheckExistenceOfEntity( vTZTENVRO_Parent, "SironField" );
if ( nRC < zCURSOR_SET )
{
zstrcpy( szMsg,
"Unable to Find SironField in TE Data Source .\n\nAttribute Name = " );
GetAddrForAttribute( &szMsgName, vTZZOXOD1, "ATTRIB", "NAME" );
zstrcat( szMsg, szMsgName );
nRC = MessagePrompt ( vTZZOXOD1, "XOD_06",
"Internal XOD Error", szMsg,
0, zBUTTONS_OK, 0, 0 );
nRC = DropView( vTZTENVRO_Parent );
return( 0 );
}
CreateEntity( vKZSIXSKO_Root, "ATTRIB", zPOS_AFTER );
SetMatchingAttributesByName( vKZSIXSKO_Root, "ATTRIB",
vTZTENVRO_Parent, "SironField", zSET_ALL );
SetAttributeFromAttribute( vKZSIXSKO_Root, "ATTRIB", "XVAATT_TOK",
vTZZOXOD1, "ATTRIB", "XVAATT_TOK" );
// Create all dependent ATTRIBCOM entities
for ( nRC = SetCursorFirstEntity( vTZTENVRO_Parent,
"SironFieldComment","SironField");
nRC > zCURSOR_UNCHANGED;
nRC = SetCursorNextEntity( vTZTENVRO_Parent,
"SironFieldComment","SironField"))
{
CreateEntity ( vKZSIXSKO_Root, "ATTRIBCOM", zPOS_AFTER );
SetMatchingAttributesByName( vKZSIXSKO_Root, "ATTRIBCOM",
vTZTENVRO_Parent, "SironFieldComment",
zSET_ALL );
}
}
}
}
// Abstieg des Pfades
nRC = CheckExistenceOfEntity( vTZZOXOD1, "CHILDENTITY" );
if ( nRC >= zCURSOR_SET )
zofnTZSIXSKO_BldXSKChildEnt( vKZSIXSKO_Root, vKZSIXSKO,
vTZZOXOD1, vTZTENVRO_Parent, nEntitySet );
nRC2 = ResetViewFromSubobject( vTZZOXOD1 );
if ( nSetViewToSubXsk )
{
nRC2 = ResetViewFromSubobject( vKZSIXSKO_Root );
nSetViewToSubXsk = 0;
}
nRC = SetCursorNextEntity( vTZZOXOD1, "CHILDENTITY", "" );
}
if ( vTZTENVRO_Parent )
nRC = DropView( vTZTENVRO_Parent );
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// 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: EnqueueInstance
//
// PARAMETERS: zVIEW vInstance - View to the instance to be enqueued
// zPCHAR szEntityNames - A string containing 1 or
// more entity names on which to enqueue
// the instance. The first entity name
// MUST BE the root of the object and
// the remaining entity names MUST be
// separated by the plus '+' character.
//
// RETURN CODES: 0 - Enqueue successful
// 1 - Enqueue unsuccessful, the instance is already
// Enqueued
// zCALL_ERROR - Enqueue unsuccessful, error in processing
//
/////////////////////////////////////////////////////////////////////////////
zSHORT OPERATION
EnqueueInstance( zVIEW vInstance, zPCHAR szEntityNames )
{
zVIEW vEnqueue;
zVIEW vEnqueueHolder;
zVIEW vQual;
zVIEW vWkInstance;
zPCHAR szEntityNamePtr;
zCHAR szCurrentEntity[ 34 ];
zCHAR szLevel[ 2 ];
zSHORT nEntity, nEnqueue, nIdx, nRC, nRetries;
zLONG lER_Token;
zCHAR szTimestamp[ 6 ];
zCHAR szObjectName[ 34 ];
zCHAR szUserID[ 34 ];
zCHAR szPassword[ 34 ];
zCHAR szKey[ 64 ];
zCHAR szMsg[ 256 ];
// We put the enqueue logic in a for loop so we can restart the
// enqueue if the enqueue fails and we cannot find the owner of
// the enqueue.
nRetries = 4;
if ( MiGetObjectNameForView( szObjectName, vInstance ) < 0 )
return( zCALL_ERROR );
for ( ; ; )
{
// Set up work variables
szEntityNamePtr = szEntityNames;
_fstrcpy( szLevel, "R" );
nEntity = nEnqueue = 0;
// Set up a multiple root instance for enqueueing
if ( ActivateEmptyObjectInstance( &vEnqueue, szlCGENQUEU,
vInstance, zMULTIPLE ) != 0 )
{
return( zCALL_ERROR );
}
// Create a view on the instance so we do not step on the applications
// cursor positions.
CreateViewFromViewForTask( &vWkInstance, vInstance, 0 );
// Get timestamp and user information for enqueue
MiGetDateTimeForOI( szTimestamp, vWkInstance );
SysGetUserID( vInstance, szUserID, szPassword );
if ( szUserID[ 0 ] == 0 )
_fstrcpy( szUserID, "(null)" );
// Loop for each entity type to be enqueued
while ( szEntityNamePtr[ 0 ] )
{
// Gather the next entity name on which to enqueue
nIdx = 0;
while ( szEntityNamePtr[ 0 ] && szEntityNamePtr[ 0 ] != '+' )
{
szCurrentEntity[ nIdx++ ] = szEntityNamePtr[ 0 ];
szEntityNamePtr++;
}
szCurrentEntity[ nIdx ] = 0;
if ( szEntityNamePtr[ 0 ] == '+' )
szEntityNamePtr++;
nEntity++;
// Now that an entity name has been gathered, troll the instance
// for every occurrence of that entity type and create an
// enqueue instance for it
nRC = SetCursorFirstEntity( vWkInstance, szCurrentEntity,
zSCOPE_OI );
if ( nRC == zCALL_ERROR )
{
DropView( vWkInstance );
DropObjectInstance( vEnqueue );
return( zCALL_ERROR );
}
if ( nRC >= zCURSOR_SET )
{
lER_Token = MiGetERTokenForEntity( vWkInstance, szCurrentEntity );
do
{
// Set up an enqueue instance, The ER_Token and the Instance
// key are the unique keys to the object, a duplicate instance
// on the database will result in an enqueue failure with the
// instance in use. The UserID combined with the Timestamp is
// the non-unique key for deletion of a logical enqueue.
// The object name and level ( 'R' - root, 'C' - child ) are
// informational only.
CreateEntity( vEnqueue, szlEnqueue, zPOS_AFTER );
SetAttributeFromInteger( vEnqueue,
szlEnqueue, szlER_Token, lER_Token );
MiGetKeyFromInstance( szKey, 61, vWkInstance, szCurrentEntity );
SetAttributeFromString( vEnqueue, szlEnqueue, szlInstanceKey,
szKey );
SetAttributeFromVariable( vEnqueue, szlEnqueue, szlTimestamp,
szTimestamp, zTYPE_DATETIME,
6, 0, 0 );
SetAttributeFromString( vEnqueue, szlEnqueue, szlType,
"U" );
SetAttributeFromString( vEnqueue, szlEnqueue, szlUser,
szUserID );
SetAttributeFromString( vEnqueue, szlEnqueue, szlObject,
szObjectName );
SetAttributeFromString( vEnqueue, szlEnqueue, szlLevel,
szLevel );
nEnqueue++;
} while ( SetCursorNextEntity( vWkInstance, szCurrentEntity,
zSCOPE_OI ) >= zCURSOR_SET );
}
// After processing an entity type, all other enqueues are at the
// child level
szLevel[ 0 ] = 'C';
}
// Now that we're done gathering the enqueue information, we can drop
// the view to the instance
DropView( vWkInstance );
// The enqueue instance has been built, now it is time to insert it
// into the database for locking the instance.
nRC = CommitObjectInstance( vEnqueue );
if ( nRC != zDUPLICATE_ROOT )
{
DropObjectInstance( vEnqueue );
return( nRC );
}
// The enqueue failed, now we will determine the owner of the enqueue
// to see if we are conflicting with ourself or to report the owner
// to the enqueue requestor
SetCursorFirstEntity( vEnqueue, szlEnqueue, 0 );
do
{
fnBuildQualForEnqueue( vEnqueue, &vQual );
nRC = ActivateObjectInstance( &vEnqueueHolder, szlCGENQUEU,
vInstance, vQual, zSINGLE );
DropObjectInstance( vQual );
if ( nRC < -1 )
return( zCALL_ERROR );
else
if ( nRC >= 0 )
break;
else
DropObjectInstance( vEnqueueHolder );
} while ( SetCursorNextEntity( vEnqueue, szlEnqueue, 0 ) >= zCURSOR_SET );
// If the enqueue holder was not found, then the enqueue may have
// disappeared while trying to find the holder, retry the enqueue
// operation.
nRetries--;
if ( nRC == -1 )
{
if ( nRetries == 0 )
return( zCALL_ERROR );
}
// Report on the enqueue holder
GetStringFromAttribute( szKey, vEnqueueHolder, szlEnqueue, szlUser );
GetStringFromAttribute( &szKey[ 30 ],
vEnqueueHolder, szlEnqueue, szlObject );
// if the current enqueue holder is the current user for the
// same object type, then offer to drop the previous enqueue and
// re-establish the enqueue for the current user
if ( _fstrcmp( szUserID, szKey ) == 0 &&
_fstrcmp( szObjectName, &szKey[ 30 ] ) == 0 && nRetries )
{
// we will retry this once and once only
nRetries = 1;
_fstrcpy( szMsg, "The " );
_fstrcat( szMsg, szObjectName );
_fstrcat( szMsg, " is already enqueued by you in this session or"
" a previous session. Would you like to release"
" the previously held enqueue?" );
nRC = MessagePrompt( vInstance, "1", szlEnqueue, szMsg, 0,
zBUTTONS_YESNO, zRESPONSE_YES,
zICON_QUESTION );
if ( nRC == zRESPONSE_NO )
{
DropObjectInstance( vEnqueue );
DropObjectInstance( vEnqueueHolder );
return( 1 );
}
// The user wants to delete a previous enqueue for the same
// object type, build the qualification for the delete and remove
// the prior enqueue.
fnBuildQualForEnqueueDelete( vEnqueueHolder, &vQual );
DropObjectInstance( vEnqueueHolder );
nRC = ActivateObjectInstance( &vEnqueueHolder, szlCGENQUEU,
vInstance, vQual, zMULTIPLE );
DropObjectInstance( vQual );
if ( nRC < 0 )
return( zCALL_ERROR );
nRC = SetCursorFirstEntity( vEnqueueHolder, szlEnqueue, 0 );
while ( nRC >= zCURSOR_SET )
nRC = DeleteEntity( vEnqueueHolder, szlEnqueue, zREPOS_NEXT );
nRC = CommitObjectInstance( vEnqueueHolder );
DropObjectInstance( vEnqueueHolder );
// If the attempt to reuse the enqueue failed on a database error,
// return that error. Otherwise, return zero ==> the enqueue was
// reused.
if ( nRC < 0 )
return( zCALL_ERROR );
else
return( 0 );
}
else
{
// Report on the owner of the enqueue
_fstrcpy( szMsg, "The " );
_fstrcat( szMsg, szObjectName );
_fstrcat( szMsg, " is currently in use by " );
_fstrcat( szMsg, szKey );
if ( _fstrcmp( szObjectName, &szKey[ 30 ] ) != 0 )
{
_fstrcat( szMsg, " under the object " );
_fstrcat( szMsg, &szKey[ 30 ] );
}
_fstrcat( szMsg, "." );
MessagePrompt( vInstance, "1", szlEnqueue, szMsg, 0,
zBUTTONS_OK, zRESPONSE_OK, 0 );
DropObjectInstance( vEnqueue );
DropObjectInstance( vEnqueueHolder );
return( 1 );
}
} // End of for loop for enqueueing
// If we reach here, then the enqueue was in use and failed.
return( 1 );
}
/*************************************************************************************************
**
** 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
//
// OPERATION: SetStackObjectFromViews
//
// DESCRIPTION: SetStackObjectFromViews creates an operation entity in the
// Stack call object an copies all of the variable data thers as well.
//
//
//
zOPER_EXPORT zSHORT OPERATION
SetStackObjectFromViews( zVIEW lpInterpSubtask, // interp subtask
zVIEW vXPG, // View to the XPG
zVIEW vStmtView, // View to the statement
zSHORT nIndex ) // index into the expression
{
zSHORT nRC; // a Return code
//zSHORT nPrevOperation; // a ret code
zVIEW vStackObject; // view to the stack object
//zVIEW vPriorOperation; // view to the prior operation in the stack object
// Get the stack object as it was loaded with the XPG
nRC =
GetViewByName( &vStackObject,
"StackObject",
lpInterpSubtask,
zLEVEL_SUBTASK );
if ( nRC != zLEVEL_SUBTASK )
{
return( -1 );
}
SfLockView( vXPG );
SfLockView( vStmtView );
// DGC 8/19/02
// vPriorOperation doesn't appear to be used outside of this function, so
// I'm removing the code.
#if 0
nRC =
CreateViewFromViewForTask( &vPriorOperation,
vStackObject, 0 );
nPrevOperation =
SetCursorPrevEntity( vPriorOperation,
"OperationCall", "" );
#endif
if ( SetCursorFirstEntityByAttr( vStackObject, "OperationCall", "Name",
vXPG, "Operation", "Name", 0 ) < zCURSOR_SET )
{
// create an operation entity at the end of the list ( stack )
CreateEntity( vStackObject, "OperationCall", zPOS_AFTER );
// set the name of the operation that was called.
SetAttributeFromAttribute( vStackObject, "OperationCall", "Name",
vXPG, "Operation", "Name" );
}
// set the views
SetAttributeFromInteger( vStackObject, "OperationCall", "XPGView",
(zLONG) vXPG );
// set the views
SetAttributeFromInteger( vStackObject, "OperationCall", "StatementView",
(zLONG) vStmtView );
// set the offset
SetAttributeFromInteger( vStackObject, "OperationCall", "StatementOffset",
nIndex );
// now loop through and do all of the variables
for ( nRC = SetCursorFirstEntity( vXPG, "Variable", "" );
nRC >= zCURSOR_SET;
nRC = SetCursorNextEntity( vXPG, "Variable", "" ) )
{
// Check to see if the variable already exists in the stack object. It
// will exist if the interpreter is being called from a different app
// (like Core) and the app has set up the arguments already.
if ( SetCursorFirstEntityByAttr( vStackObject, "Variable", "Name",
vXPG, "Variable", "Name", 0 ) < zCURSOR_SET )
{
CreateEntity( vStackObject, "Variable", zPOS_LAST );
}
SetMatchingAttributesByName( vStackObject, "Variable",
vXPG, "Variable", zSET_NULL );
}
SetCursorFirstEntity( vStackObject, "Variable", "" );
SetCursorFirstEntity( vXPG, "Variable", "" );
// DropView( vPriorOperation );
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 );
}
}
/////////////////////////////////////////////////////////////////////////////
//
// ENTRY: CreateListBox
//
// PURPOSE: This function creates a listbox with the given
// specifications and then autodesigns this listbox with
// the LISTATTRIB attributes for the listbox's entity.
// In addition to auto designing the listbox's fields, any
// actions defined for the listbox(in the style object)
// get autodesigned.
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT OPERATION
ofnTZWDLGSO_CreateListBox( zVIEW vSubtask,
zVIEW vNewDialog,
zVIEW vUserSpec,
zLONG lStart_X,
zLONG lStart_Y,
zLONG lHeight,
zPCHAR szListType )
{
zVIEW vCtrlDef;
zVIEW vTZPNCTWO;
zLONG lTotalLth;
zLONG lAttribLth;
zLONG lPaintLth;
zLONG lCC;
zLONG lCL;
zSHORT RESULT;
zCHAR szPaintStr[ 50 ];
zCHAR X_LOD_Attribute[ 16 ];
zCHAR X_ER_Attribute[ 15 ];
// TraceLineS("IN", "AutoPaintLstListPart W4" );
// Set up variables to either I_LOD listbox or L_LOD listbox.
if ( szListType[ 0 ] == 'I' )
{
strcpy_s( X_LOD_Attribute, zsizeof( X_LOD_Attribute ), "I_LOD_Attribute" );
strcpy_s( X_ER_Attribute, zsizeof( X_ER_Attribute ), "I_ER_Attribute" );
}
else
{
strcpy_s( X_LOD_Attribute, zsizeof( X_LOD_Attribute ), "L_LOD_Attribute" );
strcpy_s( X_ER_Attribute, zsizeof( X_ER_Attribute ), "L_ER_Attribute" );
}
lCC = 5;
lCL = 12;
GetViewByName( &vCtrlDef, "TZADCTLD", vNewDialog, zLEVEL_TASK );
// TraceLineS("IN", "CreateListBox W3" );
/* Create the listbox. */
CreateMetaEntity( vSubtask, vNewDialog, "Control", zPOS_AFTER );
SetCursorFirstEntityByString( vCtrlDef, "ControlDef", "Tag", "ListBox", "" );
IncludeSubobjectFromSubobject( vNewDialog, "ControlDef",
vCtrlDef, "ControlDef", zPOS_AFTER );
SetAttributeFromInteger( vNewDialog, "Control", "PSDLG_X", lStart_X );
SetAttributeFromInteger( vNewDialog, "Control", "PSDLG_Y", lStart_Y );
// We must set the CtrlBOI.
ActivateEmptyObjectInstance( &vTZPNCTWO, "TZPNCTWO",
vUserSpec, zSINGLE );
CreateEntity( vTZPNCTWO, "TZPNCTWO", zPOS_AFTER );
CreateEntity( vTZPNCTWO, "ListBox", zPOS_AFTER );
SetAttributeFromInteger( vTZPNCTWO, "ListBox", "Subtype", 8192 );
// Set Control.CtrlBOI from work entity GroupBox
SetBlobFromEntityAttributes( vNewDialog, "Control",
"CtrlBOI", vTZPNCTWO, "ListBox" );
DropView( vTZPNCTWO );
// Set the control subtype to 0(Single).
SetAttributeFromInteger( vNewDialog, "Control", "Subtype", 8192 );
lTotalLth = 0;
if ( CheckExistenceOfEntity ( vUserSpec, X_LOD_Attribute ) != 0 )
lTotalLth = 5;
// Loop through the L_LOD_Attribute and find the total width needed
// for this listbox.
RESULT = SetCursorFirstEntity( vUserSpec, X_LOD_Attribute, "" );
while ( RESULT > zCURSOR_UNCHANGED )
{
lAttribLth = ofnTZWDLGSO_GetSizeForListAttr( vSubtask, vUserSpec,
szListType );
if ( lAttribLth > 20 )
lAttribLth = 20;
if ( lAttribLth < 5 )
lAttribLth = 5;
GetStringFromAttribute( szPaintStr, zsizeof( szPaintStr ), vUserSpec,
X_ER_Attribute, "ListPaintLit" );
if ( szPaintStr[ 0 ] == 0 )
{
GetStringFromAttribute( szPaintStr, zsizeof( szPaintStr ), vUserSpec,
X_ER_Attribute, "PromptPaintLit" );
}
if ( szPaintStr[ 0 ] == 0 )
{
GetStringFromAttribute( szPaintStr, zsizeof( szPaintStr ), vUserSpec,
X_ER_Attribute, "Name" );
/* Add a ':' to the end. */
strcat_s( szPaintStr, zsizeof( szPaintStr ), ":" );
/* Add spaces before any capital letters. */
AddSpacesToString( szPaintStr );
}
lPaintLth = zstrlen( szPaintStr );
if ( lPaintLth > 20 )
lPaintLth = 20;
if ( lPaintLth < 5 )
lPaintLth = 5;
if ( lAttribLth > lPaintLth )
lTotalLth = lTotalLth + lAttribLth + 1;
else
lTotalLth = lTotalLth + lPaintLth + 1;
RESULT = SetCursorNextEntity( vUserSpec, X_LOD_Attribute, "" );
}
lTotalLth ++;
SetAttributeFromInteger( vNewDialog, "Control",
"SZDLG_X", lTotalLth * lCC );
SetAttributeFromInteger( vNewDialog, "Control", "SZDLG_Y", lHeight );
// TraceLineS("END", "CreateListBox W3" );
return( 0 );
}
zOPER_EXPORT zLONG OPERATION
SyntaxError( zVIEW vSubtask, zLONG lErrorNumber, zPCHAR szErrorString )
{
zVIEW vError;
zVIEW vSearchError;
zBOOL bFound;
zBOOL bDone;
zCHAR szMessage[ 256 ];
zCHAR szNum[ 10 ];
zLONG lRC;
if ( GetViewByName( &vError, "TZVMEROO", vSubtask, zLEVEL_TASK ) > 0 )
{
// IssueError( vError, 0, 0, "Syntax Error" );
// build msc type error message
GetStringFromAttribute( szMessage, vError, "Root", "SourceFileName" );
zstrcat( szMessage, "(" );
zltoa( qqlineno, szNum );
zstrcat( szMessage, szNum );
zstrcat( szMessage, ") : error " );
zltoa( lErrorNumber, szNum );
zstrcat( szMessage, szNum );
zstrcat( szMessage, ": " );
zstrcat( szMessage, g_szMessages[ lErrorNumber - 501 ] );
switch ( lErrorNumber )
{
case eQINVALIDFUNCTIONPARAM /*553*/:
case eQINVALIDFUNCTIONDEF /*554*/ :
case 556:
break;
default:
zstrcat( szMessage, " Last Token " );
if ( !szErrorString || !szErrorString[ 0 ] )
zstrcat( szMessage, sQToken.szToken );
}
zstrcat( szMessage, szErrorString );
// look to see if a similar error message has been posted
// we need to match both nErrorNumber and szErrorString
CreateViewFromViewForTask( &vSearchError, vError, 0 );
bFound = FALSE;
bDone = FALSE;
// Try to find 1st occurrence of current Last Token
lRC = SetCursorFirstEntityByString( vSearchError, "Error", "LastToken", szErrorString, "" );
// if none was found, skip the following loop
if ( lRC < zCURSOR_SET )
bDone = TRUE;
while ( !bDone )
{
// If we have found an occurrence of current Last Token
if ( lRC >= zCURSOR_SET )
{
// check error number
lRC = CompareAttributeToInteger( vSearchError, "Error", "ErrorNumber", lErrorNumber );
// if a match
if ( lRC == 0 )
{
bDone = TRUE;
bFound = TRUE;
}
// otherwise, look again
else
{
lRC = SetCursorNextEntityByString( vSearchError, "Error", "LastToken",
szErrorString, "" );
}
}
// otherwise, no more occurrences of szErrorString found
else
{
// so we quit looking
bDone = TRUE;
}
}
// if a simlar error was NOT previously issued
if ( bFound == FALSE )
{
// put the error in error LOD
CreateEntity( vError, "Error", zPOS_AFTER );
SetAttributeFromString ( vError, "Error", "String", szMessage );
SetAttributeFromString ( vError, "Error", "LastToken", szErrorString );
SetAttributeFromInteger( vError, "Error", "ErrorNumber", lErrorNumber );
// SysWriteLine( g_lfErrorHandle, "------" );
// SysWriteLine( g_lfErrorHandle, "------" );
SysWriteLine( vError, g_lfErrorHandle, szMessage );
}
// drop the search view
DropView( vSearchError );
}
// some errors require the parsing process to be stopped,
// because Object Engine errors would come up.
switch ( lErrorNumber )
{
case eQNOOPERATIONNAMEGIVEN:
SkipRemainingFile( );
TraceLineS( "VML Parsing STOPPED on ERROR --", szMessage );
break;
default:
TraceLineS( "VML Parsing ERROR --", szMessage );
break;
}
return( 0 );
}
/////////////////////////////////////////////////////////////////////////////
//
// CONSTRUCTOR: Tab sub-control (to group controls at the tab level)
//
/////////////////////////////////////////////////////////////////////////////
// ctor
TZNotePage::TZNotePage( TZPainterWindow *pPainterWindow,
TZPainterCtrl *pCtrlParent,
CWnd *pWndParent,
CRect& rect,
zVIEW vCtrl,
zLONG lType,
zBOOL bPlaceHolder,
zLONG lZKey,
zLONG lTabStopNbr,
zLONG lCtrlID,
zPCHAR pchTag,
zPCHAR pchText ) :
CWnd( ),
TZPainterCtrl( pPainterWindow, pCtrlParent, pWndParent,
rect, vCtrl, this, pchTag, pchText,
lType, bPlaceHolder, lZKey, lTabStopNbr, lCtrlID )
{
#ifdef DEBUG_ALL
TraceLineS( "TZNotePage::ctor ", m_csTag );
#endif
m_pNext = 0;
m_uVisible = 0x0100;
m_lSubtype = 0;
m_pZNoteBook = DYNAMIC_DOWNCAST( TZNoteBook, pWndParent );
if ( m_pZNoteBook == 0 )
return;
zPCHAR pch;
zLONG lTabNbr;
zLONG lLth;
if ( vCtrl )
{
GetAddrForAttribute( &pch, vCtrl, szlControl, szlText );
lLth = zstrlen( pch ) + 1;
m_pchCaption = new char[ lLth ];
strcpy_s( m_pchCaption, lLth, pch );
GetIntegerFromAttribute( &lTabNbr, vCtrl, szlControl, szlType );
if ( lTabNbr == 0 )
{
zVIEW vTemp;
m_pZNoteBook->m_nTabNbrMax++;
CreateViewFromViewForTask( &vTemp, vCtrl, pPainterWindow->m_vDialog );
ResetViewFromSubobject( vTemp );
while ( SetCursorFirstEntityByInteger( vTemp, szlCtrlCtrl, szlType,
m_pZNoteBook->m_nTabNbrMax, 0 ) == zCURSOR_SET )
{
m_pZNoteBook->m_nTabNbrMax++;
}
SetAttributeFromInteger( vCtrl, szlControl, szlType, m_pZNoteBook->m_nTabNbrMax );
m_lSubtype = m_pZNoteBook->m_nTabNbrMax;
DropView( vTemp );
}
else
{
if ( lTabNbr > m_pZNoteBook->m_nTabNbrMax )
m_pZNoteBook->m_nTabNbrMax = (zSHORT) lTabNbr;
m_lSubtype = m_pZNoteBook->m_nTabNbrMax;
}
if ( MiGetUpdateForView( vCtrl ) > 0 )
{
SetAttributeFromAttribute( vCtrl, szlControl, szlSyncKey, vCtrl, szlControl, szlType );
}
}
else
{
m_pZNoteBook->m_nTabNbrMax++;
m_lSubtype = m_pZNoteBook->m_nTabNbrMax;
lTabNbr = m_pZNoteBook->m_nTabNbrMax;
lLth = zstrlen( pchText ) + 1;
m_pchCaption = new char[ lLth ];
strcpy_s( m_pchCaption, lLth, pchText );
}
// TraceRect( "TabCtl rect ", rect );
// TraceLineI( " Attr.X ", Attr.X );
// TraceLineI( " Attr.Y ", Attr.Y );
// TraceLineI( " Attr.W ", Attr.W );
// TraceLineI( " Attr.H ", Attr.H );
// Build sub-controls on demand (only when visible or selectable).
m_bBuildOnDemand = TRUE;
if ( m_pZNoteBook->m_pZNotePage )
{
m_nTabIdx = 1;
TZNotePage *pCurrNotePage = m_pZNoteBook->m_pZNotePage;
while ( pCurrNotePage->m_pNext )
{
m_nTabIdx++;
pCurrNotePage = pCurrNotePage->m_pNext;
}
pCurrNotePage->m_pNext = this;
}
else
{
m_nTabIdx = 0;
m_pZNoteBook->m_pZNotePage = this;
}
// m_nTabNbr = (zSHORT) lTabNbr;
m_nTabNbr = m_nTabIdx + 1;
m_pZNoteBook->m_nPageCnt++;
TC_ITEM TabCtrlItem;
TabCtrlItem.mask = TCIF_TEXT;
TabCtrlItem.pszText = m_pchCaption;
#ifdef DEBUG_ALL
TraceLineS( "Adding TabCtrlItem: ", m_pchCaption );
#endif
m_pZNoteBook->InsertItem( m_nTabIdx, &TabCtrlItem );
//?Attr.StyleEx = WS_EX_TRANSPARENT;
//?Attr.Style &= ~(WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
CreateZ( );
}