Récupération d’informations sur le 4D Server par les librairies 4D Open (Projet Windows, Projet CFM, Projet Mach-0) (2/2)

   typedef struct DataRec {
      DataType typ;
      byte filler;
      union {
         TE4D text; /* s_Text32K */
         st80 s; /* s_AlphaNumeric */
         Real r; /* s_Number */
         int2 b; /* s_Bool */
         int2 i; /* s_Int16 */
         int4 l; /* s_Int32 */
         int4 tim; /* s_TimeSec */
         Date4D d; /* s_Dates */
         Pict4D pic; /* s_Pictures */
         Blob4D blob; /* s_Blob */
         struct { st80 s2 ; int2 unused; } other ;
      } u;
   } DataRec;

   typedef struct SearchLine {
      int2 Field_Number;
      int2 File_Number;
      byte SOP; /* search operator */
      byte unused;
      DataRec Value;
      byte LOP; /* logical operator */
      byte unused2,unused3 ;
      } SearchLine;

   typedef struct SearchRecord {
      int2 NB_Lines;
      int2 TargetFile;
      SearchLine lines[1];
      } SearchRecord;

   typedef SearchRecord *SearchRecordPtr;

   typedef struct SortLine {
      int2 Field_Number;
      int2 File_Number;
      byte Ascent;
      } SortLine;

   typedef struct SortRecord {
      int2 NB_Lines;
      int2 TargetFile;
      SortLine lines[1];
      } SortRecord;

   typedef SortRecord *SortRecordPtr;

   typedef struct ReqFieldRec {
      int2 NB_Fields;
      int2 TargetFile;
      int2 Fields[1];
      } ReqFieldRec

   typedef struct DataRec {
      DataType typ;
      byte filler;
      union {
         TE4D text; /* s_Text32K */
         st80 s; /* s_AlphaNumeric */
         Real r; /* s_Number */
         int2 b; /* s_Bool */
         int2 i; /* s_Int16 */
         int4 l; /* s_Int32 */
         int4 tim; /* s_TimeSec */
         Date4D d; /* s_Dates */
         Pict4D pic; /* s_Pictures */
         Blob4D blob; /* s_Blob */
         struct { st80 s2 ; int2 unused; } other ;
      } u;
   } DataRec;

