Chip 1997 January/Chip_1997-01_cd.bin/ms95/disk21/dir04/f012270.re_/f012270.re

Text File | 1996-04-02 | 12KB | 538 lines

/*----------------------------------------------------------------------+
|                                    |
|  Copyright (c) 1985-93;  Bentley Systems, Inc., All rights reserved.    |
|                                    |
| "MicroStation", "MDL", and "MicroCSL" are trademarks of Bentley    |
|  Systems, Inc.                            |
|                                    |
|  Limited permission is hereby granted to reproduce and modify this    |
|  copyrighted material provided that the resulting code is used only     |
|  in conjunction with Bentley Systems products under the terms of the    |
|  license agreement provided therein, and that this notice is retained    |
|  in its entirety in any such reproduction or modification.        |
|                                    |
+----------------------------------------------------------------------*/
/*----------------------------------------------------------------------+
|                                    |
|   $Workfile:   mssystem.fdf  $
|   $Revision:   6.20  $
|          $Date:   11 Oct 1995 10:18:08  $
|                                    |
+----------------------------------------------------------------------*/
#ifndef __mssystemFDF__
#define __mssystemFDF__

/*----------------------------------------------------------------------+
|                                    |
|   Header File Dependencies                        |
|                                    |
+----------------------------------------------------------------------*/

#if !defined (__dloadlibH__)
#include "dloadlib.h"
#endif

#if !defined (__mdlH__)
#include "mdl.h"
#endif

#if !defined (__msinputqH__)
#include "msinputq.h"
#endif

#if !defined (__mselemsH__)
#include "mselems.h"
#endif

#if !defined (__systemH__)
#include "system.h"
#endif

#if !defined (__msexternH__)
#include "msextern.h"
#endif

#if !defined (__extgraphH__)
# include <extgraph.h>
#endif

#if   defined (__BSI__)
#include    <misystem.fdf>
#endif

#if !defined (__MDL_SHARE_LIB__)
#define MdlSharedLib void
#endif

#if !defined (__MDL_DESC__)
#define __MDL_DESC__    1
#define  MdlDesc    void
#endif


/*======================================================================+
|                                    |
|   Function Definitions                        |
|                                    |
+======================================================================*/

Public MdlFunctionP     mdlShare_setFunction
(
int         type,
MdlSharedLib       *mdlLibP,
MdlFunctionP     functionOffset
);

int mdlSystem_abortRequested
(
void
);

void mdlSystem_cancelTimer
(
int    timerHandle
);

void    mdlSystem_closeDesignFile
(
void
);

unsigned int mdlSystem_getDgnFileChangeCount
(
void
);

void    mdlSystem_compressDgnFile
(
void
);

void    mdlSystem_compressLibrary
(
void
);

int mdlSystem_createStartupElement
(
MSElementUnion    *outElemP,
char        *startupString
);

int mdlSystem_deleteStartupElement
(
char        *programNameP
);

void mdlSystem_enterDebug
(
void
);

void    mdlSystem_enterGraphics
(
void
);

void    mdlSystem_enterGraphicsExtended
(
int    flags            /* 0=display views, 1=don't display views */
);

/*  This is an obsolete function. Use the standard function "exit" */
void    mdlSystem_exit
(
int    exitStatus,
int    exit            /*  1 means unload.  */
);

int    mdlSystem_fileDesign
(
void
);

void *mdlSystem_findMdlDesc
(                    /* <= Descriptor with the task ID   */
char     *nameP                /* => will be converted to upper. */
);

void    mdlSystem_flushDesignFile
(
void
);

void    mdlSystem_flushWriteCache
(
void
);



int mdlSystem_getChar
(
void
);

MdlDesc *mdlSystem_getCurrMdlDesc
(
void
);

char *mdlSystem_getCurrTaskID
(
void
);

char *mdlSystem_getMdlTaskID
(
void    *mdlDescP
);

char *mdlSystem_getMdlTaskList
(
void
);




int mdlSystem_getTaskStatistics
(
MdlAppStatistics    *statisticsP,    /* <= Receives statistics */
char            *taskIdP        /* => NULL for current task */
);

unsigned long mdlSystem_getTicks
(
void
);

double mdlSystem_elapsedTime
(
void
);

