zOPER_EXPORT void OPERATION
TraceRect( zCPCHAR cpcMessage,
RECT& rect )
{
zCHAR szBuffer[ 256 ];
zSHORT nLth;
nLth = zstrlen( cpcMessage );
if ( nLth < sizeof( szBuffer ) - 32 )
zstrcpy( szBuffer, cpcMessage );
else
nLth = 0;
zstrcpy( szBuffer + nLth, " X:" );
zltoa( rect.left, szBuffer + nLth + 3 );
nLth = zstrlen( szBuffer );
zstrcpy( szBuffer + nLth, " Y:" );
zltoa( rect.top, szBuffer + nLth + 3 );
nLth = zstrlen( szBuffer );
zstrcpy( szBuffer + nLth, " W:" );
zltoa( rect.right - rect.left, szBuffer + nLth + 3 );
nLth = zstrlen( szBuffer );
zstrcpy( szBuffer + nLth, " H:" );
// zltoa( rect.bottom - rect.top, szBuffer + nLth + 3 );
TraceLineI( szBuffer, rect.bottom - rect.top );
}
/////////////////////////////////////////////////////////////////////////////
//
// OPERATION: zwTZERRORD_SetCountError
//
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zSHORT /*DIALOG */ OPERATION
zwTZERRORD_SetCountError( zVIEW vSubtask )
{
zVIEW vTZERROR;
zLONG lCountError;
zLONG lCountWarning;
zSHORT nRC;
zCHAR szCount[ 10 ];
zCHAR szControlText[ 100 ];
if ( GetViewByName( &vTZERROR, "TZERROR", vSubtask, zLEVEL_TASK ) < 0 )
return( -1 );
if ( CheckExistenceOfEntity( vTZERROR, "ErrorList" ) >= zCURSOR_SET )
{
// Set Count Errors to Textfield
lCountError = 0;
lCountWarning = 0;
for ( nRC = SetCursorFirstEntity( vTZERROR, "ErrorMsg", "" );
nRC >= zCURSOR_SET;
nRC = SetCursorNextEntity( vTZERROR, "ErrorMsg", "" ) )
{
if ( CompareAttributeToInteger( vTZERROR, "ErrorMsg", "Error",
1 ) == 0 )
lCountError++;
else
lCountWarning++;
}
zltoa( lCountError, szCount );
zstrcpy( szControlText, " " );
zstrcat( szControlText, szCount );
zstrcat( szControlText, " Error(s) " );
if ( lCountWarning > 0 )
{
zltoa( lCountWarning, szCount );
zstrcat( szControlText, ", " );
zstrcat( szControlText, szCount );
zstrcat( szControlText, " Warning(s) " );
}
zstrcat( szControlText, "found" );
}
else
{
zstrcpy( szControlText, " No Errors" );
}
SetCtrlText( vSubtask, "txtCountError", szControlText );
return( 0 );
} // zwTZERRORD_SetCountError
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 );
}
zOPER_EXPORT zSHORT OPERATION
zwTZCMRPTD_LoadAudittrail( zVIEW vSubtask )
{
zVIEW vTZCMRPTO;
zVIEW vTZBRAUDO;
zVIEW vKZDBHQUA;
zULONG ulZKey;
zCHAR szZKey[18];
zSHORT nRC;
if ( GetViewByName( &vTZCMRPTO, "TZCMRPTO", vSubtask, zLEVEL_TASK ) > 0 )
{
if ( CheckExistenceOfEntity( vTZCMRPTO, "Z_MetaDef" ) == 0 )
{
if ( ActivateEmptyObjectInstance ( &vKZDBHQUA, "KZDBHQUA", vSubtask,
zSINGLE ) >= 0 )
{
SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK );
CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER );
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
}
else
return( -1 );
GetIntegerFromAttribute(( zPLONG )&ulZKey, vTZCMRPTO, "Z_MetaDef", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "Z_MetaDef" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "Z_MetaDef" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
zltoa( ulZKey, szZKey );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey );
nRC = ActivateObjectInstance( &vTZBRAUDO, "TZBRAUDO", vSubtask,
vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION );
DropObjectInstance( vKZDBHQUA );
if ( CheckExistenceOfEntity( vTZBRAUDO, "AuditTrail" ) == 0 )
SetNameForView( vTZBRAUDO, "TZBRAUDO", vSubtask, zLEVEL_TASK );
else
{
MessageSend( vSubtask, "CM00299", "Audit Trail:",
"There are no AuditTrail-Information for the component in this CPLR.",
zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP );
SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 );
return( -1 );
}
}
}
else
return( -1 );
return( 0 );
}
static zSHORT
zwfnTZCMRPTD_LoadNewAudittrail( zVIEW vSubtask, zPVIEW vTZBRAU2O )
{
zVIEW vTZCMCPL;
zVIEW vKZDBHQUA;
zULONG ulZKey;
zCHAR szZKey[18];
zSHORT nRC;
if ( GetViewByName( &vTZCMCPL, "TZCMCPL", vSubtask, zLEVEL_TASK ) < 0 )
return( -1 );
if ( CheckExistenceOfEntity( vTZCMCPL, "CPLR" ) == zCURSOR_SET )
{
if ( ActivateEmptyObjectInstance( &vKZDBHQUA, "KZDBHQUA", vSubtask,
zSINGLE ) >= 0 )
{
SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK );
CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER );
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
}
else
return( -1 );
GetIntegerFromAttribute( (zPLONG)&ulZKey, vTZCMCPL, "CPLR", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "CPLR" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
zltoa( ulZKey, szZKey );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey );
nRC = ActivateObjectInstance( vTZBRAU2O, "TZBRAU2O", vSubtask,
vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION );
DropObjectInstance( vKZDBHQUA );
SetNameForView( *vTZBRAU2O, "TZBRAU2O", vSubtask, zLEVEL_TASK );
}
else
{
MessageSend( vSubtask, "CM00299", "Audit Trail:",
"There are no Audit Trail Information for a non-repository LPLR.",
zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP );
SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 );
return( -1 );
}
return( 0 );
} // zwfnTZCMRPTD_LoadNewAudittrail
/*************************************************************************************************
**
** OPERATION: GetBorderLineWidth
**
*************************************************************************************************/
zOPER_EXPORT zLONG /*GLOBAL */ OPERATION
GetBorderLineWidth( zLONG lBorderStyle,
zPCHAR szWidth )
{
TraceLineS( "*** In GetBorderLineWidth *****", "" );
lBorderStyle >>= 24;
zltoa( lBorderStyle, szWidth );
TraceLineS( "*** szWidth *****", szWidth );
return( 0 );
} // GetBorderLineWidth
zOPER_EXPORT void OPERATION
TraceSize( zCPCHAR cpcMessage,
SIZE& size )
{
zCHAR szBuffer[ 256 ];
zSHORT nLth;
nLth = zstrlen( cpcMessage );
if ( nLth < sizeof( szBuffer ) - 32 )
zstrcpy( szBuffer, cpcMessage );
else
nLth = 0;
zstrcpy( szBuffer + nLth, " cX=" );
zltoa( size.cx, szBuffer + nLth + 4 );
nLth = zstrlen( szBuffer );
zstrcpy( szBuffer + nLth, " cY=" );
// zltoa( size.cy, szBuffer + nLth + 4 );
TraceLineI( szBuffer, size.cy );
}
zOPER_EXPORT void OPERATION
TracePoint( zCPCHAR cpcMessage,
POINT& pt )
{
zCHAR szBuffer[ 256 ];
zSHORT nLth;
nLth = zstrlen( cpcMessage );
if ( nLth < sizeof( szBuffer ) - 32 )
zstrcpy( szBuffer, cpcMessage );
else
nLth = 0;
zstrcpy( szBuffer + nLth, " X=" );
zltoa( pt.x, szBuffer + nLth + 3 );
nLth = zstrlen( szBuffer );
zstrcpy( szBuffer + nLth, " Y=" );
// zltoa( pt.y, szBuffer + nLth + 3 );
TraceLineI( szBuffer, pt.y );
}
zSHORT
ZMLE::LimitTextLength( zULONG ulTextLth )
{
#ifdef DEBUG_ALL
TraceLineS( "ZMLE::LimitTextLength: ", *m_pzsTag );
#endif
if ( ulTextLth >= 0 )
{
m_ulLth = ulTextLth;
if ( mIs_hWnd( m_hWnd ) )
SetLimitText( m_ulLth );
#ifdef zREMOTE_SERVER
zCHAR szTextLth[ 32 ];
zltoa( ulTextLth, szTextLth );
SetRemoteZCtrlAttribute( this, "MLE", "TextLth", szTextLth );
#endif
return( 0 );
}
return( 1 );
}
zSHORT /* LOCAL */ OPERATION
zwTZCMRPTD_LoadDesc_AUX( zVIEW vSubtask,
zLONG CPLR_ZKey,
zPCHAR pszTimeStamp )
{
zVIEW vTZBRAU3O;
zVIEW vKZDBHQUA;
zCHAR szZKey[18];
zSHORT nRC;
if ( GetViewByName( &vTZBRAU3O, "TZBRAU3O", vSubtask, zLEVEL_TASK ) > 0 )
DropObjectInstance( vTZBRAU3O );
if ( ActivateEmptyObjectInstance ( &vKZDBHQUA, "KZDBHQUA", vSubtask,
zSINGLE ) >= 0 )
{
SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK );
CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER );
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
}
else
return( -1 );
// QualAttrib for "WHERE CPLR.ZKey = CPLR_ZKey"
SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "AuditTrail" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
zltoa( CPLR_ZKey, szZKey );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey );
// QualAttrib for "AND"
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "AND" );
// QualAttrib for "WHERE AuditTrail.TimeStamp = pszTimeStamp"
CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "AuditTrail" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "TimeStamp" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", pszTimeStamp );
nRC = ActivateObjectInstance( &vTZBRAU3O, "TZBRAU3O", vSubtask,
vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION );
DropObjectInstance( vKZDBHQUA );
if (CheckExistenceOfEntity( vTZBRAU3O, "AuditTrail" ) == 0 )
SetNameForView( vTZBRAU3O, "TZBRAU3O", vSubtask, zLEVEL_TASK );
else
{
MessageSend( vSubtask, "CM00299", "Audit Trail:",
"There are no AuditTrail-Information for the component.",
zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP );
SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 );
return( -1 );
}
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 );
}
/*************************************************************************************************
**
** 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: AlphaNumericUpperStrip
//
// Strip all non-alphanumerics and upper case all characters
//
/////////////////////////////////////////////////////////////////////////////
zOPER_EXPORT zLONG OPERATION
AlphaNumericUpperStrip( zLONG lEntryType,
LPDOMAINDATA lpDomainData )
{
zSHORT nRC;
zSHORT nWChar;
zCHAR szWorkString[ 512 ];
zPCHAR pszStringToStore;
zPLONG lplInteger;
zLONG lWork;
LPDOMAIN lpDomain;
zCHAR szNullS[ 2 ];
zLONG lNullInteger = -2147483647 - 1;
nRC = zDME_NOT_HANDLED; // Default to not-handled.
szNullS[ 0 ] = 0;
lpDomain = (LPDOMAIN) SysGetPointerFromHandle( lpDomainData->lpViewAttribute->hDomain );
switch ( lEntryType )
{
case zDME_VALIDATE_LPDATA:
case zDME_SET_ATTRIBUTE:
if ( lpDomainData->lpViewAttribute->cType == zTYPE_STRING )
{
szWorkString[ 0 ] = 0;
// determine input data type
switch ( lpDomainData->cType )
{
case zTYPE_STRING:
// string to string
pszStringToStore = (zPCHAR) lpDomainData->lpData;
if ( lpDomainData->lpData == 0 )
pszStringToStore = szWorkString;
break;
case zTYPE_INTEGER:
// convert long to a string
lplInteger = (zPLONG) lpDomainData->lpData;
if ( *lplInteger != lNullInteger )
zltoa( *lplInteger, szWorkString );
pszStringToStore = szWorkString;
break;
case zTYPE_DATETIME:
// convert DateTime to String
nRC = UfDateTimeToString( (LPDATETIME) lpDomainData->lpData,
szWorkString, 18 );
if ( nRC == zCALL_ERROR )
return( nRC );
pszStringToStore = szWorkString;
break;
default:
szWorkString[ 0 ] = lpDomainData->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME001 - Invalid Input Data Type"
SendDomainError( lpDomainData->zView, lpDomain, 8, 1, 0,
szWorkString,
lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
// transfer all alphanumeric characters
zPCHAR psz;
nWChar = 0;
for ( psz = (zPCHAR) lpDomainData->lpData; *psz; psz++ )
{
if ( zisalnum( *psz ) )
{
szWorkString[ nWChar++ ] = ztoupper( *psz );
}
}
szWorkString[ nWChar ] = 0;
// finally store it
if ( lEntryType == zDME_SET_ATTRIBUTE )
{
nRC = StoreValueInRecord( lpDomainData->zView,
lpDomainData->lpViewEntity,
lpDomainData->lpViewAttribute,
szWorkString, 0 );
}
else
nRC = 0;
}
else
{
szWorkString[ 0 ] = lpDomainData->lpViewAttribute->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME003 - Attribute Type invalid for this Domain"
SendDomainError( lpDomainData->zView, lpDomain, 8, 3, 0,
szWorkString,
lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
break;
case zDME_GET_VARIABLE:
if ( lpDomainData->lpViewAttribute->cType == zTYPE_STRING )
{
zPCHAR lpAttrAddr;
zCHAR cAttrType;
zULONG uAttrLength;
if ( lpDomainData->cType != zTYPE_PIC )
{
nRC = GetValueFromRecord( lpDomainData->zView,
lpDomainData->lpViewEntity,
lpDomainData->lpViewAttribute,
&lpAttrAddr, &cAttrType,
&uAttrLength );
if ( nRC )
return( zCALL_ERROR );
}
// determine input data type
switch ( lpDomainData->cType )
{
case zTYPE_STRING:
if ( (zPCHAR) lpAttrAddr == 0 ) //null string
{
*((zPCHAR) lpDomainData->lpData) = 0;
nRC = -1; // indicate attribute is null
}
else
{
*((zPCHAR) lpDomainData->lpData ) = 0;
zstrncat( (zPCHAR) lpDomainData->lpData,
(zPCHAR) lpAttrAddr,
lpDomainData->uMaxStringLength );
nRC = 0;
}
break;
case zTYPE_INTEGER:
// convert string to long
if ( (zPCHAR) lpAttrAddr == 0 ) //null string
{
*((zPLONG) lpDomainData->lpData) = 0;
nRC = -1; // indicate attribute is null
}
else
{
strcpy_s( szWorkString, zsizeof( szWorkString ), (zPCHAR) lpAttrAddr );
*((zPLONG) lpDomainData->lpData) = atol( szWorkString );
nRC = 0;
}
break;
case zTYPE_PIC:
// return the picture string for the given context
{
zLPCONTEXT lpContext;
if ( GetContext( &lpContext, lpDomain,
lpDomainData->pszContextName ) )
{
zPCHAR lpEditString = (zPCHAR) SysGetPointerFromHandle( lpContext->hEditString );
if ( lpEditString && *lpEditString )
strcpy_s( (zPCHAR) lpDomainData->lpData, lpDomainData->uMaxStringLength,
lpEditString );
else
*((zPCHAR) lpDomainData->lpData) = 0;
nRC = 0;
}
else
{
// "TZDME008 - Could not find context for Domain "
SendDomainError( lpDomainData->zView, lpDomain, 8, 8, 0,
TrueName( lpDomainData->pszContextName, zSHOW_ZKEY ),
lpDomainData->lpViewAttribute->szName );
nRC = zCALL_ERROR;
}
}
break;
default:
szWorkString[ 0 ] = lpDomainData->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME001 - Invalid Input Data Type"
SendDomainError( lpDomainData->zView, lpDomain, 8, 1,
0, szWorkString, lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
nRC = 0;
}
else
{
szWorkString[ 0 ] = lpDomainData->lpViewAttribute->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME003 - Attribute Type invalid for this Domain"
SendDomainError( lpDomainData->zView, lpDomain, 8, 3, 0,
szWorkString, lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
case zDME_COMPARE_ATTRIBUTE:
if ( lpDomainData->lpViewAttribute->cType == zTYPE_STRING )
{
zPCHAR lpAttrAddr;
zCHAR cAttrType;
zULONG uAttrLength;
nRC = GetValueFromRecord( lpDomainData->zView, lpDomainData->lpViewEntity, lpDomainData->lpViewAttribute,
&lpAttrAddr, &cAttrType, &uAttrLength );
if ( nRC )
return( zCALL_ERROR );
if ( lpAttrAddr == 0 )
lpAttrAddr = szNullS;
// determine input data type
switch ( lpDomainData->cType )
{
case zTYPE_STRING:
if ( lpDomainData->lpViewAttribute->bCaseSens )
nRC = zstrcmp( lpAttrAddr, (zPCHAR) lpDomainData->lpData );
else
nRC = zstrcmpi( lpAttrAddr, (zPCHAR) lpDomainData->lpData );
break;
case zTYPE_INTEGER:
lWork = zatol( lpAttrAddr );
lWork -= *((zPLONG) lpDomainData->lpData);
nRC = (lWork == 0) ? 0 : (lWork < 0) ? -1 : 1;
break;
default:
szWorkString[ 0 ] = lpDomainData->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME001 - Invalid Input Data Type"
SendDomainError( lpDomainData->zView, lpDomain, 8, 1, 0, szWorkString,
lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
}
else
{
szWorkString[ 0 ] = lpDomainData->lpViewAttribute->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME003 - Attribute Type invalid for this Domain"
SendDomainError( lpDomainData->zView, lpDomain, 8, 3, 0,
szWorkString, lpDomainData->lpViewAttribute->szName );
return( zCALL_ERROR );
}
break;
case zDME_GET_COMPARE_VALUE:
switch ( lpDomainData->cType )
{
case zTYPE_STRING:
nRC = 0;
break;
case zTYPE_INTEGER:
zltoa( *((zPLONG) lpDomainData->lpData), szWorkString );
strcpy_s( (zPCHAR) lpDomainData->lpData, lpDomainData->uMaxStringLength, szWorkString );
nRC = 1; // indicate returning a string value
break;
default:
szWorkString[ 0 ] = lpDomainData->cType;
szWorkString[ 1 ] = 0;
strcat_s( szWorkString, zsizeof( szWorkString ), ", " );
strcat_s( szWorkString, zsizeof( szWorkString ), lpDomainData->lpViewEntity->szName );
// "TZDME001 - Invalid Input Data Type"
SendDomainError( lpDomainData->zView, lpDomain, 8, 1, 0,
szWorkString, lpDomainData->lpViewAttribute->szName );
nRC = -2;
}
break;
case zDME_ADD_TO_ATTRIBUTE:
case zDME_GET_FIRST_TBL_ENT_FOR_ATTR:
case zDME_GET_NEXT_TBL_ENT_FOR_ATTR:
case zDME_SET_ATTRIBUTE_VALUE_NEXT:
case zDME_SET_ATTRIBUTE_VALUE_PREV:
default:
// Entry not handled
return( zDME_NOT_HANDLED );
}
return( nRC );
} // AlphaNumericUpperStrip