data.u.blob.BlobLen

   #if __INTEL__
      /* #pragma once */
      /* #include "ansi_prefix.win32.h" */
      /* #include <Windows.h> */
      /* Use pre-compiled header instead */
   #elif WIN32 /* &lt;-- defined by Visual C++ */
      #include <Windows.h>
   #endif

   #if WINVER
      #undef COLOR_WINDOWFRAME
      #undef COLOR_BTNSHADOW
      #undef COLOR_BTNFACE
      #undef COLOR_BTNHIGHLIGHT
      #undef COLOR_BTNTEXT
      #undef InsertMenuItem
      #undef InsertMenu
      #undef AppendMenu
      //#include "ASIPORT.H"/*To use Altura headers (in the folder PPC_H, placed in the
         project folder)*/
   #endif

   #define Openlib 1



   #include "Open4D.h"
   #include <stdlib.h>
   #include <string.h>
   #include <stdio.h>


   const short KNC = NC_TCPIP;
   const unsigned char KStationName[32]="Intel machine\0";
   const unsigned char KUserName[32]="APIUser\0";
   const unsigned char KUserPass[32]="APIPass\0";
   const unsigned char KUserTask[32]="APITask\0";
   const unsigned char kAlphaData[256] = "Champs Alpha\0";
   const unsigned char kTexteData[256] = "Champs Texte\0";

   unsigned char kSetName1[32] = "MySet1\0";
   unsigned char kSetName2[32] = "MySet2\0";
   NetworkComponentHandle hNetworkComponent;
   NetworkLocationPtr pNetworkLocation;
   ConnectHandle hConnect;
   IDRec logRec;
   unsigned char szName[256];
   int choix;

   void Menu(void);
   void initialisation(void);
   int2 StartWSConnection(void);
   void Check(int2 myErr, char *description);
   unsigned char *SP2CSTR(unsigned char *pstr);
   void CloseWSConnection(void);
   void AddRecords(void);
   void GetBlob(void);
   void SortRecords(void);
   void SearchRecords(void);
   void Sets(void);

   int2 StartWSConnection()
   {
      int2 myErr;

      myErr =_4D_Select4DServer(szName, &pNetworkLocation, KNC, hNetworkComponent);
      if(!myErr)
      {
         _4D_Open4DConnection(&logRec, pNetworkLocation, &hConnect,KNC, hNetworkComponent);
      }
      return(myErr);

   }


   void CloseWSConnection()
   {
      _4D_Close4DConnection(hConnect);
   }

   void Check(int2 myErr, char *description)
   {
      char err[256];
      if(myErr)
      {
         sprintf(err, "%s: returns %d\n", description , myErr);
         printf(err);
         getchar();
      }
   }

   unsigned char *SP2CSTR(unsigned char *pstr)
   {
      unsigned char len = *pstr;
      memcpy(pstr, pstr+1, len);
      pstr[len] = '\0';
      return pstr;
   }

   void initialisation(void)
   {
      memcpy(&logRec.StationName[1],KStationName, strlen((char *)KStationName));
      logRec.StationName[0]=strlen((char *)KStationName);
      memcpy(&logRec.UserName[1],KUserName, strlen((char *)KUserName));
      logRec.UserName[0]=strlen((char *)KUserName);
      memcpy(&logRec.UserPass[1],KUserPass, strlen((char *)KUserPass));
      logRec.UserPass[0]=strlen((char *)KUserPass);
      memcpy(&logRec.TaskName[1],KUserTask, strlen((char *)KUserTask));
      logRec.TaskName[0]=strlen((char *)KUserTask);
   }




   // Traitement des données


   void AddRecords(void)
   {
      BufferHandle hBuffer;
      Handle4D hText, hPict, hBlob;
      char *pText, *pPict, *pBlob;
      DataRec data;
      short fNb = 1, nbRec=1;



      printf("Deleting all records of table : %d\n", fNb);
      Check(_4D_SelectAllRecords(hConnect, fNb),"_4D_SelectAllRecords\0");
      Check(_4D_DeleteSelectedRecords(hConnect, fNb),"_4D_DeleteSelectedRecords\0");


      do {

         printf("Adding records to table : %d et l'enregistrement: %d \n", fNb, nbRec);

         hBuffer = _4D_CreateBuffer(hConnect, fNb);

         data.typ = s_AlphaNumeric;
         memcpy(&data.u.s[1], kAlphaData, strlen((char *)kAlphaData));
         data.u.s[0] = strlen((char *)kAlphaData);
         Check(_4D_AddToBuffer(hConnect, hBuffer, 1, &data),"_4D_AddToBuffer\0");

         data.typ = s_Text32K;
         hText = Alloc4DHandle(strlen((char *)kTexteData));
         pText = (char *) Lock4DHandle(hText);
         memcpy(pText, &kTexteData, strlen((char *)kTexteData));
         Unlock4DHandle(hText);
         data.u.text.TextLen = strlen((char *)kTexteData);
         data.u.text.hText = hText;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 2, &data),"_4D_AddToBuffer\0");

         data.typ = s_Number;
         data.u.r.r = 999.999;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 3, &data),"_4D_AddToBuffer\0");

         data.typ = s_Int16;
         data.u.i = 999;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 4, &data),"_4D_AddToBuffer\0");

         data.typ = s_Int32;
         data.u.l = 999;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 5, &data),"_4D_AddToBuffer\0");

         data.typ = s_Dates;
         data.u.d.Day = 27;
         data.u.d.Month = 03;
         data.u.d.Year = 2000;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 6, &data),"_4D_AddToBuffer\0");

         data.typ = s_TimeSec;
         data.u.tim = 999;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 7, &data),"_4D_AddToBuffer\0");

         data.typ = s_Bools;
         data.u.b = 1;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 8, &data),"_4D_AddToBuffer\0");

         hPict = Alloc4DHandle(strlen((char *)kAlphaData));
         pPict = (char *) Lock4DHandle(hPict);
         memcpy(pPict, &kAlphaData, strlen((char *)kAlphaData));
         Unlock4DHandle(hPict);
         data.typ = s_Pictures;
         data.u.pic.PictLen = strlen((char *)kAlphaData);
         data.u.pic.hPict = hPict;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 9, &data),"_4D_AddToBuffer\0");

         hBlob = Alloc4DHandle(strlen((char *)kAlphaData));
         pBlob = (char *) Lock4DHandle(hBlob);
         memcpy(pBlob, &kAlphaData, strlen((char *)kAlphaData));
         Unlock4DHandle(hBlob);
         data.typ = s_Blob;
         data.u.blob.BlobLen = strlen((char *)kAlphaData);
         data.u.blob.hBlob = hBlob;
         Check(_4D_AddToBuffer(hConnect, hBuffer, 10, &data),"_4D_AddToBuffer\0");

         Check(_4D_NewRecord(hConnect, hBuffer),"_4D_NewRecord\0");

         Free4DHandle(hText);
         Free4DHandle(hPict);
         Free4DHandle(hBlob);
         Free4DHandle((Handle4D) hBuffer);
         nbRec ++;

      } while ( nbRec < 4 );

   }


   void GetBlob(void)
   {
      ReqFieldRecPtr pReq = (ReqFieldRecPtr) malloc(sizeof(ReqFieldRec));
      BufferHandle hBuf = 0L;
      unsigned char IsLocked;
      DataRec data;

      Check(_4D_SelectAllRecords(hConnect, 1),"_4D_SelectAllRecords\0");
      Check(_4D_GotoSelectedRecord(hConnect, 1, 1),"_4D_GotoSelectedRecord\0");
      pReq->NB_Fields = 1;
      pReq->TargetFile = 1;
      pReq->Fields[0] = 10;
      Check(_4D_GetFields(hConnect, pReq, &hBuf, &IsLocked),"_4D_GetFields\0");
      Check(_4D_GetNthField(hConnect, hBuf, 1, &data),"_4D_GetNthField\0");
      printf("Got blob field size : %ld original size was : %d\n", data.u.blob.BlobLen,
      strlen((char *) kAlphaData));
      Free4DHandle((Handle4D) data.u.blob.hBlob);
      Free4DHandle((Handle4D) hBuf);
      free(pReq);
   }

   // Sorts records in ascent order
   // if we had more than one field to sort on the server --
   // SortRecordPtr pSort = (SortRecordPtr) malloc(sizeof(SortRecord) + ( ( n - 1 ) * sizeof(SortLine) ));
   void SortRecords(void)
   {
      SortRecordPtr pSort = (SortRecordPtr) malloc(sizeof(SearchRecord));

      printf("Sorting records , field #4 in ascent order\n");
      pSort->NB_Lines = 1;
      pSort->TargetFile = 1;
      pSort->lines[0].File_Number = 1;
      pSort->lines[0].Field_Number = 4;
      pSort->lines[0].Ascent = 1;
      Check(_4D_Sort(hConnect, pSort),"_4D_Sort\0");
      free(pSort);
   }

   // Searches records where field #4 of type integer == 999
   // if we had more than one field to search on the server --
   // SortRecordPtr pSearch = (SearchRecordPtr) malloc(sizeof(SearchRecord) + ( ( n - 1 ) * sizeof(SearchLine) ));
   void SearchRecords(void)
   {
      SearchRecordPtr pSearch = (SearchRecordPtr) malloc(sizeof(SearchRecord));
      DataRec data;
      int4 nbRec;

      data.typ = s_Int16;
      data.u.i = 999;

      printf("Searching records , field #4 = 999 \n");
      pSearch->NB_Lines = 1;
      pSearch->TargetFile = 1;
      pSearch->lines[0].Field_Number = 4;
      pSearch->lines[0].File_Number = 1;
      pSearch->lines[0].SOP = Equal;
      pSearch->lines[0].Value = data;
      pSearch->lines[0].LOP = None2;
      Check(_4D_Search(hConnect, pSearch, &nbRec),"_4D_Search\0");
      free(pSearch);
      printf("found %ld records matching = 999\n", nbRec);
   }

   // Demonstrates the use of sets
   void Sets(void)
   {
      unsigned char pSetName1[32], pSetName2[32];
      int4 recIn;

      memcpy(&pSetName1[1], kSetName1, strlen((char *)kSetName1));
      pSetName1[0] = strlen((char *)kSetName1);
      memcpy(&pSetName2[1], kSetName2, strlen((char *)kSetName2));
      pSetName2[0] = strlen((char *)kSetName2);

      Check(_4D_SelectAllRecords(hConnect, 1),"_4D_SelectAllRecords\0");
      Check(_4D_CreateEmptySet(hConnect, pSetName1, 1),"_4D_CreateEmptySet\0");
      Check(_4D_AddToSet(hConnect, pSetName1, 1),"_4D_AddToSet\0");
      SearchRecords(& hConnect);
      Check(_4D_CreateSet(hConnect, pSetName2, 1),"_4D_CreateSet\0");
      Check(_4D_RecordsInSet(hConnect, pSetName1, &recIn),"_4D_RecordsInSet\0");
      printf("Set %s contains : %ld record(s)\n", SP2CSTR(pSetName1), recIn);
      Check(_4D_RecordsInSet(hConnect, pSetName2, &recIn),"_4D_RecordsInSet\0");
      printf("Set %s contains : %ld record(s)\n", SP2CSTR(pSetName2), recIn);
      Check(_4D_ClearSet(hConnect, pSetName1),"_4D_ClearSet\0");
      Check(_4D_ClearSet(hConnect, pSetName2),"_4D_ClearSet\0");
   }

   void Menu(void)
   {
      printf("\n\n1 :Ajouter et Supprimer des entregistrements ");
      printf("\n2 :Chercher un enregistrement ");
      printf("\n3 :Supprimer et Trier les enregistrements ");
      printf("\n4 :Manipuler des ensembles");
      printf("\n5 :Manipuler les Blobs");
      printf("\n0 Pour quitter le programme");

      printf("\n\n\t Entrer votre choix : ");

      scanf("%d", &choix);

      switch(choix)

      {

         case 1: AddRecords();
         break;

         case 2: SearchRecords();
         break;

         case 3: SortRecords();
         break;

         case 4: Sets();
         break;

         case 5: GetBlob();
         break;

         case 0:
         break;

         default:
         printf("\n\n Choix Incorrecte ! Appuyer sur une touche !");
         choix = getch();

      }
   }

   void main(void)
   {

      initialisation();

      _4D_Init4DWS();

      hNetworkComponent= _4D_InitNetworkComponent(KNC);

      if(hNetworkComponent)
      {
         if(!StartWSConnection())
         {

            do
               Menu();

            while(choix != 0);

            CloseWSConnection();
         }

         _4D_DeInitNetworkComponent(KNC,hNetworkComponent);
      }

      _4D_DeInit4DWS();
   }

   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>

   #define OpenLib 1

   #ifdef __MWERKS__
      #ifdef __INTEL__
         #define WINVER 0x0400
         #define MACVER 0
      #endif
   #else
      #define WINVER 0x0400
      #define __INTEL__
   #endif

   #include "Open4D.h"

   const short      kNC = NC_TCPIP;
                     // change nc here, if u want test with tcp/ip per example

   #ifdef __INTEL__
      const unsigned char kStationName[32] = "Intel machine\0";
   #else
      const unsigned char kStationName[32] = "Motorola machine\0";
   #endif
   const unsigned char kUserName[32] = "APIUser\0";
   const unsigned char kUserPass[32] = "APIPass\0";
   const unsigned char kUserTask[32] = "APITask\0";


   unsigned char *PversCstring(unsigned char *pstr);

   void initialisation();
   void Check(int2 myErr, char *description);
   int2 StartWSConnection(void);
   void CloseWSConnection(void);
   void DisplayServerInfo(void);
   void DisplayProcessInfo(void);
   void DisplayStructureInfo(void);


   NetworkComponentHandle hNetworkComponent;
   NetworkLocationPtr pNetworkLocation;
   ConnectHandle hConnect;
   IDRec logRec;
   unsigned char szName[256];





   // converts a pstring to a cstring
   unsigned char *PversCstring(unsigned char *pstr)
   {
      unsigned char len = *pstr;
      memmove(pstr, pstr+1, len);
      pstr[len] = '\0';
      return pstr;
   }

   // checks for errors and reports
   void Check(int2 myErr, char *description)
   {
      char err[256];

      if ( myErr ) {
         sprintf(err,"%s : returns %d\n", description, myErr);
         printf(err);
         getchar();
      }
   }

   // opens a connection with server and errors if any
   int2 StartWSConnection(void)
   {
      int2 myErr;
      myErr = _4D_Select4DServer(szName, &pNetworkLocation, kNC, hNetworkComponent);
      if ( ! myErr ) {
         myErr = _4D_Open4DConnection(&logRec, pNetworkLocation, &hConnect, kNC,
         hNetworkComponent);
      }
      return myErr;
   }

   // closes connection
   void CloseWSConnection(void)
   {
      if (hConnect)
      _4D_Close4DConnection (hConnect);
   }
   void DisplayServerInfo(void)
   {
      ServerInfoRec sInfo;
      Date4D d;
      int4 l;
      unsigned char b;

      printf("\n INFORMATIONS SUR LE 4D SERVEUR \n");

      printf("szName : %s\n", PversCstring(szName));
      Check(_4D_GetServerInfo(hConnect, &sInfo),"_4D_GetServerInfo\0");
      printf("ServerCurVers : %X\n", ((sInfo.ServerCurVers & 0xfff) << 16) );
      printf("InvertedData : %d\n", sInfo.ServerHasInvertedData);
      Check(_4D_Server_CurrentTime(hConnect, &l),"_4D_Server_CurrentTime\0");
      printf("Server_CurrentTime : %ld ticks\n", l);
      Check(_4D_Server_CurrentDate(hConnect, &d),"_4D_Server_CurrentDate\0");
      printf("Server_CurrentDate : %d/%d/%d\n", d.Day, d.Month, d.Year);
      Check(_4D_IsConnectionAsync(hConnect, (unsigned char *) &b),"_4D_IsConnectionAsync\0");
      printf("IsConnectionAsync ? : %d\n", b);
      printf("\n");
   }

   // displays running processes on server
   void DisplayProcessInfo(void)
   {
      ListProcessHandle hList = 0L;
      ListProcessPtr pList;
      int2 i;

      printf("\n INFORMATIONS SUR LES PROCESS SERVEUR \n");

      Check(_4D_GetNbUsers(hConnect, &i),"_4D_GetNbUsers\0");
      printf("GetNbUsers : %d\n", i);
      Check(_4D_GetNbUserProcesses(hConnect, &i),"_4D_GetNbUserProcesses\0");
      printf("GetNbUserProcesses : %d\n", i);
      Check(_4D_GetListProcess(hConnect, &hList),"_4D_GetListProcess\0");
      pList = (ListProcessPtr) Lock4DHandle((Handle4D)hList);

      for ( i = 0 ; i < pList->NB_Process ; i ++ ) {
         printf("GetListProcess_ProcessInfo[%d]_UserName : %s\n",
            i, PversCstring(pList->Processes[i].UserName));
         printf("GetListProcess_ProcessInfo[%d]_StationName : %s\n",
            i, PversCstring(pList->Processes[i].StationName));
         printf("GetListProcess_ProcessInfo[%d]_Taskname : %s\n",
            i, PversCstring(pList->Processes[i].Taskname));
         printf("GetListProcess_ProcessInfo[%d]_TotalTimeSpent : %ld ticks\n",
            i, pList->Processes[i].TotalTimeSpent);
         printf("GetListProcess_ProcessInfo[%d]_State : %d\n",
            i, pList->Processes[i].State);
      }
      Unlock4DHandle((Handle4D)hList);
      Free4DHandle((Handle4D)hList);
   }

   // displays structure
   void DisplayStructureInfo(void)
   {
      FileListHandle hList = 0L;
      FileListPtr pList;
      FileDefHandle hDef = 0L;
      FileDefPtr pDef;
      int2 i, f;

      printf("\n INFORMATIONS SUR LES TABLES \n");

      Check(_4D_CountFiles(hConnect, &i),"_4D_CountFiles\0");
      printf("CountFiles : %d\n", i);
      Check(_4D_GetFileList(hConnect, &hList),"_4D_GetFileList\0");
      pList = (FileListPtr) Lock4DHandle((Handle4D) hList);
      for ( f = 1; f <= pList ->nbFiles ; f ++ ) {
         Check(_4D_GetFileDefinition(hConnect, f, &hDef),"_4D_GetFileDefinition\0");
         pDef = (FileDefPtr) Lock4DHandle((Handle4D)hDef);
         printf("GetFileList : %s\n", PversCstring(pList->fileNames[f-1]));
         printf("GetFileDefinition_NB_Fields : %d\n", pDef->NB_Fields);
         printf("GetFileDefinition_Invisible : %d\n", pDef->Invisible);
         printf("GetFileDefinition_FileNum : %d\n", pDef->FileNum);
         printf("GetFileDefinition_Frame : %d/%d/%d/%d\n", pDef->Frame.left,
            pDef->Frame.top, pDef->Frame.right, pDef->Frame.bottom);
         printf("GetFileDefinition_TrigOnSavingNew : %d\n", pDef->TrigOnSavingNew);
         printf("GetFileDefinition_TrigOnSavingExisting : %d\n", pDef->TrigOnSavingExisting);
         printf("GetFileDefinition_TrigOnDeleting : %d\n", pDef->TrigOnDeleting);
         printf("GetFileDefinition_TrigOnLoading : %d\n", pDef->TrigOnLoading);
         printf("\n INFORMATIONS SUR LES CHMAPS \n");

         for ( i = 0 ; i < pDef->NB_Fields ; i ++ ) {
            printf("GetFileDefinition_Fields[%d]_Name : %s\n", i, PversCstring(pDef->Fields[i].Name));
            printf("GetFileDefinition_Fields[%d]_Typ : %d\n", i, pDef->Fields[i].Typ);
            printf("GetFileDefinition_Fields[%d]_AlphaLen : %d\n", i, pDef->Fields[i].AlphaLen);
            printf("GetFileDefinition_Fields[%d]_u_SimpleField_RelatedFile : %d\n",
               i, pDef->Fields[i].u.SimpleField.RelatedFile);
            printf("GetFileDefinition_Fields[%d]_u_SimpleField_RelatedField : %d\n",
               i, pDef->Fields[i].u.SimpleField.RelatedField);
            printf("GetFileDefinition_Fields[%d]_u_SimpleField_Att : %X\n",
               i, pDef->Fields[i].u.SimpleField.Att);
            printf("GetFileDefinition_Fields[%d]_u_SimpleField_DiscriminantField : %d\n",
               i, pDef->Fields[i].u.SimpleField.DiscriminantField);
            printf("GetFileDefinition_Fields[%d]_u_PictField_PicAtt : %X\n",
               i, pDef->Fields[i].u.PictField.PicAtt);
            printf("GetFileDefinition_Fields[%d]_u_PictField_CompressDriver : %X\n",
               i, pDef->Fields[i].u.PictField.CompressDriver);
         }
         Unlock4DHandle((Handle4D)hDef);
         Free4DHandle((Handle4D)hDef);
         printf("\n");
      }
      Unlock4DHandle((Handle4D)hList);
      Free4DHandle((Handle4D)hList);
   }



   void initialisation(void)
   {
      memcpy(&logRec.StationName[1], kStationName, strlen((char *)kStationName));
      logRec.StationName[0] = strlen((char *)kStationName);
      memcpy(&logRec.UserName[1], kUserName, strlen((char *)kUserName));
      logRec.UserName[0] = strlen((char *)kUserName);
      memcpy(&logRec.UserPass[1], kUserPass, strlen((char *)kUserPass));
      logRec.UserPass[0] = strlen((char *)kUserPass);
      memcpy(&logRec.TaskName[1], kUserTask, strlen((char *)kUserTask));
      logRec.TaskName[0] = strlen((char *)kUserTask);
   }


   void main(void)
   {
      printf("GetVersionNumber : %ld\n", ( _4D_GetVersionNumber() >> 16 ));
      printf("NB_NetworkComponent : %d\n", _4D_NB_NetworkComponent());

      hNetworkComponent = _4D_InitNetworkComponent(kNC);
      if ( hNetworkComponent ) {
         if ( ! StartWSConnection()) {
            initialisation();
            DisplayServerInfo();
            DisplayProcessInfo();
            DisplayStructureInfo();
            //CloseWSConnection();
         }
         _4D_DeInitNetworkComponent(kNC, hNetworkComponent);
      }
      _4D_DeInit4DWS();
   }