void    mdlSystem_getUstnOSPid
(
ProcessID    *pidP
);

int     mdlSystem_getenv
(
char    *bufferP,    /* <= Environment variable stored here */
char    *variableNameP,    /* => Name of variable to search for */
int    maxlen        /* => Size of buffer bufferP points to */
);

int    mdlSystem_getCfgVar
(
char    *pValue,    /* <= output string. May also be a NULL            */
            /*    pointer if only checking existance of cfg var     */
char    *pCfgVar,   /* => cfg var to look for                    */
int    maxlen        /* => maximum length of string to be copied into pValue */
);

int    mdlSystem_getCfgVarAtLevel
(
char    *envStr,   /* <= output environment string. May also be a NULL         */
           /*    pointer if only checking existence of envvar        */
char    *envVar,   /* => environment variable to look for            */
int    maxlen,    /* => maximum length of string to be copied into envStr  */
int     level      /* => level at which to look                 */
);

int    mdlSystem_getCfgVarByIndex
(
char   **name,        /* <= name of configuration variable         */
char   **translation,    /* <= translation of configuration variable    */
int    *level,        /* <= level at which config variable is defined */
boolean    *lock,        /* <= TRUE if configuration variable is locked    */
int     index        /* => index of variable                */
);

int    mdlSystem_getCfgVarLevel
(
int    *levelP,    /* <= level of cfg var definition        */
char    *pCfgVar    /* => configuration variable to look for    */
);

char    *mdlSystem_getExpandedCfgVar
(
char    *pVariable
);

char    *mdlSystem_expandCfgVar
(
char    *pValue
);

int     mdlSystem_defineCfgVar
(
char    *pVariable,
char    *pValue,
int    level
);

int    mdlSystem_putenv
(
char    *variableP,
char    *valueP
);

int     mdlSystem_deleteCfgVar
(
char    *pVariable    /* => Name of variable to delete */
);

int    mdlSystem_deleteCfgVarAtLevel
(
char    *pCfgVar,       /* => configuration variable to look for */
int    level           /* => level to remove */
);

int     mdlSystem_lockCfgVar
(
char    *pVariable            /* => Name of variable to lock */
);

boolean mdlSystem_isCfgVarLocked
(
char    *pVariable            /* => Name of variable to check */
);

int    mdlSystem_processCfgVarFile
(
char    *fileName,        /* => name of file to process */
int    startingProcessLevel    /* => level to start processing file */
);

int    mdlSystem_rewriteCfgVarFile
(
char    *cfgVarFileNameP,       /* => file name to rewrite */
char    *cfgVarNameP,           /* => name of variable */
char    *cfgVarValueP           /* => value of variable */
);

#if defined (STRING_LIST_DEFINED)
int    mdlSystem_createListFromCfgVarValue
(                            /* <= # of values, -1 if error */
StringList      **valueStrListPP,        /* <= */
char            *cfgVarValueP                /* => */
);

int    mdlSystem_getWorkspaceList
(                            /* <= # of workspaces, -1 if error */
StringList      **workspaceStrListPP,        /* <= */
int            attributes                /* => */
);
#endif

int     mdlSystem_loadMdlProgram
(
char    *pathP,        /* => File containing the program. If NULL,
                  assumed to be the same as the parent's. */
char    *taskIdP,    /* => Specifies which program is to be loaded. */
char    *pArgument    /* => Argument passed to MDL Program's main. */
);

void *mdlSystem_getMdlDescFromProcessNumber
(
long     processNumber
);

void *mdlSystem_nextMdlApp
(
void    *descP
);

int    mdlSystem_newDesignFile
(
char    *fileName
);

int    mdlSystem_exchangeDesignFile
(
char    *fileName,      /* => name of reference file to make master */
ULong     option         /* => Function options */
);

int    mdlSystem_saveDesignFile
(
void
);

void    mdlSystem_pauseTicks
(
int     sixtieths        /* => sixtieths of a second */
);


long mdlSystem_getProcessNumberFromMdlDesc
(
void    *mdlDescP
);

void mdlSystem_resetElmUpdateFuncActive
(
int        activity
);

MdlFunctionP mdlSystem_setFunction
(
int            type,
MdlFunctionP    function
);

