home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / edispm11.zip / EDisPM / SRC / Client / EDCLIENT.CPP < prev    next >
Text File  |  1996-05-14  |  32KB  |  843 lines
  1. /* EDClient.cpp: EDClient:      EDisPM.EXE V 1.1 */
  2. /* Editorclient - Client-(Edit-und User-) fenster*/
  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. /* latest changes: 11.5.1996                     */
  9. /*-----------------------------------------------*/
  10.  
  11. #include "EDISPM.H"
  12. #include "EDCLIENT.HPP"
  13.  
  14. #include <ititle.hpp>
  15. #include <iexcept.hpp>
  16.  
  17. /* Update-Thread-Klasse-Implementation */
  18. Update::Update (IFrameWindow *mainWin) :
  19.    mainWin(mainWin),
  20.    t()
  21. {
  22.    t.start(new IThreadMemberFn<Update>(*this, update));
  23. }
  24.  
  25. Update::~Update()
  26. {
  27.   t.stop();
  28. }
  29.  
  30. void Update::update()
  31. {
  32.    IWindowHandle handle;
  33.    handle = mainWin->handle();
  34.    for (; ; ) {
  35.       IThread::current().sleep(15000);
  36.       handle.postEvent(WM_COMMAND, IDMM_UPDATE, 0);
  37.    } /* endfor */
  38. }
  39.  
  40.  
  41. /* Editor-Client-Fenster-Klasse-Impl. */
  42. EDClient::EDClient (IFrameWindow *mW, IString uName) :
  43.     EDClientStub(mW, uName)
  44. {
  45.    mainWin = mW;
  46. }
  47.  
  48. EDClient::~EDClient()
  49. {
  50. }
  51.  
  52. short EDClient::openEditWindow(IMenuBar *mainWinMenu)
  53. {
  54.    short rc = 0;
  55.    long i;
  56.  
  57.    infoA->setInactiveText("");
  58.  
  59.   /* ClientAreaFenster erzeugen und im Hauptfenster anmelden */
  60.    EDMainSplitWin = new ISplitCanvas(0x8008, mainWin, mainWin);
  61.  
  62.   /* Text & Userfenster erzeugen und anordnen */
  63.    EDTextWin = new IMultiLineEdit(1, EDMainSplitWin, EDMainSplitWin,
  64.                                   IRectangle(),
  65.                                   IMultiLineEdit::classDefaultStyle
  66.                                   & ~IMultiLineEdit::wordWrap
  67.                                   | IMultiLineEdit::verticalScroll
  68.                                   | IMultiLineEdit::horizontalScroll
  69.                                   & ~IWindow::visible);
  70.    EDUserWin = new IContainerControl(2, EDMainSplitWin, EDMainSplitWin);
  71.  
  72.    EDMainSplitWin->setSplitWindowPercentage(EDTextWin, 75);
  73.    EDMainSplitWin->setSplitWindowPercentage(EDUserWin, 25);
  74.  
  75.    EDTextWin->setText("");
  76.  
  77.   /* Info von EDService holen: Zeilenanzahl, Eventcounter */
  78.    long lCount, lEventCnt;   getinfo(&lCount, &lEventCnt, getLogonUserNameStr());
  79.    eventCnt = lEventCnt;
  80.    nLines   = lCount;
  81.  
  82.   /* Text von EDService holen */
  83.    IString ltext("");
  84.    _IDL_SEQUENCE_long   llist;
  85.  
  86.   /* ZeilenInfoListe (EDTextInf-Sequence) leeren */
  87.    EDTextInf.removeAll();
  88.    if (!gettext(&llist)) {
  89.       EDLine*    lline;
  90.  
  91.       for (i=0; i<sequenceLength(llist); i++ ) {
  92.         /* Zeile anhand der ID holen */
  93.          getline(sequenceElement(llist, i), &lline, getLogonUserNameStr());
  94.  
  95.         /* MLE-Text aufbauen */
  96.          EDTextWin->addLineAsLast(lline->_get_line(ev));
  97.         /* Neue LineInfo erzeugen und füllen */
  98.          LineInfo linfo(  sequenceElement(llist, i),
  99.                           lline->_get_vnr(ev),
  100.                           lline->_get_lock(ev),
  101.                           lline->_get_ltime(ev) );
  102.         /* LineInfo in ZeilenInfoListe einfügen */
  103.          EDTextInf.addAsLast(linfo);
  104.       } /* endfor */
  105.    } /* endif */
  106.  
  107.   /* Client-Fenster in Hauptfenster einbinden */
  108.    mainWin->setClient(EDMainSplitWin);
  109.  
  110.   /* Cursor setzten */
  111.    lCursorLine = 0;
  112.    lCursorCol  = 0;
  113.    EDTextWin->setCursorAtLine(lCursorLine);
  114.    EDTextWin->setTop(lCursorLine);
  115.    EDTextWin->setFocus();
  116.    EDTextWin->show();
  117.  
  118.   /* Weise dem MLE den eigenen Keyboard-Handler zu */
  119.  
  120.    EDTextWinKHandler = new EDClient::EDKeyboardHandler(this);
  121.    EDTextWinKHandler->handleEventsFor(EDTextWin);
  122.    EDTextWinEHandler = new EDClient::EDEditHandler(this);
  123.    EDTextWinEHandler->handleEventsFor(EDTextWin);
  124.    EDTextWinMHandler = new EDClient::EDMouseClickHandler(this);
  125.    EDTextWinMHandler->handleEventsFor(EDTextWin);
  126.  
  127.   /* Userliste holen und in Userfenster eintragen */
  128.    _IDL_SEQUENCE_string ulist;
  129.  
  130.    if (!getusers(&ulist)) {
  131.       EDUserObject* user;
  132.       for (i=0; i<ulist._length; i++ ) {
  133.          IString name(ulist._buffer[i]);
  134.          if (name == getLogonUserNameStr())
  135.             name = name + "\n(myself)";
  136.          user = new EDUserObject (name,
  137.                           IDIC_EDISPM,
  138.                           "12345,6789",
  139.                           38);
  140.  
  141.          EDUserWin->addObject(user);
  142.       } /* endfor */
  143.    } /* endif */
  144.  
  145.    EDUserWin->arrangeIconView();
  146.    EDUserWin->showIconView();
  147.    mainWinMenu->setMenu(EDCLIENTMENU);
  148.  
  149.    mainWin->update();
  150.  
  151.   /* Neue Zeileninfo anzeigen */
  152.    setLineStatusInfo();
  153.  
  154.   /* Update-Thread starten */
  155.    upThread = new Update(mainWin);
  156.  
  157.    edClientStatus = 3;
  158.  
  159.    return 0;
  160. }
  161.  
  162.  
  163.  
  164. short EDClient::closeEditWindow(IStaticText *emptyClient, IMenuBar *mainWinMenu)
  165. {
  166.    short rc = 0;
  167.  
  168.    if (edClientStatus == 0)
  169.       return rc;
  170.  
  171.    if (edClientStatus == 3) {
  172.      /* Gesperrte Zeile entsperren */
  173.       ISequence<LineInfo>::Cursor lCursor(EDTextInf);
  174.  
  175.       EDTextInf.setToPosition(lCursorLine+1, lCursor);
  176.  
  177.       if ((EDTextInf.elementAt(lCursor)).lock == getLogonUserNameStr()) {
  178.          rc = putline((EDTextInf.elementAt(lCursor)).lid, getCursorLine(lCursorLine), (EDTextInf.elementAt(lCursor)).vnr + 1, getLogonUserNameStr());
  179.          if (rc >= 0) {
  180.             (EDTextInf.elementAt(lCursor)).vnr++;
  181.          } /* endif */
  182.          rc = rellock((EDTextInf.elementAt(lCursor)).lid, getLogonUserNameStr());
  183.          if (rc >= 0) {
  184.             (EDTextInf.elementAt(lCursor)).lock = "";
  185.          } /* endif */
  186.       } /* endif */
  187.  
  188.      /* Update-Thread stoppen */
  189.       upThread->~Update();
  190.  
  191.       delete EDUserWin;
  192.       delete EDTextWinKHandler;
  193.       delete EDTextWinEHandler;
  194.       delete EDTextWinMHandler;
  195.       delete EDTextWin;
  196.       delete EDMainSplitWin;
  197.  
  198.       infoA->setInactiveText("");
  199.  
  200.      /* Hauptfenster mit leerem Hintergrund und einfachen Menü besetzen */
  201.      /* falls nicht Programmende */
  202.       if ((emptyClient != NULL) && (mainWinMenu != NULL)) {
  203.          mainWin->setClient(emptyClient);
  204.          mainWinMenu->setMenu(EDMAINMENU);
  205.          mainWin->update();
  206.       } /* endif */
  207.    } /* endif */
  208.  
  209.    edClientStatus = 0;
  210.  
  211.    return rc;
  212. }
  213.  
  214. short EDClient::saveEditWinText()
  215. {
  216.    short rc;
  217.   /* Gesperrte Zeile entsperren */
  218.    ISequence<LineInfo>::Cursor lCursor(EDTextInf);
  219.  
  220.    EDTextInf.setToPosition(lCursorLine+1, lCursor);
  221.  
  222.    if ((EDTextInf.elementAt(lCursor)).lock == getLogonUserNameStr()) {
  223.       rc = putline((EDTextInf.elementAt(lCursor)).lid, getCursorLine(lCursorLine), (EDTextInf.elementAt(lCursor)).vnr + 1, getLogonUserNameStr());
  224.       if (rc >= 0) {
  225.          (EDTextInf.elementAt(lCursor)).vnr++;
  226.       } /* endif */
  227.       rc = rellock((EDTextInf.elementAt(lCursor)).lid, getLogonUserNameStr());
  228.       if (rc >= 0) {
  229.          (EDTextInf.elementAt(lCursor)).lock = "";
  230.       } /* endif */
  231.    } /* endif */
  232.  
  233.   /* EDService: Text abspeichern */
  234.    savetext(getLogonFileNameStr());
  235.  
  236.    return 0;
  237. }
  238.  
  239. short EDClient::isEditWindowActive()
  240. {
  241.    if (edClientStatus == 3)
  242.       return (short) true;
  243.  
  244.    return (short) false;
  245. }
  246.  
  247.  
  248. ULONG EDClient::getXCursorPos()
  249. {
  250.    return(EDTextWin->cursorLinePosition());
  251. }
  252.  
  253. ULONG EDClient::getYCursorPos()
  254. {
  255.    ULONG tmpYPos, tmpYOrgPos, tmpXPos;
  256.  
  257.    tmpXPos = EDTextWin->cursorLinePosition();
  258.    tmpYOrgPos = EDTextWin->cursorPosition();
  259.    EDTextWin->setCursorLinePosition(tmpXPos);
  260.    tmpYPos = tmpYOrgPos - EDTextWin->cursorPosition();
  261.    EDTextWin->setCursorPosition(tmpYOrgPos);
  262.  
  263.    return(tmpYPos);
  264. }
  265.  
  266. IString EDClient::getCursorLine(ULONG cPos)
  267. {
  268.    return(EDTextWin->text(cPos));
  269. }
  270.  
  271. void EDClient::setLineStatusInfo()
  272. {
  273.   // show line info in DocShell statusline
  274.    LineInfo lInfo = EDTextInf.elementAtPosition(lCursorLine+1);
  275.    IString  lInfText;
  276.    lInfText = "Zeile "+IString(lCursorLine+1)+" Spalte "+IString(lCursorCol+1);
  277.    if (lInfo.lock == "") {
  278.       lInfText += " Id "+ IString(lInfo.lid) +
  279.               " Vnr "+IString(lInfo.vnr);
  280.    } else {
  281.       lInfText += " Id "+ IString(lInfo.lid) +
  282.               " Vnr "+IString(lInfo.vnr)+" Gesperrt von "+lInfo.lock;
  283.    }
  284.    infoA->setInactiveText(lInfText);
  285. }
  286.  
  287.  
  288.  
  289. short EDClient::updateTextWin()
  290. {
  291.    short rc = 0;
  292.    long i, i2, lid, k1, k2, k3, k4, k1Tmp, k2Tmp;
  293.    EDUserObject* user;
  294.    _IDL_SEQUENCE_long   elist;   // Eventsliste
  295.    _IDL_SEQUENCE_string ulist;   // Userliste
  296.    _IDL_SEQUENCE_long   llist;   // Textliste
  297.    ISequence<LineInfo>::Cursor lCursor(EDTextInf);
  298.  
  299.    long     curXPos = getXCursorPos();
  300.    long     curYPos = getYCursorPos();
  301.    long     tmpYPos;
  302.  
  303.   /* Hole Eventliste seit dem letzten Update vom Server */
  304.    rc = getevents(&elist, getLogonUserNameStr());
  305.  
  306.    EDTextWin->disableUpdate();
  307.  
  308.   /* Wenn Text markiert->demarkieren */
  309. //   if (EDTextWin->hasSelectedText()) {
  310. //      EDTextWin->selectRange(IRange(curYPos, curYPos));
  311. //   } /* endif */
  312.  
  313. try {
  314.  
  315.   /* Prüfen, ob Cursor Zeile gewechselt hat */
  316.    if (lCursorLine != curXPos) {
  317.  
  318.      /* Wenn vorherige Zeile gesperrt von mir gesperrt: entsperren */
  319.       long curLine = lCursorLine;
  320.       EDTextInf.setToPosition(curLine+1, lCursor);
  321.       if ((EDTextInf.elementAt(lCursor)).lock == getLogonUserNameStr()) {
  322.          rc = putline((EDTextInf.elementAt(lCursor)).lid, getCursorLine(curLine), (EDTextInf.elementAt(lCursor)).vnr + 1, getLogonUserNameStr());
  323.          if (rc >= 0) {
  324.             (EDTextInf.elementAt(lCursor)).vnr++;
  325.          } /* endif */
  326.          rc = rellock((EDTextInf.elementAt(lCursor)).lid, getLogonUserNameStr());
  327.          if (rc >= 0) {
  328.             (EDTextInf.elementAt(lCursor)).lock = "";
  329.          } /* endif */
  330.       } /* endif */
  331.    } /* endif */
  332.  
  333.   /* Eventliste bearbeiten */
  334.    for (i=0; i<elist._length; i++ ) {
  335.  
  336.       switch (elist._buffer[i]) {
  337.       case -1:      // User-update
  338.  
  339.         /* Userliste holen und in Userfenster eintragen */
  340.          rc = getusers(&ulist);
  341.          EDUserWin->removeAllObjects();
  342.          for (i2=0; i2<ulist._length; i2++ ) {
  343.             IString name(ulist._buffer[i2]);
  344.             if (name == getLogonUserNameStr())
  345.                name = name + "\n(myself)";
  346.             user = new EDUserObject (name,
  347.                    IDIC_EDISPM,
  348.                    "12345,6789",
  349.                    38);
  350.  
  351.             EDUserWin->addObject(user);
  352.          } /* endfor */
  353.          EDUserWin->arrangeIconView();
  354.  
  355.          break;
  356.       case -2:      // Textreihenfolge verändert
  357.  
  358.         /* Text von EDService holen */
  359.          if (!gettext(&llist)) {
  360.             for (k1=0, k2=1; k1<sequenceLength(llist); k1++, k2++ ) {
  361.                if (k2 > EDTextInf.numberOfElements()) {
  362.  
  363.                  /* Neue Zeilen am Ende anhängen */
  364.                   LineInfo lInfo(sequenceElement(llist, k1), 0, "", 0);
  365.                   EDTextInf.addAsLast(lInfo);
  366.                  /* Erste Zeile */
  367.                   if ((k2 == 2) && (getCursorLine(0) == "")) {
  368.                      EDTextWin->addAsLast("^");
  369.                   } /* endif */
  370.                   EDTextWin->addLine("^", k2-1);
  371.  
  372.                } else if (sequenceElement(llist, k1) != (EDTextInf.elementAtPosition(k2)).lid) {
  373.  
  374.                   k1Tmp = sequenceElement(llist, k1);
  375.                   k2Tmp = (EDTextInf.elementAtPosition(k2)).lid;
  376.  
  377.                   for ( k3 = k1+1, k4 = k2+1;
  378.                            (k3 < sequenceLength(llist)-1)
  379.                         || (k4 < EDTextInf.numberOfElements());
  380.                         k3++, k4++)
  381.                   {
  382.                      if (k3 < sequenceLength(llist)-1) {
  383.                         if (sequenceElement(llist, k3) == k2Tmp) {
  384.                            break;
  385.                         } /* endif */
  386.                      } /* endif */
  387.                      if (k4 < EDTextInf.numberOfElements()) {
  388.                         if (k1Tmp == (EDTextInf.elementAtPosition(k4)).lid) {
  389.                            break;
  390.                         } /* endif */
  391.                      } /* endif */
  392.                   } /* endfor */
  393.  
  394.                   if (k4 <= EDTextInf.numberOfElements()) {
  395.                      if (k1Tmp == (EDTextInf.elementAtPosition(k4)).lid) {
  396.                        /* k4-k2-1 Elemente löschen */
  397.                         for (k3 = k2; k3<k4 ; k3++ ) {
  398.                            EDTextInf.removeAtPosition(k2);
  399.                            EDTextWin->removeLine(k2-1);
  400.                            if (curXPos > k2-1 ) {
  401.                               curXPos--;
  402.                            } /* endif */
  403.                         } /* endfor */
  404.                         goto ende_k3k4_behandlung;
  405.                      } /* endif */
  406.                   } /* endif */
  407.                   if (k3 < sequenceLength(llist)) {
  408.                      if (sequenceElement(llist, k3) == k2Tmp) {
  409.                        /* k3-k1 Elemente einfügen */
  410.                         for ( ; k1 < k3 ; k1++,k2++ ) {
  411.                            LineInfo lInfo(sequenceElement(llist, k1), 0, "", 0);
  412.                            EDTextWin->addLine("^", k2-1);
  413.                            EDTextInf.addAtPosition(k2, lInfo);
  414.                            if (curXPos >= k2-1 ) {
  415.                               curXPos++;
  416.                            } /* endif */
  417.                         } /* endfor */
  418.                         goto ende_k3k4_behandlung;
  419.                      } /* endif */
  420.                   } /* endif */
  421.                  /* Sonst: Element einfügen */
  422.                   {
  423.                      LineInfo lInfo(k1Tmp, 0, "", 0);
  424.                      EDTextWin->addLine("^", k2-1);
  425.                      EDTextInf.addAtPosition(k2, lInfo);
  426.                      if (curXPos >= k2-1 ) {
  427.                         curXPos++;
  428.                      } /* endif */
  429.                      goto ende_k3k4_behandlung;
  430.                   }
  431.  
  432.                   ende_k3k4_behandlung:;
  433.                } /* endif */
  434.             } /* endfor */
  435.             for (k4=k2; k4 <= EDTextInf.numberOfElements() ; k4++) {
  436.               /* Zeile am Ende löschen */
  437.                EDTextInf.removeAtPosition(k2);
  438.                EDTextWin->removeLine(k2-1);
  439.             } /* endfor */
  440.          } /* endif */
  441.          break;
  442.       default: // IDs geänderter Zeilen
  443.          if ((lid = sequenceElement(elist, i)) >= 0) {
  444.             EDLine *eLine;
  445.             rc = getline(lid, &eLine, getLogonUserNameStr());
  446.             if (rc >= 0) {
  447.                for ( i2 = 1; i2 < EDTextInf.numberOfElements()
  448.                              && (EDTextInf.elementAtPosition(i2)).lid != lid ;
  449.                      i2++);
  450.                if ((EDTextInf.elementAtPosition(i2)).lid == lid) {
  451.                   EDTextInf.setToPosition(i2, lCursor);
  452.                   if ((EDTextInf.elementAt(lCursor)).lock != getLogonUserNameStr()) {
  453.                      if (getCursorLine(i2-1) != eLine->_get_line(ev)) {
  454.                        /* Letzte Zeile ? */
  455.                         if (i2 >= EDTextWin->numberOfLines()) {
  456.                            EDTextWin->removeLine(i2-1);
  457.                            EDTextWin->addAsLast(eLine->_get_line(ev));
  458.                        /* Standard */
  459.                         } else {
  460.                            EDTextWin->removeLine(i2-1);
  461.                            EDTextWin->addLine(eLine->_get_line(ev), i2-1);
  462.                         } /* endif */
  463.                      } /* endif */
  464.                   } /* endif */
  465.  
  466.                   (EDTextInf.elementAt(lCursor)).lock  = eLine->_get_lock(ev);
  467.                   (EDTextInf.elementAt(lCursor)).vnr   = eLine->_get_vnr(ev);
  468.                   (EDTextInf.elementAt(lCursor)).ltime = 0;
  469.                } /* endif */
  470.             } /* endif */
  471.          } /* endif */
  472.  
  473.          break;
  474.       } /* endswitch */
  475.    } /* endfor */
  476.  
  477.    if (curXPos < 0)
  478.       curXPos = 0;
  479.    if (curXPos >= EDTextInf.numberOfElements() )
  480.       curXPos = EDTextInf.numberOfElements()-1;
  481.  
  482. } /* end try */
  483. catch ( IException& exc) {
  484.    weiter("Update has failed: k1:"+IString(k1)+" k2:"+IString(k2)+" curXPos:"+IString(curXPos)+"--"+exc.text());
  485. } /* end catch */
  486.  
  487.    EDTextWin->setCursorLinePosition(curXPos);
  488.    tmpYPos = EDTextWin->cursorPosition();
  489.    if (curYPos < 0)
  490.       curYPos = 0;
  491.    if (curYPos >= getCursorLine(curXPos).length()-1)
  492.       curYPos = getCursorLine(curXPos).length()-1;
  493.    EDTextWin->setCursorPosition(tmpYPos + curYPos);
  494.    EDTextWin->enableUpdate();
  495.  
  496.    lCursorLine = curXPos;
  497.    lCursorCol  = curYPos;
  498.  
  499.   /* Neue Zeileninfo anzeigen */
  500.    setLineStatusInfo();
  501.    return 0;
  502. }
  503.  
  504. short EDClient::setWindowView(long horzVert)
  505. {
  506.    if (horzVert == IDMM_HORZ) {
  507.       EDMainSplitWin->setOrientation(ISplitCanvas::horizontalSplit);
  508.    } else {
  509.       EDMainSplitWin->setOrientation(ISplitCanvas::verticalSplit);
  510.    } /* endif */
  511.    EDUserWin->arrangeIconView();
  512.    return 0;
  513. }
  514.  
  515.  
  516. /* EDTextWinKHandler: in EDClient eingelegte Klasse */
  517. EDClient::EDKeyboardHandler :: EDKeyboardHandler ( EDClient* client ) :
  518.   clClient( client )
  519. { }
  520.  
  521. Boolean EDClient::EDKeyboardHandler::characterKeyPress (IKeyboardEvent& event)
  522. {
  523.    Boolean dontPassOn = false;  // Standard: Zeichen weitergeben
  524.    long     curXPos = clClient->getXCursorPos();
  525.    long     curYPos = clClient->getYCursorPos();
  526.    IString  lText;
  527.    short    rc;
  528.    ISequence<LineInfo>::Cursor lCursor(clClient->EDTextInf);
  529.  
  530.   /* Wenn Text markiert->demarkieren */
  531. //   if (clClient->EDTextWin->hasSelectedText()) {
  532. //      clClient->EDTextWin->selectRange(IRange(curYPos, curYPos));
  533. //   } /* endif */
  534.  
  535.   /* Prüfen ob Zeile gesperrt, wenn nicht->sperren */
  536.    clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  537.    if ((clClient->EDTextInf.elementAt(lCursor)).lock != clClient->getLogonUserNameStr()) {
  538.       rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  539.       if (rc >= 0) {
  540.          (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  541.       } else {
  542.          dontPassOn = true;
  543.       } /* endif */
  544.    } /* endif */
  545.  
  546.    return dontPassOn;
  547. }
  548.  
  549. Boolean EDClient::EDKeyboardHandler :: virtualKeyPress ( IKeyboardEvent& event )
  550. {
  551.    Boolean  dontPassOn = true;  // Standard: Eingabe nicht gültig
  552.    long     curXPos = clClient->getXCursorPos();
  553.    long     curYPos = clClient->getYCursorPos();
  554.    LineInfo lInfo(0, 0, "",0);
  555.    IString  lText;
  556.    short    rc;
  557.    ISequence<LineInfo>::Cursor lCursor(clClient->EDTextInf);
  558.  
  559.   /* Wenn Text markiert->demarkieren */
  560. //   if (clClient->EDTextWin->hasSelectedText()) {
  561. //      clClient->EDTextWin->selectRange(IRange(curYPos, curYPos));
  562. //   } /* endif */
  563.  
  564.   /* Cursor runter */
  565.    switch (event.virtualKey()) {
  566.    case IKeyboardEvent::insert:
  567.       if (event.isAltDown()) {
  568.          clClient->EDTextWin->setChangedFlag();
  569.          dontPassOn = true;
  570.       } else if (!event.isShiftDown() && !event.isCtrlDown())
  571.          dontPassOn = false;
  572.       break;
  573.    case IKeyboardEvent::home:
  574.       if (!event.isAltDown() && !event.isShiftDown()) {
  575.          if (event.isCtrlDown()) {  /* Cursor in erste Zeile */
  576.             clClient->EDTextWin->setCursorLinePosition(0);
  577.             clClient->EDTextWin->setTop(0);
  578.             clClient->EDTextWin->setChangedFlag();
  579.             dontPassOn = true;
  580.          } else {
  581.             clClient->EDTextWin->setChangedFlag();
  582.             dontPassOn = false;
  583.          } /* endif */
  584.       } /* endif */
  585.       break;
  586.    case IKeyboardEvent::end:
  587.       if (!event.isAltDown() && !event.isShiftDown()) {
  588.          if (event.isCtrlDown()) {  /* Cursor in letzte Zeile */
  589.             clClient->EDTextWin->setCursorLinePosition(clClient->EDTextInf.numberOfElements()-1);
  590.             clClient->EDTextWin->setTop(clClient->EDTextInf.numberOfElements()-1);
  591.             clClient->EDTextWin->setChangedFlag();
  592.             dontPassOn = true;
  593.          } else {
  594.             clClient->EDTextWin->setChangedFlag();
  595.             dontPassOn = false;
  596.          } /* endif */
  597.       } /* endif */
  598.       break;
  599.    case IKeyboardEvent::up:         /* Cursor hoch */
  600.    case IKeyboardEvent::down:       /* Cursor runter */
  601.    case IKeyboardEvent::left:       /* Cursor links */
  602.    case IKeyboardEvent::right:      /* Cursor rechts */
  603.      /* Pure Cursor-Taste ? */
  604.       if (!event.isAltDown() && !event.isShiftDown()) {
  605.          IEventParameter1 param1(event.parameter1().number1() | 0x0020,
  606.                                  event.parameter1().char3(), 0);
  607.          (*event.window()).postEvent(IWindow::character, param1, IEventParameter2(0, 0x1A));
  608.          dontPassOn = false;
  609.       } /* endif */
  610.       break;
  611.    case IKeyboardEvent::space:
  612.       event.setResult(false);
  613.       dontPassOn = false;
  614.       break;
  615.    case IKeyboardEvent::enter:      /* Neue Zeile einfügen */
  616.    case IKeyboardEvent::newLine:
  617.       {
  618.          clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  619.          EDLine *eLine;
  620.          long prelid = (clClient->EDTextInf.elementAt(lCursor)).lid;
  621.          lCursor.setToNext();
  622.  
  623.          clClient->lCursorLine = curXPos;
  624.         /* Prüfen ob Zeile gesperrt, wenn nicht->sperren */
  625.          clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  626.          rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  627.          if (rc >= 0) {
  628.             (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  629.  
  630.             rc = clClient->insline(prelid, &eLine, clClient->getLogonUserNameStr());
  631.             if (rc >= 0) {
  632.                lInfo.lid = eLine->_get_lnr(clClient->ev);
  633.                lInfo.lock = eLine->_get_lock(clClient->ev);
  634.                lInfo.vnr = eLine->_get_vnr(clClient->ev);
  635.                clClient->EDTextInf.addAtPosition(curXPos+2, lInfo);
  636.  
  637. //                  clClient->EDTextWin->disableRefresh();
  638. //                  clClient->EDTextWin->addLine(eLine->_get_line(clClient->ev), curXPos+1);
  639. //
  640. //                  clClient->EDTextWin->setCursorAtLine(curXPos);
  641. //                  curY1Pos = clClient->EDTextWin->selectedRange().lowerBound();
  642. //                  clClient->EDTextWin->setCursorAt(curYPos);
  643. //
  644. //                  IString zeile1((clClient->getCursorLine(curXPos)).subString(1,curYPos-curY1Pos));
  645. //                  IString zeile2((clClient->getCursorLine(curXPos)).subString(curYPos-curY1Pos+1));
  646. //
  647. //                  rc = clClient->putline((clClient->EDTextInf.elementAt(lCursor)).lid, zeile1, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  648. //                  if (rc >= 0) {
  649. //                     (clClient->EDTextInf.elementAt(lCursor)).vnr++;
  650. //                     clClient->EDTextWin->removeLine(curXPos);
  651. //                     clClient->EDTextWin->addLine(zeile1, curXPos);
  652. //                  } /* endif */
  653. //                  lCursor.setToNext();
  654. //                  rc = clClient->putline((clClient->EDTextInf.elementAt(lCursor)).lid, zeile2, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  655. //                  if (rc >= 0) {
  656. //                     (clClient->EDTextInf.elementAt(lCursor)).vnr++;
  657. //                     clClient->EDTextWin->removeLine(curXPos+1);
  658. //                     clClient->EDTextWin->addLine(zeile2, curXPos+1);
  659. //                  } /* endif */
  660. //                  clClient->lCursorLine = curXPos+1;
  661. //                  clClient->EDTextWin->setCursorAtLine(clClient->lCursorLine);
  662. //                  clClient->EDTextWin->enableRefresh();
  663.                dontPassOn = false;
  664.            } /* endif */
  665.          } /* endif */
  666.       }
  667.       break;
  668.    case IKeyboardEvent::backSpace:
  669.       if (event.isCtrlDown()) {      /* Zeile löschen */
  670.  
  671.         /* Prüfen ob Zeile gesperrt, wenn nicht->sperren */
  672.          clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  673.          if ((clClient->EDTextInf.elementAt(lCursor)).lock != clClient->getLogonUserNameStr()) {
  674.             rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  675.             if (rc >= 0) {
  676.                (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  677.                clClient->EDTextWin->disableUpdate();
  678.               /* Letzte Zeile ? -> Zeile leeren */
  679.                if (curXPos+1 == clClient->EDTextInf.numberOfElements()) {
  680.                   clClient->EDTextWin->removeLine(curXPos);
  681.               /* Standard-Behandlung */
  682.                } else {
  683.                   long lid    = (clClient->EDTextInf.elementAt(lCursor)).lid;
  684.                   long vnr    = (clClient->EDTextInf.elementAt(lCursor)).vnr;
  685.                   rc = clClient->delline(lid, vnr, clClient->getLogonUserNameStr());
  686.                   if (rc >= 0) {
  687.                      long lc = clClient->getXCursorPos();
  688.                      clClient->EDTextWin->removeLine(curXPos);
  689.                      clClient->EDTextWin->setCursorLinePosition(lc);
  690.                      clClient->EDTextInf.removeAtPosition(curXPos+1);
  691.                   } /* endif */
  692.                } /* endif */
  693.                clClient->EDTextWin->enableUpdate();
  694.             } /* endif */
  695.          } /* endif */
  696.      /* Zeichen vor Cursor löschen */
  697.       } else if (!event.isAltDown() && !event.isShiftDown()) {
  698.  
  699.         /* Prüfen ob Cursor != 1. Zeichen in Zeile (Zeilenwechsel) */
  700.          if (curYPos > 0) {
  701.            /* Prüfen ob Zeile gesperrt, wenn nicht->sperren */
  702.             clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  703.             if ((clClient->EDTextInf.elementAt(lCursor)).lock != clClient->getLogonUserNameStr()) {
  704.                rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  705.                if (rc >= 0) {
  706.                   (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  707.                } else {
  708.                   dontPassOn = true;
  709.                   break;
  710.                } /* endif */
  711.             } /* endif */
  712.  
  713.            /* BackSpace-Taste gültig */
  714.             dontPassOn = false;
  715.          } /* endif */
  716.       } /* endif */
  717.       break;
  718.  
  719.   /* Zeichen nach Cursor löschen */
  720.    case IKeyboardEvent::deleteKey:
  721.       if (!event.isAltDown() && !event.isShiftDown() && !event.isCtrlDown()) {
  722.         /* Prüfen ob Cursor != letztes Zeichen in Zeile (Zeilenwechsel) */
  723.          if (curYPos >= clClient->getCursorLine(curXPos).length()-1) {
  724.            /* Zeile löschen und zusammenhängen */
  725.             if (curXPos+1 < clClient->EDTextInf.numberOfElements()) {
  726.                clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  727.                rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  728.                if (rc >= 0) {
  729.                   (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  730.                   lCursor.setToNext();
  731.                   rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  732.                   if (rc >=0) {
  733.                      (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  734.                      long lid    = (clClient->EDTextInf.elementAt(lCursor)).lid;
  735.                      long vnr    = (clClient->EDTextInf.elementAt(lCursor)).vnr;
  736.                      rc = clClient->delline(lid, vnr, clClient->getLogonUserNameStr());
  737.                      if (rc >= 0) {
  738.                         clClient->EDTextInf.removeAtPosition(curXPos+2);
  739.                         dontPassOn = false;
  740.                         break;
  741.                      } else {
  742.                         rc = clClient->rellock((clClient->EDTextInf.elementAt(lCursor)).lid, clClient->getLogonUserNameStr());
  743.                         if (rc >= 0) {
  744.                            (clClient->EDTextInf.elementAt(lCursor)).lock = "";
  745.                         } /* endif */
  746.                      } /* endif */
  747.                   } /* endif */
  748.                } /* endif */
  749.             } /* endif */
  750.          } else {
  751.            /* Zeichen löschen */
  752.            /* Prüfen ob Zeile gesperrt, wenn nicht->sperren */
  753.             clClient->EDTextInf.setToPosition(curXPos+1, lCursor);
  754.             if ((clClient->EDTextInf.elementAt(lCursor)).lock != clClient->getLogonUserNameStr()) {
  755.                rc = clClient->getlock((clClient->EDTextInf.elementAt(lCursor)).lid, (clClient->EDTextInf.elementAt(lCursor)).vnr, clClient->getLogonUserNameStr());
  756.                if (rc >= 0) {
  757.                   (clClient->EDTextInf.elementAt(lCursor)).lock = clClient->getLogonUserNameStr();
  758.                } else {
  759.                   dontPassOn = true;
  760.                   break;
  761.                } /* endif */
  762.             } /* endif */
  763.  
  764.            /* Delete-Taste gültig */
  765.             dontPassOn = false;
  766.          } /* endif */
  767.       } /* endif */
  768.       break;
  769.    default:
  770.      break;
  771.    } /* endswitch */
  772.    event.setResult(true);
  773.    return dontPassOn;
  774. }
  775.  
  776.  
  777.  
  778.  
  779. /* EDEditHandler: in EDClient eingelegte Klasse */
  780. EDClient::EDEditHandler :: EDEditHandler ( EDClient* client ) :
  781.   clClient( client )
  782. { }
  783.  
  784. Boolean EDClient::EDEditHandler::edit (IControlEvent& event)
  785. {
  786.    long     curLine;
  787.    LineInfo lInfo(0, 0, "", 0);
  788.    IString  lInfText;
  789.    ISequence<LineInfo>::Cursor lCursor(clClient->EDTextInf);
  790.    short    rc;
  791.    if ((clClient->getXCursorPos() < clClient->EDTextWin->numberOfLines())
  792.        && (clClient->getXCursorPos()+1 <= clClient->EDTextInf.numberOfElements())) {
  793.  
  794.      /* Prüfen, ob Cursor Zeile gewechselt hat */
  795.       curLine = clClient->lCursorLine;
  796.       clClient->EDTextInf.setToPosition(curLine+1, lCursor);
  797.  
  798.       if (clClient->lCursorLine != clClient->getXCursorPos()) {
  799.         /* Wenn vorherige Zeile gesperrt von mir gesperrt: entsperren */
  800.          if ((clClient->EDTextInf.elementAt(lCursor)).lock == clClient->getLogonUserNameStr()) {
  801.             rc = clClient->putline((clClient->EDTextInf.elementAt(lCursor)).lid, clClient->getCursorLine(curLine), (clClient->EDTextInf.elementAt(lCursor)).vnr + 1, clClient->getLogonUserNameStr());
  802.             if (rc >= 0) {
  803.                (clClient->EDTextInf.elementAt(lCursor)).vnr++;
  804.             } /* endif */
  805.             rc = clClient->rellock((clClient->EDTextInf.elementAt(lCursor)).lid, clClient->getLogonUserNameStr());
  806.             if (rc >= 0) {
  807.                (clClient->EDTextInf.elementAt(lCursor)).lock = "";
  808.             } /* endif */
  809.          } /* endif */
  810.       } /* endif */
  811.  
  812.      /* Neue Zeileninfo anzeigen */
  813.       clClient->lCursorLine = clClient->getXCursorPos();
  814.       clClient->lCursorCol  = clClient->getYCursorPos();
  815.       clClient->setLineStatusInfo();
  816.    } /* endif */
  817.  
  818.    return false;
  819. }
  820.  
  821.  
  822. /* EDMouseClickHandler: in EDClient eingelegte Klasse */
  823. EDClient::EDMouseClickHandler :: EDMouseClickHandler ( EDClient* client ) :
  824.   clClient( client )
  825. { }
  826.  
  827. Boolean EDClient::EDMouseClickHandler::mouseClicked (IMouseClickEvent& event)
  828. {
  829.    Boolean dontPassOn = true;   // Standard: Mouseclick verhindern
  830.    switch (event.mouseAction()) {
  831.    case IMouseClickEvent::click:
  832.       dontPassOn = false;
  833.       break;
  834.    case IMouseClickEvent::down:
  835.       clClient->EDTextWin->setFocus();
  836.       break;
  837.    default:
  838.      break;
  839.    } /* endswitch */
  840.    return dontPassOn;
  841. }
  842.  
  843.