home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / edispm11.zip / EDisPM / SRC / Server / edtext.cpp < prev    next >
C/C++ Source or Header  |  1996-05-06  |  11KB  |  387 lines
  1. /* EDText.CPP : DSOM-Klasse : EDisServ.DLL V 1.1 */
  2. /* Speicherung der Textzeilen und Zugriff        */
  3. /*                                               */
  4. /* (C) 1995 M.Schwarz, FoPra TU-Muenchen SS1995  */
  5. /* (C) 1996 M.Schwarz, SOMObjects-Programmierung */
  6. /*                     OS/2 Inside 7/96          */
  7.  
  8. /*
  9.  *  This file was generated by the SOM Compiler.
  10.  *  Generated using:
  11.  *     SOM incremental update: 2.43
  12.  */
  13.  
  14. #ifndef SOM_Module_edtext_Source
  15. #define SOM_Module_edtext_Source
  16. #endif
  17. #define EDText_Class_Source
  18.  
  19. #include "EDText.xih"
  20. #include "EDLine.xh"
  21.  
  22. /* IUICL-Headers (zum Laden von Texten) */
  23. #include <iostream.h>
  24. #include <fstream.h>
  25. #include <string.h>
  26.  
  27.  
  28.  
  29. /* SOM-Functionen */
  30.  
  31. /*
  32.  * loadtext (OK):
  33.  */
  34.  
  35. SOM_Scope long  SOMLINK loadtext(EDText *somSelf,  Environment *ev,
  36.                                  string filePath)
  37. {
  38.  
  39.     EDTextData *somThis = EDTextGetData(somSelf);
  40.     EDLine    *eLine;
  41.  
  42.     ifstream  infile(filePath);
  43.     long     rc = 0;
  44.     long      lnr = 0;
  45.     char      line[255];
  46.  
  47.     EDTextMethodDebug("EDText","loadtext");
  48. /**/
  49.     if (somThis->strFilePath) SOMFree(somThis->strFilePath);
  50.     somThis->strFilePath = (string) SOMMalloc(strlen(filePath)+1);
  51.     strcpy(somThis->strFilePath, filePath);
  52.  
  53.    /* Datei öffnen */
  54.     if (!infile) {
  55.       /* Neue Datei erzeugen */
  56.        ofstream  outfile(filePath);
  57.        if (!outfile)
  58.          return -1;
  59.       /* Text in Datei schreiben */
  60.        outfile << "";
  61.       /* Datei schließen */
  62.        outfile.close();
  63.  
  64.        infile.open(filePath);
  65.     } /* endif */
  66.  
  67.     if (infile) {
  68.       /* Datei Zeile für Zeile laden */
  69.        while (!infile.eof()) {
  70.           infile.getline(line, 255, '\n');
  71.           if (!infile.fail()) {
  72.             /* Zeile line in Text einfügen */
  73.              lnr++;
  74.              eLine = new EDLine;
  75.              eLine->set(ev, lnr, line, "", 0, 0);
  76.              if (somSelf->addLine(ev, lnr, eLine))
  77.                 return -2;
  78.           } /* endif */
  79.        } /* endwhile */
  80.        somThis->nLines = sequenceLength(somThis->seqLNr);
  81.     } else {
  82.       /* Datei nicht gefunden */
  83.        return -1;
  84.     } /* endif */
  85.  
  86.     if (lnr == 0) {
  87.       /* Neue Datei: eine Zeile eintragen */
  88.        lnr++;
  89.        eLine = new EDLine;
  90.        eLine->set(ev, lnr, "", "", 0, 0);
  91.        if (somSelf->addLine(ev, lnr, eLine))
  92.           return -2;
  93.     } /* endif */
  94.  
  95.     if (somThis->nLines == 0)
  96.        return -3;
  97.  
  98.     return (somThis->nLines);
  99. }
  100.  
  101. /*
  102.  * saveText (OK):
  103.  */
  104.  
  105. SOM_Scope long  SOMLINK savetext(EDText *somSelf,  Environment *ev,
  106.                                  string filePath)
  107. {
  108.     EDTextData *somThis = EDTextGetData(somSelf);
  109.     EDLine    *eLine;
  110.  
  111.     long     rc = 0;
  112.     long      lid = 0;
  113.     char      line[255];
  114.     EDTextMethodDebug("EDText","savetext");
  115. /**/
  116.     if (somThis->strFilePath) SOMFree(somThis->strFilePath);
  117.     somThis->strFilePath = (string) SOMMalloc(strlen(filePath)+1);
  118.     strcpy(somThis->strFilePath, filePath);
  119.  
  120.    /* Datei zum Schreiben öffnen */
  121.     ofstream  outfile(filePath);
  122.  
  123.    /* Text in Datei schreiben */
  124.     for (long i=0 ;i<sequenceLength(somThis->seqLNr) ;i++ ) {
  125.        lid = sequenceElement(somThis->seqLNr, i);
  126.        somSelf->getLine(ev, lid, &eLine);
  127.  
  128.        if (i != 0) outfile << "\n";
  129.        outfile << eLine->_get_line(ev);
  130.  
  131.     } /* endfor */
  132.  
  133.    /* Datei schließen */
  134.     outfile.close();
  135.  
  136.     return(rc);
  137. }
  138.  
  139. /*
  140.  * getText (OK):
  141.  */
  142.  
  143. SOM_Scope long  SOMLINK getText(EDText *somSelf,  Environment *ev,
  144.                                 _IDL_SEQUENCE_long* sLNr)
  145. {
  146.     EDTextData *somThis = EDTextGetData(somSelf);
  147.     EDTextMethodDebug("EDText","getText");
  148. /**/
  149.     if (somThis->seqLNr._buffer) {
  150.        *sLNr = somThis->seqLNr;
  151.     } else {
  152.        return -1;
  153.     } /* endif */
  154.  
  155.     return 0;
  156. }
  157.  
  158. /*
  159.  * addLine (OK):
  160.  */
  161.  
  162. SOM_Scope long  SOMLINK addLine(EDText *somSelf,  Environment *ev,
  163.                                 long lnr, EDLine* ed_line)
  164. {
  165.     EDTextData *somThis = EDTextGetData(somSelf);
  166.     EDTextMethodDebug("EDText","addLine");
  167. /**/
  168.     if (lnr-1 != sequenceLength(somThis->seqLNr))
  169.        return -1;
  170.  
  171.    /* Zeile i in seqLines einfügen */
  172.     somThis->seqLines._buffer = (EDLine**)
  173.        SOMRealloc(somThis->seqLines._buffer, sizeof(EDLine*)
  174.                   *(sequenceLength(somThis->seqLines)+1));
  175.     sequenceElement(somThis->seqLines, sequenceLength(somThis->seqLines)) = ed_line;
  176.     sequenceLength(somThis->seqLines)++;
  177.  
  178.     somThis->seqLNr._buffer = (long*) SOMRealloc(somThis->seqLNr._buffer, sizeof (long) * (sequenceLength(somThis->seqLNr)+1) );
  179.     sequenceLength(somThis->seqLNr)++;
  180.     sequenceElement(somThis->seqLNr,
  181.        sequenceLength(somThis->seqLNr)-1) = sequenceLength(somThis->seqLines)-1;
  182.     somThis->nLines++;
  183.  
  184.     return (0);
  185. }
  186.  
  187. /*
  188.  * insLine (OK):
  189.  */
  190.  
  191. /*
  192.  * SOM_Scope long  SOMLINK insLine(EDText *somSelf,  Environment *ev,
  193.  *                                 long prelid, long aftlid, EDLine** ed_line)
  194.  */
  195.  
  196. /*
  197.  * The prototype for insLine was replaced by the following prototype:
  198.  */
  199. SOM_Scope long  SOMLINK insLine(EDText *somSelf,  Environment *ev,
  200.                                 long prelid, EDLine** ed_line)
  201. {
  202.     EDTextData *somThis = EDTextGetData(somSelf);
  203.     long    i, lid;
  204.     EDLine   *eLine;
  205.     EDTextMethodDebug("EDText","insLine");
  206. /**/
  207.    /* Zeile in seqLNr einfügen */
  208.     i = 0;
  209.     if (prelid != -1 /* Anfangszeile -> i=0 */) {
  210.        while ( prelid != sequenceElement(somThis->seqLNr, i)
  211.                && (i < sequenceLength(somThis->seqLNr))) {
  212.          i++;
  213.        } /* endwhile */
  214.        if (prelid != sequenceElement(somThis->seqLNr, i))
  215.           return -2;
  216.        i++;
  217.     }
  218.  
  219.    /* neue Zeile lid in seqLines erzeugen */
  220.     somThis->seqLines._buffer = (EDLine**) SOMRealloc(somThis->seqLines._buffer, sizeof(EDLine*)*(sequenceLength(somThis->seqLines)+1));
  221.     lid = sequenceLength(somThis->seqLines);
  222.     sequenceLength(somThis->seqLines)++;
  223.  
  224.    /* Neue EDLine erzeugen und setzen */
  225.     eLine = new EDLine;
  226.     eLine->set(ev, lid, "", "", 0, 0);
  227.     sequenceElement(somThis->seqLines, lid) = eLine;
  228.  
  229.    /* Zeile i in seqLNr einfügen */
  230.     somThis->seqLNr._buffer = (long*) SOMRealloc(somThis->seqLNr._buffer, sizeof(long)*(sequenceLength(somThis->seqLNr)+1));
  231.     sequenceLength(somThis->seqLNr)++;
  232.     for (int jj = sequenceLength(somThis->seqLNr)-1 ;jj > i; jj-- ) {
  233.        sequenceElement(somThis->seqLNr, jj) = sequenceElement(somThis->seqLNr, jj-1);
  234.     } /* endfor */
  235.     sequenceElement(somThis->seqLNr, i) = lid;
  236.     somThis->nLines++;
  237.  
  238.     *ed_line = eLine;
  239.  
  240.     return(lid);
  241. }
  242.  
  243. /*
  244.  * delLine (OK):
  245.  */
  246.  
  247. /*
  248.  * SOM_Scope long  SOMLINK delLine(EDText *somSelf,  Environment *ev,
  249.  *                                 long lid, long prelid, long aftlid)
  250.  */
  251.  
  252. /*
  253.  * The prototype for delLine was replaced by the following prototype:
  254.  */
  255. SOM_Scope long  SOMLINK delLine(EDText *somSelf,  Environment *ev,
  256.                                 long lid)
  257. {
  258.     EDTextData *somThis = EDTextGetData(somSelf);
  259.     long    i;
  260.     EDTextMethodDebug("EDText","delLine");
  261.  
  262.    /* Zeile aus seqLNr löschen */
  263.     i = 0;
  264.     while ( (lid != sequenceElement(somThis->seqLNr, i))
  265.             && (i < sequenceLength(somThis->seqLNr))) {
  266.       i++;
  267.     } /* endwhile */
  268.     if (lid == sequenceElement(somThis->seqLNr, i)) {
  269.  
  270.       /* Löschen */
  271.        for (int jj=i;jj<sequenceLength(somThis->seqLNr) ;jj++ ) {
  272.           sequenceElement(somThis->seqLNr, jj) = sequenceElement(somThis->seqLNr, jj+1);
  273.        } /* endfor */
  274.        somThis->seqLNr._buffer = (long*) SOMRealloc(somThis->seqLNr._buffer, sizeof(long)*(sequenceLength(somThis->seqLNr)-1));
  275.        sequenceLength(somThis->seqLNr)--;
  276.  
  277.     } else {
  278.        return -1;  /* ZeilenID nicht vorhanden */
  279.     } /* endif */
  280.  
  281.     return 0;
  282.  
  283. }
  284.  
  285. /*
  286.  * setLine (OK):
  287.  */
  288.  
  289. SOM_Scope long  SOMLINK setLine(EDText *somSelf,  Environment *ev,
  290.                                 long lid, EDLine* ed_line)
  291. {
  292.     EDTextData *somThis = EDTextGetData(somSelf);
  293.     EDLine *tmpline;
  294.     EDTextMethodDebug("EDText","setLine");
  295.  
  296.     if ((lid >= 0) && (lid < sequenceLength(somThis->seqLines))) {
  297.        tmpline = sequenceElement(somThis->seqLines,lid);
  298.        tmpline->set(ev, lid, ed_line->_get_line(ev), ed_line->_get_lock(ev), ed_line->_get_vnr(ev), ed_line->_get_ltime(ev));
  299.     } else {
  300.        return(-1);
  301.     }
  302.     return(0);
  303. }
  304.  
  305. /*
  306.  * getLine (OK):
  307.  */
  308.  
  309. SOM_Scope long  SOMLINK getLine(EDText *somSelf,  Environment *ev,
  310.                                 long lid, EDLine** ed_line)
  311. {
  312.     EDTextData *somThis = EDTextGetData(somSelf);
  313.     EDTextMethodDebug("EDText","getLine");
  314.  
  315.     if ((lid >= 0) && (lid < sequenceLength(somThis->seqLines))) {
  316.        *ed_line = sequenceElement(somThis->seqLines, lid);
  317.     } else {
  318.        return(-1);
  319.     } /* endif */
  320.  
  321.     return (0);
  322. }
  323.  
  324.  
  325.  
  326. SOM_Scope void SOMLINK somDefaultInit(EDText *somSelf, som3InitCtrl* ctrl)
  327. {
  328.     EDTextData *somThis; /* set in BeginInitializer */
  329.     somInitCtrl globalCtrl;
  330.     somBooleanVector myMask;
  331.     EDTextMethodDebug("EDText","somDefaultInit");
  332.     EDText_BeginInitializer_somDefaultInit;
  333.  
  334.     EDText_Init_SOMObject_somDefaultInit(somSelf, ctrl);
  335. /*a*/
  336.    /* Zeilenzuordnungsfeld init */
  337.     sequenceLength(somThis->seqLNr) = 0;
  338.     somThis->seqLNr._buffer =
  339.        (long*) SOMMalloc(sizeof (long));
  340.    /* Zeilenablagefeld init */
  341.     sequenceLength(somThis->seqLines) = 0;
  342.     somThis->seqLines._buffer =
  343.        (EDLine**) SOMMalloc(sizeof (EDLine *));
  344.    /* Variablen init */
  345.     somThis->nLines = 0; /* == sequenceLength(somThis->seqLNr) */
  346.     somThis->strFilePath = NULL;
  347. /*e*/
  348. }
  349.  
  350.  
  351. SOM_Scope void SOMLINK somDestruct(EDText *somSelf, octet doFree,
  352.                                    som3DestructCtrl* ctrl)
  353. {
  354.     EDTextData *somThis; /* set in BeginDestructor */
  355.     somDestructCtrl globalCtrl;
  356.     somBooleanVector myMask;
  357.     EDTextMethodDebug("EDText","somDestruct");
  358.     EDText_BeginDestructor;
  359.  
  360. /*a*/
  361.     EDLine *eLine;
  362.     long lid;
  363.  
  364.    /* Speicher für die EDLines freigeben */
  365.     for (long i=0 ;i<sequenceLength(somThis->seqLNr) ;i++ ) {
  366.        lid = sequenceElement(somThis->seqLNr, i);
  367.        if ((lid >= 0) && (lid < sequenceLength(somThis->seqLines))) {
  368.           eLine = sequenceElement(somThis->seqLines, lid);
  369.        }
  370.        if (eLine) {
  371.           delete eLine;
  372.        } /* endif */
  373.     } /* endfor */
  374.  
  375.    /* Speicher der Textablagefelder freigeben */
  376.     if (somThis->seqLNr._buffer)
  377.        SOMFree(somThis->seqLNr._buffer);
  378.     if (somThis->seqLines._buffer)
  379.        SOMFree(somThis->seqLines._buffer);
  380.     if (somThis->strFilePath)
  381.        SOMFree(somThis->strFilePath);
  382. /*e*/
  383.     EDText_EndDestructor;
  384. }
  385.  
  386.  
  387.