int mdlSystem_setMdlAppClass
(
char    *taskIdP,
int     newClass
);

int mdlSystem_setTimerFunction
(
int    *timerHandleP,        /* <= timer handle */
long    duration,        /* => duration in sixtieths of a second */
MdlFunctionP funcP,         /* => offset of function to call on timeout */
long    argument,        /* => argument to send to your function */
int    continuous        /* => if TRUE, restart on timeout */
);

int mdlSystem_unloadMdlProgram
(
char    *pName            /* Name of Program to unload.  */
);

int mdlSystem_userAbortEnable
(
int    enable
);

void mdlSystem_startBusyCursor
(
void
);

void mdlSystem_stopBusyCursor
(
void
);

void mdlSystem_extendedAbortEnable
(
boolean    enable        /* <= TRUE to enable, FALSE to disable  */
);

int mdlSystem_extendedAbortRequested
(
void
);

int mdlSystem_computeDesignRange
(
Dpoint3d    *minP,            /* <= range minimum */
Dpoint3d    *maxP,            /* <= range maximum */
boolean        *elementFoundP,        /* <= TRUE if element found (or NULL) */
int        view,            /* => view number (or -1) */
RotMatrix   *rotMatrixP,        /* => rotation matrix (NULL for identity) */
ULong        *fileMaskP            /* => file mask (NULL for all files) */
);


#if defined (pm386) && defined (__msexternH__)
int mdlGraph_setDriverInfo
(
int            logicalScreen,
MSExternalProgramDescr    *driverPgmDescr,
int            *pFarHandler
);
#endif

#if defined (__extgraphH__)
int mdlSystem_getVideoAcceleratorInfo
(
AcceleratorInfo    *returnedInfoP,    /* <= returned data pointer */
int         length,    /* => max. size of returned data */
int         screen        /* => requested screen */
);
#endif


BoolInt    mdlSystem_CADInputJournalActive
(
void
);

int     mdlSystem_journalCommand
(
char    *taskIdP,        /* => task id string (may be NULL) */
long     cmdnum,        /* => command number */
char    *unparsedP        /* => unparsed part of command (may be NULL) */
);

int    mdlSystem_journalDataPoint
(
Point3d     *uorsP,        /* => Data point in design file coordinates */
Point3d     *rawUorsP,      /* => Unadjusted data point coords (may be NULL) */
int         view,        /* => View that data point is in (0 relative) */
int         buttonTrans,   /* => Button transition, e.g. BUTTONTRANS_UP */
int         qualifierMask  /* => Qualifying keys, if any, e.g. TOGGLESELECT_MODKEY */
);

int     mdlSystem_journalTentativePoint
(
Point3d     *uorsP,        /* => Tentative point in design file coordinates */
int         view        /* => View that tentative point is in (0 relative) */
);

int     mdlSystem_journalReset
(
void
);

int     mdlSystem_journalKeyin
(
char    *stringP        /* => String keyed in */
);

int      mdlSystem_journalCommandString
(
char    *stringP            /* => String to journal as a command */
);

int     mdlSystem_journalAccessStrByTaskId
(
char    *taskIdP,        /* => Task's id string */
char    *accessStrP,        /* => Access string */
int      dataType,        /* => Data type--CEXPR_TYPE_xxx
                      Special cases indicated in high byte */
ULong     dataMask,        /* => Bit mask if only using some bits in *dataP */
void    *dataP            /* => Pointer to the data, matches "dataType" */
);

int     mdlSystem_journalAccessString
(
void    *ownerMD,        /* => MDL descriptor for the owner task */
char    *accessStrP,        /* => Access string */
int      dataType,        /* => Data type--CEXPR_TYPE_xxx
                      Special cases indicated in high byte */
ULong     dataMask,        /* => Bit mask if only using some bits in *dataP */
void    *dataP            /* => Pointer to the data, matches "dataType" */
);

int     mdlSystem_journalAppMessage
(
char    *taskIdP,        /* => Task's id string */
char    *msgP            /* => Message text, may contain newlines */
);

int     mdlSystem_getDiskSpace
(
ULong       *pTotalBytes,
ULong       *pFreeBytes,
char        *fileSys            /* => fileSys letter */
);


#endif /* __mssystemFDF__ */