home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / win_txl / txl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-13  |  76.1 KB  |  2,732 lines
  1. /************************************************************************
  2. *                .......................................                *
  3. *                .                                     .                *
  4. *                .       TOOLBOX - INTERPRETER         .                *
  5. *                . TESTPROGRAMM FÜR WINDOWS-FUNKTIONEN .                *
  6. *                .               TXL.C                 .                *
  7. *                .     M.Beising, K.Bauer & TOOLBOX    .                *
  8. *                .......................................                *
  9. *************************************************************************/
  10.  
  11. #include <windows.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <ctype.h>
  16. #include <math.h>
  17. #include "txl.h"
  18. #include "global.h"
  19. #include "helpid.h"
  20.  
  21. BOOL txlInit( hInstance )
  22. HANDLE hInstance;
  23. {
  24.     PWNDCLASS   ptxlClass;
  25.     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
  26.     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
  27.     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage,20 );
  28.  
  29.     ptxlClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );
  30.     ptxlClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
  31.     ptxlClass->hIcon          = LoadIcon( hInstance, MAKEINTRESOURCE(TXLICON) );
  32.     ptxlClass->lpszMenuName   = (LPSTR)NULL;
  33.     ptxlClass->lpszClassName  = (LPSTR)szAppName;
  34.     ptxlClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
  35.     ptxlClass->hInstance      = hInstance;
  36.     ptxlClass->style          = CS_HREDRAW | CS_VREDRAW;
  37.     ptxlClass->lpfnWndProc    = txlWndProc;
  38.     ptxlClass->cbClsExtra       = 0;
  39.     ptxlClass->cbWndExtra       = 0;
  40.  
  41.     if (!RegisterClass( (LPWNDCLASS)ptxlClass ) )
  42.            return FALSE;
  43.     LocalFree( (HANDLE)ptxlClass );
  44.     return TRUE;
  45. }
  46.  
  47.  
  48. int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
  49. HANDLE hInstance, hPrevInstance;
  50. LPSTR lpszCmdLine;
  51. int cmdShow;
  52. {
  53.     MSG   msg;
  54.     HWND  hWnd;
  55.     HMENU hMenu;
  56.     HANDLE hAccelTable;
  57.  
  58.    if (!hPrevInstance) {
  59.           if (!txlInit( hInstance ))
  60.             return FALSE;
  61.         }
  62.     else {
  63.             GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
  64.             GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
  65.             GetInstanceData( hPrevInstance, (PSTR)szMessage, 20 );
  66.             GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
  67.           }
  68.     hInst = hInstance;
  69.     hWnd = CreateWindow((LPSTR)szAppName,
  70.                         (LPSTR)szMessage,
  71.                               WS_OVERLAPPEDWINDOW |WS_CLIPCHILDREN,
  72.                               wX,
  73.                               wY,
  74.                               wW,
  75.                               wH,
  76.                               (HWND)NULL,
  77.                               (HMENU) LoadMenu(hInstance,(PSTR)"theMenu"),
  78.                               (HANDLE)hInstance,
  79.                               (LPSTR)NULL
  80.                         );
  81.     hWndglob=hWnd;
  82.     ShowWindow( hWnd, cmdShow );
  83.     GetClientRect(hWnd,(LPRECT)&rect);
  84.  
  85.     hWndEdit = CreateWindow((LPSTR)"Edit",
  86.                               (LPSTR)NULL,
  87.                               WS_CHILD | ES_MULTILINE | ES_AUTOVSCROLL |
  88.                               ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL,
  89.                               0,
  90.                               0,
  91.                               rect.right,
  92.                               rect.bottom,
  93.                               (HWND)hWnd,
  94.                               (HMENU)NULL,
  95.                               (HANDLE)hInstance,
  96.                               (LPSTR)NULL
  97.                               );
  98.     lpprocAbout = MakeProcInstance( (FARPROC)About, hInstance );
  99.     hMenu = GetSystemMenu(hWnd, FALSE);
  100.     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
  101.     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);
  102.  
  103.     MakeHelpPathName(szHelpFileName);
  104.     hHelpCursor = LoadCursor(hInst,"HelpCursor");
  105.  
  106.     UpdateWindow( hWnd );
  107.     SetFocus(hWnd);
  108.  
  109.     hAccelTable = LoadAccelerators( hInst, (LPSTR)"theAcc");
  110.  
  111.     while (TRUE)
  112.      {
  113.       if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  114.       {
  115.        if(msg.message==WM_QUIT)
  116.            break;
  117.        if (TranslateAccelerator(hWnd, hAccelTable, (LPMSG) &msg) ==0 )
  118.           {
  119.            TranslateMessage(&msg);
  120.            DispatchMessage(&msg);
  121.           }
  122.       } else
  123.                 if(RUNBREAK)
  124.                {
  125.                  if(WaitLine==NULL)
  126.                      {
  127.                       ActLine = FirstLine;
  128.                       HideCaret(hWndglob);
  129.                       ForCnt=0;
  130.                      }
  131.                      else
  132.                        ActLine = WaitLine;
  133.                          DoProgram ();
  134.                }
  135.      }
  136.        return msg.wParam;
  137. }
  138.  
  139.  
  140. long FAR PASCAL txlWndProc( hWnd, message, wParam, lParam )
  141. HWND hWnd;
  142. unsigned message;
  143. WORD wParam;
  144. LONG lParam;
  145. {
  146.     HDC hDC;
  147.     PAINTSTRUCT ps;
  148.     HANDLE hmenu;
  149.     WORD wFormat;
  150.     DWORD dwHelpContextId;
  151.     int i;
  152.     hmenu = GetMenu(hWnd);
  153.     switch (message)
  154.     {
  155.  
  156.     case WM_CHAR:
  157.                if(Edit) break;
  158.  
  159.                if(RUNBREAK && wParam==0x1b)
  160.                     {
  161.                      RUNBREAK=FALSE;
  162.                      WaitLine=NULL;
  163.                      break;
  164.                     } else if(RUNBREAK)
  165.                                  break;
  166.        switch(wParam)
  167.                 {
  168.                 case '\r':  if(!Readcnt) break;
  169.                                  ResetError();
  170.                                  ForCnt=0;
  171.                                  *NewLine.Zeile='\0';
  172.                                  InterAct ();
  173.                                  memset(ReadBuffer,'\0',255);
  174.                                  PRINTF(">");
  175.                                  x=tm.tmMaxCharWidth+6;
  176.                                  Readcnt=0;
  177.                                break;
  178.                 case '\b':
  179.                          if(!Readcnt)
  180.                               {
  181.                                 Readcnt=0;
  182.                                 ReadBuffer[0]='>';
  183.                                 Piep();
  184.                               }
  185.                                else
  186.                                   ReadBuffer[--Readcnt]='\0';
  187.  
  188.                 default: if(wParam >= ' ' && Readcnt<255)
  189.                                ReadBuffer[Readcnt++] = wParam;
  190.                                x=(ReadBuffer[0]!= '>' ? (tm.tmMaxCharWidth+6):0);
  191.                                Zeile-=(tm.tmHeight+2);
  192.                                if(Zeile<0)Zeile=0;
  193.                                PRINTF(ReadBuffer);
  194.                            break;
  195.                 }
  196.                 break;
  197.     case WM_CREATE :
  198.            BLACK=RGB(0,0,0);
  199.            BLAU=RGB(0,0,255);
  200.            GRUEN=RGB(0,255,0);
  201.            TURKIS=RGB(0,255,255);
  202.            ROT=RGB(255,0,0);
  203.            VIOLETT=RGB(255,0,255);
  204.            GELB=RGB(255,255,0);
  205.            WEISS=RGB(255,255,255);
  206.            GRAU=RGB(128,128,128);
  207.            hGrauBrush=CreateSolidBrush(GRAU);
  208.            hWeissBrush=CreateSolidBrush(WEISS);
  209.            hBlackBrush=CreateSolidBrush(BLACK);
  210.            hBlauBrush=CreateSolidBrush(BLAU);
  211.            hGruenBrush=CreateSolidBrush(GRUEN);
  212.            hTurkisBrush=CreateSolidBrush(TURKIS);
  213.            hRedBrush=CreateSolidBrush(ROT);
  214.            hViolettBrush=CreateSolidBrush(VIOLETT);
  215.            hGelbBrush=CreateSolidBrush(GELB);
  216.            hGrauPen=CreatePen(0,1,GRAU);
  217.            hWeissPen=CreatePen(0,1,WEISS);
  218.            hBlackPen=CreatePen(0,1,BLACK);
  219.            hBlauPen=CreatePen(0,1,BLAU);
  220.            hGruenPen=CreatePen(0,1,GRUEN);
  221.            hTurkisPen=CreatePen(0,1,TURKIS);
  222.            hRedPen=CreatePen(0,1,ROT);
  223.            hViolettPen=CreatePen(0,1,VIOLETT);
  224.            hGelbPen=CreatePen(0,1,GELB);
  225.            FirstLine=NULL;
  226.            ActLine=NULL;
  227.            FirstVar=NULL;
  228.            SetFileName ("work.txl");
  229.            break;
  230.     case WM_SIZE :
  231.             GetClientRect(hWnd,(LPRECT)&rect);
  232.             MoveWindow(hWndEdit,0,0,LOWORD(lParam),HIWORD(lParam),TRUE);
  233.             Zeile = 0;
  234.             return DefWindowProc( hWnd, message, wParam, lParam );
  235.            break;
  236.     case WM_INITMENU:
  237.              if (bHelp)
  238.              {
  239.               SetCursor(hHelpCursor);
  240.               return TRUE;
  241.              }
  242. if (wParam == hmenu)
  243.  {
  244.  
  245.        (Mono) ? CheckMenuItem(hmenu,MN_MONO,MF_CHECKED) :
  246.                     CheckMenuItem(hmenu,MN_MONO,MF_UNCHECKED);
  247.        (TXW4) ? CheckMenuItem(hmenu,MN_KURSIV,MF_CHECKED) :
  248.                     CheckMenuItem(hmenu,MN_KURSIV,MF_UNCHECKED);
  249.        (TXW3) ? CheckMenuItem(hmenu,MN_UNTERS,MF_CHECKED) :
  250.                     CheckMenuItem(hmenu,MN_UNTERS,MF_UNCHECKED);
  251.        (TYW3) ? CheckMenuItem(hmenu,MN_DURCHG,MF_CHECKED) :
  252.                     CheckMenuItem(hmenu,MN_DURCHG,MF_UNCHECKED);
  253.    for (ini = 0;ini<8;ini++)
  254.             (TXW1==ini) ? CheckMenuItem(hmenu,(ini+126),MF_CHECKED) :
  255.                               CheckMenuItem(hmenu,(ini+126),MF_UNCHECKED);
  256.             CheckMenuItem(hmenu,MW_NORMAL,MF_UNCHECKED);
  257.             CheckMenuItem(hmenu,MW_HEAVY,MF_UNCHECKED);
  258.            if(TYW2==500)
  259.             CheckMenuItem(hmenu,MW_NORMAL,MF_CHECKED);
  260.            if(TYW2==600)
  261.             CheckMenuItem(hmenu,MW_HEAVY,MF_CHECKED);
  262.    for (ini = 8;ini<55;ini++)
  263.             switch(ini)
  264.               {
  265.                case 9:
  266.                case 11:
  267.                case 17:
  268.                case 23:
  269.                case 25:
  270.                case 31:
  271.                case 33:
  272.                case 34:
  273.                case 41:
  274.                case 43:
  275.                case 46:
  276.                case 47:
  277.                case 49:
  278.                case 51:
  279.                case 53:
  280.                case 55:
  281.                           break;
  282.               default:
  283.             (TXW2==ini) ? CheckMenuItem(hmenu,(ini),MF_CHECKED) :
  284.                               CheckMenuItem(hmenu,(ini),MF_UNCHECKED);
  285.                           break;
  286.               }
  287.  
  288.     OpenClipboard(hWnd);
  289.     wFormat = 0;
  290.     while ((wFormat = EnumClipboardFormats(wFormat)) != 0 && wFormat != CF_TEXT);
  291.     (wFormat == CF_TEXT ? (EnableMenuItem(hmenu,MN_PASTE,MF_ENABLED)):
  292.                                 (EnableMenuItem(hmenu,MN_PASTE,MF_GRAYED)));
  293.      CloseClipboard();
  294.  
  295. if(Edit)
  296.   {
  297.      for(icnt=MN_UNDO;icnt<=MN_WERSETZE;icnt++)
  298.            EnableMenuItem(hmenu,(WORD)icnt,MF_ENABLED);
  299.      for(icnt=MN_EDITOR;icnt<=MN_RUN;icnt++)
  300.            EnableMenuItem(hmenu,(WORD)icnt,MF_GRAYED);
  301.   }
  302.   else
  303.    {
  304.      for(icnt=MN_UNDO;icnt<=MN_WERSETZE;icnt++)
  305.            EnableMenuItem(hmenu,(WORD)icnt,MF_GRAYED);
  306.      for(icnt=MN_EDITOR;icnt<=MN_RUN;icnt++)
  307.            EnableMenuItem(hmenu,(WORD)icnt,MF_ENABLED);
  308.    }
  309.  
  310.     (Drucker ? (EnableMenuItem(hmenu,MN_SCREEN,MF_ENABLED)):
  311.                  (EnableMenuItem(hmenu,MN_SCREEN,MF_GRAYED)));
  312. }
  313.               break;
  314.  
  315.     case WM_COMMAND:
  316.  
  317.              i=0;
  318.              if(!bHelp && wParam == MN_HELP)
  319.                  {
  320.                      ReadBuffer[Readcnt] = '\0';
  321.  
  322.                      for (i==0;i < (TOKMAX-TOKMIN-1);i++)
  323.                          if(strcmpi(ReadBuffer,&TokBefDesc[i].Befehl[0])==0)
  324.                               break;
  325.                      if(i>=(TOKMAX-TOKMIN-1)) i=0;
  326.                        else
  327.                          {
  328.                           i+=100;
  329.                           bHelp=TRUE;
  330.                          }
  331.                  }
  332.  
  333.              if (bHelp) {
  334.                  dwHelpContextId =
  335.                        (i > 99)  ? (DWORD) i :
  336.                        (wParam == MN_HELP)    ? (DWORD) HELPID_MENU_HELP   :
  337.                        (wParam == MN_RUN)     ? (DWORD) HELPID_MENU_RUN    :
  338.                        (wParam == MN_LOAD)    ? (DWORD) HELPID_MENU_LOAD   :
  339.                        (wParam == MN_SAVE)    ? (DWORD) HELPID_MENU_SAVE   :
  340.                        (wParam == MN_LIST)    ? (DWORD) HELPID_MENU_LIST   :
  341.                        (wParam == MN_TYPESET) ? (DWORD) HELPID_MENU_TYPE   :
  342.                        (wParam == MN_CLS)     ? (DWORD) HELPID_MENU_CLS    :
  343.                        (wParam == MN_MONO)    ? (DWORD) HELPID_MENU_MONO   :
  344.                        (wParam == MN_EDITOR)  ? (DWORD) HELPID_MENU_EDITOR :
  345.                        (wParam == MN_INTERPR) ? (DWORD) HELPID_MENU_INTERPR:
  346.                        (wParam == MN_UNDO)    ? (DWORD) HELPID_MENU_UNDO   :
  347.                        (wParam == MN_CUT)     ? (DWORD) HELPID_MENU_CUT    :
  348.                        (wParam == MN_COPY)    ? (DWORD) HELPID_MENU_COPY   :
  349.                        (wParam == MN_PASTE)   ? (DWORD) HELPID_MENU_PASTE  :
  350.                        (wParam == MN_CLEAR)   ? (DWORD) HELPID_MENU_CLEAR  :
  351.                        (wParam == MN_SELECT)  ? (DWORD) HELPID_MENU_SELECT :
  352.                        (wParam == MN_ELOAD)   ? (DWORD) HELPID_MENU_ELOAD  :
  353.                        (wParam == MN_ESAVE)   ? (DWORD) HELPID_MENU_ESAVE  :
  354.                        (wParam == MN_SEARCH)  ? (DWORD) HELPID_MENU_SEARCH :
  355.                        (wParam == MN_WSEARCH) ? (DWORD) HELPID_MENU_WSEARCH :
  356.                        (wParam == MN_ERSETZE) ? (DWORD) HELPID_MENU_ERSETZE  :
  357.                        (wParam == MN_WERSETZE) ? (DWORD) HELPID_MENU_WERSETZE :
  358.                        (DWORD) 0L;
  359.  
  360.                  if (!dwHelpContextId)
  361.                         dwHelpContextId = (DWORD)HELPID_MENU_HELP;
  362.                  bHelp = FALSE;
  363.                  WinHelp(hWnd,szHelpFileName,HELP_CONTEXT,dwHelpContextId);
  364.                  break;
  365.              }
  366.  
  367.            menuecommand(hWnd,wParam);
  368.               break;
  369.     case WM_SYSCOMMAND:
  370.         switch (wParam)
  371.         {
  372.         case IDSABOUT:
  373.             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
  374.             break;
  375.         default:
  376.             return DefWindowProc( hWnd, message, wParam, lParam );
  377.         }
  378.         break;
  379.        case WM_LBUTTONDOWN:
  380.              if (bHelp)
  381.              {
  382.                  bHelp = FALSE;
  383.                  WinHelp( hWnd, szHelpFileName, HELP_CONTEXT,
  384.                               (DWORD) HELPID_MENU_HELP );
  385.                  break;
  386.              }
  387.  
  388.              return (DefWindowProc(hWnd, message, wParam, lParam));
  389.  
  390.  
  391.        case WM_NCLBUTTONDOWN:
  392.              if (bHelp) {
  393.                  dwHelpContextId = (DWORD)HELPID_MENU_HELP;
  394.                  bHelp = FALSE;
  395.                  WinHelp(hWnd,szHelpFileName,HELP_CONTEXT,dwHelpContextId);
  396.                  break;
  397.              }
  398.  
  399.              return (DefWindowProc(hWnd, message, wParam, lParam));
  400.        case WM_KEYDOWN:
  401.                  if(Anfang)
  402.                           {
  403.                                ccls();
  404.                                PRINTF(">");
  405.                                x=tm.tmMaxCharWidth+6;
  406.                                Zeile=0;
  407.                                Anfang=FALSE;
  408.                           }
  409.              if (wParam == VK_F1) {
  410.                  if (GetKeyState(VK_SHIFT)<0) {
  411.                        bHelp = TRUE;
  412.                        SetCursor(hHelpCursor);
  413.                        return (DefWindowProc(hWnd, message, wParam, lParam));
  414.                  }
  415.                  else {
  416.                        WinHelp(hWnd,szHelpFileName,HELP_INDEX,0L);
  417.                  }
  418.              }
  419.  
  420.              else if (wParam == VK_ESCAPE && bHelp) {
  421.                  bHelp = FALSE;
  422.                  SetCursor((HCURSOR)GetClassWord(hWnd,GCW_HCURSOR));
  423.              }
  424.              break;
  425.  
  426.        case WM_SETCURSOR:
  427.              if (bHelp) {
  428.                  SetCursor(hHelpCursor);
  429.                  break;
  430.              }
  431.              return (DefWindowProc(hWnd, message, wParam, lParam));
  432.              break;
  433.  
  434.        case WM_ENTERIDLE:
  435.              if ((wParam == MSGF_MENU) && (GetKeyState(VK_F1) & 0x8000)) {
  436.                  bHelp = TRUE;
  437.                  PostMessage(hWnd, WM_KEYDOWN, VK_RETURN, 0L);
  438.              }
  439.              break;
  440.  
  441.     case WM_DESTROY:
  442.            cscreen();
  443.            cneu();
  444.            DeleteObject(hBlackBrush);
  445.            DeleteObject(hBlauBrush);
  446.            DeleteObject(hGruenBrush);
  447.            DeleteObject(hTurkisBrush);
  448.            DeleteObject(hRedBrush);
  449.            DeleteObject(hViolettBrush);
  450.            DeleteObject(hGelbBrush);
  451.            DeleteObject(hWeissBrush);
  452.            DeleteObject(hGrauBrush);
  453.  
  454.            DeleteObject(hBlackPen);
  455.            DeleteObject(hBlauPen);
  456.            DeleteObject(hGruenPen);
  457.            DeleteObject(hTurkisPen);
  458.            DeleteObject(hRedPen);
  459.            DeleteObject(hViolettPen);
  460.            DeleteObject(hGelbPen);
  461.            DeleteObject(hWeissPen);
  462.            DeleteObject(hGrauPen);
  463.            if(bCaret)
  464.              DestroyCaret();
  465.            WinHelp(hWnd,szHelpFileName,HELP_QUIT,0L);
  466.            PostQuitMessage( 0 );
  467.         break;
  468.  
  469.   case WM_PAINT:
  470.                if(Drucker)
  471.                  break;
  472.           BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
  473.             Zeile=0;
  474.           if(Anfang)
  475.                 {
  476.                     txlBitmap(hWnd,ps.hdc);
  477.                     GetTextMetrics(ps.hdc,(LPTEXTMETRIC)&tm);
  478.                     CreateCaret(hWnd,1,tm.tmAveCharWidth,tm.tmHeight);
  479.                     bCaret=TRUE;
  480.                     ShowCaret(hWnd);
  481.                 }
  482.           EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
  483.              if(!Edit) {
  484.                            if(Readcnt)
  485.                               PRINTF(ReadBuffer);
  486.                                else
  487.                                 {
  488.                                  x=0;
  489.                                  Zeile=0;
  490.                                  PRINTF(">");
  491.                                 }
  492.                               Zeile-=(tm.tmHeight+2);
  493.                           }
  494.           break;
  495.     case WM_SETFOCUS:
  496.           if(!Edit)
  497.             ErzeugeCursor(hWnd);
  498.              else SetFocus(hWndEdit);
  499.           break;
  500.     case WM_KILLFOCUS:
  501.            if(bCaret)
  502.                {
  503.                 DestroyCaret();
  504.                 bCaret=FALSE;
  505.                }
  506.     default:
  507.           return DefWindowProc( hWnd, message, wParam, lParam );
  508.         break;
  509.     }
  510.     return(0L);
  511. }
  512.  
  513. void txlBitmap(HWND hWnd,HDC hDC)
  514. {
  515.   HDC hcDC;
  516.       hBitmap = LoadBitmap(hInst,(LPSTR)"toolbox");
  517.       hcDC    = CreateCompatibleDC(hDC);
  518.  
  519.       hOldBitmap = SelectObject(hcDC,hBitmap);
  520.       SetStretchBltMode(hDC,WHITEONBLACK);
  521.       SetTextColor(hDC,GELB);
  522.       SetBkColor(hDC,ROT);
  523.       StretchBlt(hDC,100,10,72,72,hcDC,0,0,72,72,SRCCOPY);
  524.       SetTextColor(hDC,GRUEN);
  525.       SetBkColor(hDC,BLAU);
  526.       StretchBlt(hDC,200,55,72,72,hcDC,0,0,72,72,SRCCOPY);
  527.       SetTextColor(hDC,VIOLETT);
  528.       SetBkColor(hDC,GELB);
  529.       StretchBlt(hDC,300,100,72,72,hcDC,0,0,72,72,SRCCOPY);
  530.  
  531.       DeleteObject(SelectObject(hcDC,hOldBitmap));
  532.       DeleteDC(hcDC);
  533. }
  534.  
  535. void InterAct ()
  536. {
  537.     char Ausgabe[30];
  538.     LinePos = ReadBuffer;
  539.     SkipChar ();
  540.     Scan ();
  541.  
  542.     if (Steuer == ZIFFER) {
  543.       NewLine.LineNumber = atoi (ScanBuffer);
  544.       ActLine = 
  545.       if (MakeToken () == OK)
  546.       InsIntLine ();
  547.       else {
  548.                     sprintf (Ausgabe,"%s %03d %s ","# Zeile",
  549.                                  NewLine.LineNumber,"ist gel÷scht! #");
  550.  
  551.                        PRINTF (Ausgabe);
  552.                     DelLine (NewLine.LineNumber);
  553.       }
  554.     }
  555.     else {
  556.       ActLine = 
  557.       SkipChar ();
  558.       LinePos = ReadBuffer;
  559.       if (MakeToken () == OK) {
  560.           LinePos = ActLine->Zeile;
  561.           InterpLine ();
  562.       }
  563.       else {
  564.           sprintf (ReadBuffer,"# Befehl <%s> unbekannt #",ScanBuffer);
  565.           serror (ReadBuffer);
  566.       }
  567.     }
  568. }
  569.  
  570. int InterpLine ()
  571. {
  572. int i,error;
  573.  i = 0xff & *LinePos;
  574.   if ((i >= TOKMIN) && (i <= TOKMAX)) {
  575.     LinePos++;
  576.     SkipChar ();
  577.     error = TokBefDesc[i-TOKMIN].function ();
  578.   }
  579.   else {
  580.     serror ("# Unbekannter Befehl! #");
  581.     error = FALSE;
  582.   }
  583. return (error);
  584. }
  585.  
  586. int DoProgram ()
  587. {
  588. int error = TRUE;
  589.  if(!RUNBREAK)
  590.   {
  591.    SetCursor(LoadCursor(NULL,IDC_WAIT));
  592.    SetCursorPos(100,30);
  593.    ForCnt=0;
  594.   }
  595.   while (ActLine && error && !TreeError)
  596.    {
  597.     LinePos = ActLine->Zeile;
  598.     GetNextLine = TRUE;
  599.     error = InterpLine ();
  600.     if (GetNextLine)
  601.       ActLine = ActLine->NextZeile;
  602.        WaitLine = ActLine;
  603.       if (IntError || RUNBREAK)
  604.            break;
  605.     }
  606.     if(!RUNBREAK)
  607.       SetCursor(LoadCursor(NULL,IDC_ARROW));
  608.      if(!ActLine) RUNBREAK=FALSE;
  609. return (error);
  610. }
  611.  
  612. int MakeToken ()
  613. {
  614. int     i,j;
  615. int     LineSym;
  616. char    *TokLine;
  617.   TokLine = ActLine->Zeile;
  618.   if (Scan () == UNEOL)
  619.      return (ERROR_1);
  620.   if (TestBefehl(&i) == 0) {
  621.     *TokLine++ = i + TOKMIN;
  622.     *TokLine = '\0';
  623.     if (TokBefDesc[i].CopyRest) {
  624.       strcat (TokLine,LinePos);
  625.       return (OK);
  626.     }
  627.     else
  628.       for (LineSym = TokBefDesc[i].ParaCount;
  629.              LineSym ; LineSym--) {
  630.       if (Scan () == SCANOK)
  631.           if (TestBefehl(&i) == 0) {
  632.             *TokLine++ = i + TOKMIN;
  633.             *TokLine = '\0';
  634.           }
  635.           else {
  636.             strcat (TokLine,ScanBuffer);
  637.             TokLine = strchr (TokLine,'\0');
  638.           }
  639.       else
  640.           return (ERROR_1);
  641.     }
  642.   }
  643.   else
  644.     return (ERROR_1);
  645. return (OK);
  646. }
  647.  
  648. int TestBefehl (int *Befehl)
  649. {
  650. int i,j;
  651.  
  652.   for (i = 0;
  653.        (TokBefDesc[i].function != NULL) &&
  654.        ((j = strcmp(TokBefDesc[i].Befehl,ScanBuffer)) != 0)
  655.        ; i++) {
  656.     }
  657.   *Befehl = i;
  658. return (j);
  659. }
  660.  
  661. void InsIntLine ()
  662. {
  663. PRGZEILE        *NewLine;
  664. PRGZEILE        *InsZeile;
  665.  
  666.             NewLine = (PRGZEILE NEAR *)LocalAlloc (LPTR,sizeof(PRGZEILE));
  667.           if (NewLine == NULL) {
  668.               PRINTF ("#### Kein Speicherplatz mehr vorhanden! ####");
  669.             return;
  670.           }
  671.  
  672.           if (!FirstLine) {
  673.             FirstLine = NewLine;
  674.             NewLine->LineNumber = ActLine->LineNumber;
  675.             strcpy (NewLine->Zeile,ActLine->Zeile);
  676.             NewLine->NextZeile = NULL;
  677.             NewLine->PrevZeile = NULL;
  678.             return;
  679.           }
  680.  
  681.           if (FindInsPos(ActLine->LineNumber,&InsZeile)) {
  682.                     strcpy (InsZeile->Zeile,ActLine->Zeile);
  683.                     LocalFree ((LOCALHANDLE)NewLine);
  684.           }
  685.           else {
  686.                     NewLine->LineNumber = ActLine->LineNumber;
  687.                     strcpy (NewLine->Zeile,ActLine->Zeile);
  688.                     if ((InsZeile == FirstLine) &&
  689.                         (InsZeile->LineNumber < NewLine->LineNumber)) {
  690.                       NewLine->NextZeile = NULL;
  691.                       NewLine->PrevZeile = InsZeile;
  692.                       InsZeile->NextZeile = NewLine;
  693.                       return;
  694.                     }
  695.  
  696.                     if (InsZeile->NextZeile) {
  697.                       NewLine->NextZeile  = InsZeile;
  698.                       NewLine->PrevZeile  = InsZeile->PrevZeile;
  699.  
  700.                       if (InsZeile->PrevZeile)
  701.                               InsZeile->PrevZeile->NextZeile = NewLine;
  702.                       else
  703.                               FirstLine = NewLine;
  704.                       InsZeile->PrevZeile = NewLine;
  705.                     }
  706.                     else {
  707.                       NewLine->NextZeile = NULL;
  708.                       NewLine->PrevZeile = InsZeile;
  709.                       InsZeile->NextZeile = NewLine;
  710.                     }
  711.           }
  712. }
  713.  
  714. int FindInsPos (LineNumber,InsPos)
  715. int             LineNumber;
  716. PRGZEILE        **InsPos;
  717. {
  718. PRGZEILE        *FindZeile,*LastLine;
  719.  
  720.           FindZeile = FirstLine;
  721.  
  722.           while ((FindZeile != NULL) &&
  723.                  (FindZeile->LineNumber < LineNumber)) {
  724.       LastLine = FindZeile;
  725.             FindZeile = FindZeile->NextZeile;
  726.           }
  727.           if (!FindZeile)
  728.             FindZeile = LastLine;
  729.  
  730.           if (FindZeile->LineNumber == LineNumber) {
  731.             *InsPos = FindZeile;
  732.             return (TRUE);
  733.           }
  734.           else {
  735.             *InsPos =  FindZeile;
  736.             return (FALSE);
  737.           }
  738. }
  739.  
  740. int
  741. DelLine (int LineNumber)
  742. {
  743. PRGZEILE        *InsPos;
  744.           if (FindInsPos (LineNumber,&InsPos)) {
  745.             if ((InsPos->NextZeile == NULL) &&
  746.                 (InsPos->PrevZeile == NULL))
  747.               FirstLine = NULL;
  748.             else
  749.                     if (InsPos == FirstLine) {
  750.                         FirstLine = InsPos->NextZeile;
  751.                         InsPos->NextZeile->PrevZeile = NULL;
  752.                     }
  753.                     else {
  754.                       if (InsPos->NextZeile == NULL)
  755.                         InsPos->PrevZeile->NextZeile = NULL;
  756.                       else {
  757.                           InsPos->PrevZeile->NextZeile = InsPos->NextZeile;
  758.                           InsPos->NextZeile->PrevZeile = InsPos->PrevZeile;
  759.                       }
  760.               }
  761.             LocalFree ((LOCALHANDLE)InsPos);
  762.             return (TRUE);
  763.           }
  764.           else
  765.             return (FALSE);
  766. }
  767.  
  768. /* SCANNER */
  769.  
  770. int Scan ()
  771. {
  772. int test;
  773. char    *buffer;
  774.  
  775.   GetChar ();
  776.   SkipSpace ();
  777.  
  778.   if ((test = isalpha(Charakter)) != FALSE)
  779.     test = ALPHA;
  780.   else
  781.     if ((test = isdigit (Charakter)) != FALSE)
  782.       test = ZIFFER;
  783.        else
  784.            test = Charakter;
  785.  
  786.   switch (test) {
  787.     case ALPHA :
  788.       Steuer = ALPHA;
  789.       GetBezeichner (ScanBuffer);
  790.       NoSkipChar ();
  791.       break;
  792.     case ZIFFER :
  793.       GetZahl (ScanBuffer);
  794.       NoSkipChar ();
  795.       break;
  796.     case '"'        :
  797.       GetString (ScanBuffer);
  798.        if(IntError)
  799.              Steuer = EOLCHAR;
  800.                else
  801.                 Steuer = STRING;
  802.       break;
  803.     case '?'        :
  804.     case '('        :
  805.     case ')'        :
  806.     case '='        :
  807.     case '<'        :
  808.     case '>'        :
  809.     case '/'        :
  810.     case '*'        :
  811.     case '+'        :
  812.     case '-'        :
  813.       ScanBuffer[0] = Charakter;
  814.       ScanBuffer[1] = '\0';
  815.       Steuer = SONDER;
  816.       break;
  817.     case ',':
  818.        Steuer = TRENNER;
  819.       break;
  820.     case ';':
  821.       ScanBuffer[0] = Charakter;
  822.       ScanBuffer[1] = '\0';
  823.       Steuer = EOLCHAR;
  824.       break;
  825.     case EOLFEHLER:
  826.       return (UNEOL);
  827.     default :
  828.       Steuer = UNKNOWN;
  829.       fatal_error ("#  Ungⁿltiges Zeichen gefunden! #");
  830.       return (INVCHAR);
  831.   }
  832.  
  833. return (SCANOK);
  834. }
  835.  
  836. void SkipSpace ()
  837. {
  838.           while (Charakter == SPACE)
  839.             GetChar ();            /* Leerzeichen ueberlesen */
  840. }
  841.  
  842. void GetChar ()
  843. {
  844.   if (NeedNext == TRUE)
  845.     GetNextChar ();
  846.   else
  847.     NeedNext = TRUE;
  848. }
  849.  
  850. void GetNextChar ()
  851.  
  852. {
  853.  if (*LinePos != '\0') {
  854.    Charakter = *LinePos++;
  855.  }
  856.  else
  857.    Charakter = EOLFEHLER;
  858. }
  859.  
  860. void GetBezeichner (char *buffer)
  861. {
  862. int count = 0;
  863.  
  864.  while ((Charakter ==  '$') || (isalpha (Charakter) || isdigit (Charakter)) &&
  865.        (Charakter != ';') && (count++ < NAMLEN))
  866.  {
  867.    *buffer++ = Charakter;
  868.    GetChar ();
  869.  }
  870.  *buffer = '\0';
  871. }
  872.  
  873. void GetZahl (char *buffer)
  874. {
  875. int count = 0;
  876.    Steuer=ZIFFER;
  877.   while (((Charakter == '.') || isdigit (Charakter)) &&
  878.            (count++ < NAMLEN))
  879.   {
  880.     if (Charakter == '.') Steuer = FLONUM;
  881.     *buffer++ = Charakter;
  882.      GetChar ();
  883.   }
  884.      *buffer = '\0';
  885. }
  886.  
  887. void GetString (char *buffer)
  888. {
  889. int count = 0;
  890.  
  891.   GetChar ();
  892.  
  893.   while ( (Charakter != '"') &&
  894.             (count++ < ZEILENLAENGE))
  895.   {
  896.     *buffer++ = Charakter;
  897.     GetChar ();
  898.     *buffer = '\0';
  899.     if (Charakter == EOLFEHLER) {
  900.       fatal_error ("Stringende lΣ▀t sich nicht finden!");
  901.       break;
  902.     }
  903.   }
  904.   GetChar ();
  905. }
  906.  
  907. void GetGeklammert (char *buffer)
  908. {
  909. int count = 0;
  910. int nextkl;
  911.     nextkl=1;
  912. while ((nextkl) && (count++ < 200))
  913.   {
  914.     *buffer++ = Charakter;
  915.     GetChar ();
  916.     if(Charakter == '(') nextkl++;
  917.      if(Charakter == ')') nextkl--;
  918.       if (Charakter == EOLFEHLER)
  919.           fatal_error ("Rechte Klammer nicht gefunden! ");
  920.  
  921.   }
  922.   *buffer++ = Charakter;
  923.   *buffer = '\0';
  924.   GetChar ();
  925. }
  926.  
  927. void
  928. NoSkipChar ()
  929. {
  930.   NeedNext = FALSE;
  931. }
  932.  
  933. void
  934. SkipChar ()
  935. {
  936.   NeedNext = TRUE;
  937. }
  938.  
  939. int cset(void)
  940. {
  941. VAR             Variable;
  942.  
  943.           Scan ();
  944.           if (Steuer == ALPHA) {
  945.             strcpy (Variable.VarName,ScanBuffer);
  946.             Scan ();
  947.             if ((Steuer == SONDER) && (*ScanBuffer == '=')) {
  948.                     SetVar (&Variable,VARIABLE);
  949.             }
  950.             else
  951.               serror ("# Zuweisung erwartet! #");
  952.           }
  953.           else
  954.             serror ("# Variablenname erwartet! #");
  955.  
  956. return (OK);
  957. }
  958.  
  959. int cwtitle()
  960. {
  961.            Scan();
  962.           if (Steuer == STRING)
  963.                  SetWindowText(hWndglob,ScanBuffer);
  964.                  else
  965.                     SetWindowText(hWndglob,szMessage);
  966.              return (OK);
  967. }
  968.  
  969. int KlammerTok()
  970. {
  971. int Error,cnt,vcnt;
  972.        cnt=vcnt=0;
  973.        Error = Scan();
  974.  
  975.        if((Steuer == SONDER) && (*ScanBuffer == '?'))
  976.              return (63);
  977.        if((Steuer == SONDER) && (*ScanBuffer == '('))
  978.           {
  979.            do
  980.            {
  981.              SkipChar();
  982.              Error = Scan();
  983.  
  984.               if((Steuer == SONDER) && (*ScanBuffer == ')')) break;
  985.  
  986.              switch(Steuer)
  987.               {
  988.                case ALPHA:
  989.                  break;
  990.                case TRENNER:
  991.                  break;
  992.                case ZIFFER:
  993.                  break;
  994.                case EOLCHAR:
  995.                default:
  996.                  Error = UNEOL;
  997.                  break;
  998.               }
  999.        if(Steuer==ZIFFER || Steuer==ALPHA)
  1000.            {
  1001.               vcnt++;
  1002.              switch(vcnt)
  1003.              {
  1004.               case 1: if(Steuer ==  ALPHA) XW1 = ReadInt(ScanBuffer);
  1005.                            else
  1006.                                XW1 = atoi(ScanBuffer);
  1007.                         /* Hier könnte ^ jeweils auch LinePos=ScanBuffer an
  1008.                            CalcExpression() und somit Formeln als Parameter
  1009.                            übergeben werden.
  1010.                            z.B. bei ellipse (x*pi+4,etc......);
  1011.                         */
  1012.                         break;
  1013.               case 2: if(Steuer ==  ALPHA) YW1 = ReadInt(ScanBuffer);
  1014.                            else
  1015.                                YW1 = atoi(ScanBuffer);
  1016.                         break;
  1017.               case 3: if(Steuer ==  ALPHA) XW2 = ReadInt(ScanBuffer);
  1018.                            else
  1019.                                XW2 = atoi(ScanBuffer);
  1020.                         break;
  1021.               case 4: if(Steuer ==  ALPHA) YW2 = ReadInt(ScanBuffer);
  1022.                            else
  1023.                                YW2 = atoi(ScanBuffer);
  1024.                         break;
  1025.               case 5: if(Steuer ==  ALPHA) XW3 = ReadInt(ScanBuffer);
  1026.                            else
  1027.                                XW3 = atoi(ScanBuffer);
  1028.                         break;
  1029.               case 6: if(Steuer ==  ALPHA) YW3 = ReadInt(ScanBuffer);
  1030.                            else
  1031.                                YW3 = atoi(ScanBuffer);
  1032.                         break;
  1033.               case 7: if(Steuer ==  ALPHA) XW4 = ReadInt(ScanBuffer);
  1034.                            else
  1035.                                XW4 = atoi(ScanBuffer);
  1036.                         break;
  1037.               case 8: if(Steuer ==  ALPHA) YW4 = ReadInt(ScanBuffer);
  1038.                            else
  1039.                                YW4 = atoi(ScanBuffer);
  1040.                         break;
  1041.               case 9: if(Steuer ==  ALPHA) TOutP = ReadInt(ScanBuffer);
  1042.                            else
  1043.                                TOutP = atoi(ScanBuffer);
  1044.                         break;
  1045.               case 10: if(Steuer ==  ALPHA) TCliP = ReadInt(ScanBuffer);
  1046.                            else
  1047.                                TCliP = atoi(ScanBuffer);
  1048.                         break;
  1049.               case 11: if(Steuer ==  ALPHA) TQual = ReadInt(ScanBuffer);
  1050.                            else
  1051.                                TQual = atoi(ScanBuffer);
  1052.                         break;
  1053.               case 12: if(Steuer ==  ALPHA) oem  = ReadInt(ScanBuffer);
  1054.                            else
  1055.                                oem  = atoi(ScanBuffer);
  1056.                                (oem != 0 ? (oem == 2 ? 2 : 255) : 0);
  1057.                         break;
  1058.               case 13: if(Steuer ==  ALPHA) TESCP = ReadInt(ScanBuffer);
  1059.                            else
  1060.                                TESCP = atoi(ScanBuffer);
  1061.                         break;
  1062.               case 14: if(Steuer ==  ALPHA) TORIENT  = ReadInt(ScanBuffer);
  1063.                            else
  1064.                                TORIENT  = atoi(ScanBuffer);
  1065.                         break;
  1066.              }
  1067.            }
  1068.            } while(Error != UNEOL);
  1069.  
  1070.           }
  1071.  
  1072.      return (IntError ? FALSE : vcnt);
  1073. }
  1074.  
  1075. void Paramtozeichne(int was,int hole)
  1076. {
  1077.                     if(KlammerTok()==hole)
  1078.                           Zeichne(was); else
  1079.                            fatal_error ("# PARAMETER-ERROR #");
  1080. }
  1081.  
  1082.  
  1083. HDC GetPrinterDC()
  1084. {
  1085. char szPrinter[64];
  1086. char *szDevice,*szDriver,*szOutput;
  1087.      GetProfileString("windows","device","",szPrinter,64);
  1088.    if((szDevice = strtok(szPrinter,",")) &&
  1089.       (szDriver = strtok(NULL,     ", ")) &&
  1090.       (szOutput = strtok(NULL,     ", ")))
  1091.    return CreateDC(szDriver,szDevice,szOutput,NULL);
  1092.  return 0;
  1093. }
  1094.  
  1095. int csetprint()
  1096. {
  1097.  if((hPrnDC=GetPrinterDC())==NULL)
  1098.      {
  1099.        serror("# DRUCKER-INIT-ERROR #");
  1100.        return(ERROR);
  1101.      }
  1102.  
  1103.   if(Escape(hPrnDC,STARTDOC,sizeof szMessage - 1,szMessage,NULL) > 0)
  1104.        Drucker=TRUE;
  1105.      else
  1106.      {
  1107.        serror("# DRUCKER-OUTPUT-ERROR #");
  1108.        return(ERROR);
  1109.      }
  1110.  return(OK);
  1111. }
  1112.  
  1113. int cscreen()
  1114. {
  1115.  if(Drucker)
  1116.     {
  1117.     if(Escape(hPrnDC,NEWFRAME,0,NULL,NULL) > 0)
  1118.        Escape(hPrnDC,ENDDOC,0,NULL,NULL);
  1119.       DeleteDC(hPrnDC);
  1120.       Drucker=FALSE;
  1121.     }
  1122. }
  1123.  
  1124. void makefont()
  1125. {
  1126. int Art,TFamily;
  1127.            Art = (TXW1 >= 0 && TXW1 < 8) ? TXW1 : 0;
  1128.            mF.lfHeight = TXW2;
  1129.            mF.lfWidth  = TYW1;
  1130.            mF.lfEscapement = TESCP;
  1131.            mF.lfOrientation = TORIENT;
  1132.            mF.lfWeight = TYW2;
  1133.            mF.lfItalic = TXW4;
  1134.            mF.lfUnderline = TXW3;
  1135.            mF.lfStrikeOut = TYW3;
  1136.            mF.lfCharSet = oem;
  1137.            switch(TQual)
  1138.             {
  1139.             default:
  1140.              case 0:  mF.lfQuality = DEFAULT_QUALITY; break;
  1141.              case 1:  mF.lfQuality = DRAFT_QUALITY;   break;
  1142.              case 2:  mF.lfQuality = PROOF_QUALITY;   break;
  1143.             }
  1144.            switch(TOutP)
  1145.             {
  1146.             default:
  1147.              case 0: mF.lfOutPrecision = OUT_DEFAULT_PRECIS;   break;
  1148.              case 1: mF.lfOutPrecision = OUT_CHARACTER_PRECIS; break;
  1149.              case 2: mF.lfOutPrecision = OUT_STRING_PRECIS;    break;
  1150.              case 3: mF.lfOutPrecision = OUT_STROKE_PRECIS;    break;
  1151.             }
  1152.            switch(TCliP)
  1153.             {
  1154.             default:
  1155.              case 0: mF.lfClipPrecision = CLIP_DEFAULT_PRECIS;   break;
  1156.              case 1: mF.lfClipPrecision = CLIP_CHARACTER_PRECIS; break;
  1157.              case 2: mF.lfClipPrecision = CLIP_STROKE_PRECIS;    break;
  1158.             }
  1159.  
  1160.            TFamily=TFam / 10;
  1161.  
  1162.            switch(TFamily)
  1163.             {
  1164.             default:
  1165.              case 1: mF.lfPitchAndFamily = DEFAULT_PITCH;  break;
  1166.              case 2: mF.lfPitchAndFamily = FIXED_PITCH;     break;
  1167.              case 3: mF.lfPitchAndFamily = VARIABLE_PITCH;  break;
  1168.             }
  1169.  
  1170.            TFamily=TFam % 10;
  1171.  
  1172.            switch(TFamily)
  1173.             {
  1174.             default:
  1175.              case 0: mF.lfPitchAndFamily |= FF_DONTCARE;   break;
  1176.              case 1: mF.lfPitchAndFamily |= FF_DECORATIVE; break;
  1177.              case 2: mF.lfPitchAndFamily |= FF_MODERN;     break;
  1178.              case 3: mF.lfPitchAndFamily |= FF_ROMAN;      break;
  1179.              case 4: mF.lfPitchAndFamily |= FF_SCRIPT;     break;
  1180.              case 5: mF.lfPitchAndFamily |= FF_SWISS;      break;
  1181.             }
  1182.             strcpy(mF.lfFaceName,MFONT[Art]);
  1183.            FontChange=TRUE;
  1184. }
  1185.  
  1186. int ctexttype()
  1187. {
  1188. int Menge;
  1189.     Menge=KlammerTok();
  1190.     if (Menge==63)
  1191.       {
  1192.   PRINTF("Anzahl der Parameter 1 - 14  m÷glich <!!Vorsicht!!> bei P. 13-14");
  1193.   PRINTF("(Art,Hch,Br,Fat,U.st,D.gst,Kurs,Fam,OutP,Clip,Qual,OEM,ESC,ORIENT)");
  1194.        return(OK);
  1195.       } else
  1196.  
  1197.     if(Menge > 0 && Menge < 15)
  1198.           {
  1199.            switch(Menge)
  1200.            {
  1201.               case 14:
  1202.               case 13:
  1203.               case 12: TFam=YW4;
  1204.               case 11:
  1205.               case 10:
  1206.               case 9 :
  1207.               case 8 :
  1208.               case 7 : TXW4=XW4;
  1209.               case 6 : TYW3=YW3;
  1210.               case 5 : TXW3=XW3;
  1211.               case 4 : TYW2=YW2;
  1212.               case 3 : TXW2=XW2;
  1213.               case 2 : TYW1=YW1;
  1214.               case 1 : TXW1=XW1;
  1215.               default:
  1216.                          break;
  1217.            }
  1218.             makefont();
  1219.           }
  1220.           else
  1221.              {
  1222.               FontChange=FALSE;
  1223.               TextCol = -1;
  1224.               Backgrd = 15;
  1225.               if(bCaret)
  1226.                  {
  1227.                      DestroyCaret();
  1228.                      bCaret = FALSE;
  1229.                  }
  1230.              }
  1231.     return(OK);
  1232. }
  1233. int clocate()
  1234. {
  1235.      if(KlammerTok()== 2)
  1236.       {
  1237.           x=XW1;
  1238.           Zeile=YW1;
  1239.           locate=TRUE;
  1240.       }
  1241.      return(OK);
  1242. }
  1243.  
  1244. int cllist()
  1245. {
  1246.   /* Programm darf nicht länger sein als Druckerseite
  1247.      Ergänzung in Funktion TEXTZEILE(...)  if(Drucker && Zeile >= YPage)
  1248.      dann neue Seite.....            YPage=GetDeviceCaps(hPrnDC,VERTRES)
  1249.   */
  1250.   csetprint();
  1251.   clist();
  1252.   cscreen();
  1253. }
  1254. int ctextcol()
  1255. {
  1256.   TextCol= (KlammerTok()==1) ? XW1 : -1;
  1257.   return (OK);
  1258. }
  1259. int cpencolor()
  1260. {
  1261.   Pen = (KlammerTok()==1) ? XW1 : 0;
  1262.   return (OK);
  1263. }
  1264.  
  1265. int ccolor()
  1266. {
  1267.   Brush= (KlammerTok()==1) ? XW1 : 0;
  1268.   return (OK);
  1269. }
  1270.  
  1271. int cbackgrd()
  1272. {
  1273.   Backgrd= (KlammerTok()==1) ? XW1 : 15;
  1274.   return (OK);
  1275. }
  1276.  
  1277. int cviereck()
  1278. {
  1279.      Paramtozeichne(9,8);
  1280.      return(OK);
  1281. }
  1282.  
  1283. int crectline()
  1284. {
  1285.      Paramtozeichne(10,4);
  1286.      return(OK);
  1287. }
  1288.  
  1289.  
  1290.  
  1291. int crectangle()
  1292. {
  1293.      Paramtozeichne(1,4);
  1294.      return(OK);
  1295. }
  1296.  
  1297. int croundrect()
  1298. {
  1299.      Paramtozeichne(3,6);
  1300.      return(OK);
  1301. }
  1302.  
  1303. int cellipse()
  1304. {
  1305.      Paramtozeichne(2,4);
  1306.      return(OK);
  1307. }
  1308.  
  1309. int cpie()
  1310. {
  1311.      Paramtozeichne(6,8);
  1312.      return(OK);
  1313. }
  1314.  
  1315. int carc()
  1316. {
  1317.      Paramtozeichne(4,8);
  1318.      return(OK);
  1319. }
  1320.  
  1321. int cpolyline()
  1322. {
  1323.      Paramtozeichne(7,8);
  1324.      return(OK);
  1325. }
  1326.  
  1327. int clineto()
  1328. {
  1329.      Paramtozeichne(0,4);
  1330.      return(OK);
  1331. }
  1332. int cflodfil()
  1333. {
  1334.      Paramtozeichne(8,3);
  1335.      return(OK);
  1336. }
  1337. int csetpxl()
  1338. {
  1339.      Paramtozeichne(5,3);
  1340.      return(OK);
  1341. }
  1342.  
  1343.  
  1344. int cmove()
  1345. {
  1346.      if(KlammerTok()== 4)
  1347.                      MoveWindow(hWndglob,XW1,YW1,XW2,YW2,TRUE);
  1348.                else
  1349.           MoveWindow(hWndglob,wX,wY,wW,wH,TRUE);
  1350.      return(OK);
  1351. }
  1352.  
  1353. int cinput()
  1354. {
  1355. VAR             Variable;
  1356.  
  1357.     Scan();
  1358.           if (Steuer == STRING)
  1359.              {
  1360.                sprintf (Questr,"%s",ScanBuffer);
  1361.                Scan();
  1362.              } else strcpy(Questr," Zahl eingeben :");
  1363.  
  1364.              if (Steuer == ALPHA)
  1365.                  {
  1366.                       strcpy (Variable.VarName,ScanBuffer);
  1367.                       lpProcTextBox = MakeProcInstance(Input, hInst);
  1368.                       DialogBox(hInst,"TextBox",hWndglob,lpProcTextBox);
  1369.                       FreeProcInstance(lpProcTextBox);
  1370.                       Variable.VarType = FLONUM;
  1371.                       SetVar(&Variable,INPUT);
  1372.                       SetCursor(LoadCursor(NULL,IDC_WAIT));
  1373.                       return (OK);
  1374.                  } else
  1375.                  {
  1376.  
  1377.                     PRINTF ("# Variablen-Name ? #");
  1378.                     return (FALSE);
  1379.                  }
  1380. }
  1381.  
  1382. int cinline()
  1383. {
  1384. VAR             Variable;
  1385.  
  1386.     Scan();
  1387.           if (Steuer == STRING)
  1388.              {
  1389.                sprintf (Questr,"%s",ScanBuffer);
  1390.                Scan();
  1391.              }  else strcpy(Questr," Text eingeben :");
  1392.  
  1393.              if (Steuer == ALPHA)
  1394.                  {
  1395.                       strcpy (Variable.VarName,ScanBuffer);
  1396.                       lpProcTextBox = MakeProcInstance(Input, hInst);
  1397.                       DialogBox(hInst,"TextBox",hWndglob,lpProcTextBox);
  1398.                       FreeProcInstance(lpProcTextBox);
  1399.                       Variable.VarType = STRING;
  1400.                       SetVar(&Variable,INLINE);
  1401.                       SetCursor(LoadCursor(NULL,IDC_WAIT));
  1402.                       return (OK);
  1403.                  } else
  1404.                  {
  1405.  
  1406.                     PRINTF ("# Variablen-Name ? #");
  1407.                     return (FALSE);
  1408.                  }
  1409. }
  1410. int ccursor(void)
  1411. {
  1412.            Scan();
  1413.               if(strcmp(ScanBuffer,"off") == 0)
  1414.                     HideCaret(hWndglob);
  1415.                      else
  1416.                       if(strcmp(ScanBuffer,"on") == 0)
  1417.                          ShowCaret(hWndglob);
  1418. }
  1419. int cdruck(void)
  1420. {
  1421. char *such;
  1422. int Error;
  1423.            memset(PrintBuf,'\0',ZEILENLAENGE-1);
  1424.            Mehr=(strchr(LinePos,',')) ? TRUE : FALSE;
  1425.            Scan();
  1426.  
  1427.            if(Steuer != EOLCHAR)
  1428.             {
  1429.            do {
  1430.             switch (Steuer) {
  1431.               case        EOLCHAR:
  1432.                 Mehr=FALSE;
  1433.                  break;
  1434.               case        STRING:
  1435.                 if(!Mehr || !PrintBuf[0])
  1436.                         sprintf (PrintBuf,"%s",ScanBuffer);
  1437.                      else strcat(PrintBuf,ScanBuffer);
  1438.                  break;
  1439.               case        ZIFFER:
  1440.                 if(!Mehr || !PrintBuf[0])
  1441.                         sprintf (PrintBuf,"%s",ScanBuffer);
  1442.                      else strcat(PrintBuf,ScanBuffer);
  1443.                  break;
  1444.               case        ALPHA:
  1445.                 PrintVar (ScanBuffer);
  1446.                  break;
  1447.               case        TRENNER:
  1448.                Mehr= TRUE;
  1449.               break;
  1450.               case        SONDER:
  1451.                if(*ScanBuffer == '(')
  1452.                 {
  1453.                      GetGeklammert (Questr);
  1454.                        if(IntError) return ERROR_1;
  1455.                      such=LinePos;
  1456.                      LinePos=Questr;
  1457.                     if (CalcExpression (&Variable) == ERROR_1)
  1458.                        {
  1459.                          serror ("# CalcExpr. Fehler! #");
  1460.                          return (OK);
  1461.                        }
  1462.                     sprintf(IntegerZahl,"%-18.6f",
  1463.                                 Variable.VarWert.variable.Flotype);
  1464.                      Nullenweg();
  1465.                     LinePos=such;
  1466.                 if(!Mehr || !PrintBuf[0])
  1467.                     strcpy (PrintBuf,IntegerZahl);
  1468.                      else strcat(PrintBuf,IntegerZahl);
  1469.  
  1470.                 }
  1471.               break;
  1472.               default :
  1473.                          serror ("# Nicht druckbarer Ausdruck! #");
  1474.                  return (OK);
  1475.               break;
  1476.             }
  1477.                 Error=Scan();
  1478.  
  1479.               } while (Error != UNEOL && Steuer != EOLCHAR);
  1480.                 PRINTF(PrintBuf);
  1481.             }
  1482.                  return (OK);
  1483. }
  1484. int messagebox()
  1485. {
  1486.   PrMsgBox=TRUE;
  1487.   return cdruck();
  1488. }
  1489.  
  1490. int cgoto(void)
  1491. {
  1492. int     error,LineNumber;
  1493.  
  1494.           Scan ();
  1495.           if ((Steuer == ZIFFER) && FirstLine)    {
  1496.             LineNumber = atoi (ScanBuffer);
  1497.             if (FindInsPos (LineNumber,&ActLine)) {
  1498.               ActLine = ActLine->PrevZeile;
  1499.               GetNextLine = FALSE;
  1500.               return (OK);
  1501.             }
  1502.             else {
  1503.  
  1504.                  PRINTF ("# Sprungziel nicht gefunden! #");
  1505.               return (FALSE);
  1506.             }
  1507.           }
  1508.           else
  1509.             {
  1510.  
  1511.             PRINTF ("# Kein Programm im Speicher! #");
  1512.             }
  1513. return (OK);
  1514. }
  1515.  
  1516. int cwhile()
  1517. {
  1518.  int i;
  1519.    if(ActLine->NextZeile!=NULL)
  1520.        forcalc[ForCnt].Goto = ActLine->NextZeile;
  1521.      else
  1522.            {
  1523.             serror("# WHILE without WEND #");
  1524.             return(ERROR_1);
  1525.            }
  1526.  
  1527.     if((forcalc[ForCnt].whilestr = (char NEAR *)LocalAlloc (LPTR,81*sizeof(char)))==NULL)
  1528.            {
  1529.             serror("# kein Speicher mehr #");
  1530.             return(ERROR_1);
  1531.            } else i=0;
  1532.  
  1533.      while((forcalc[ForCnt].whilestr[i]=LinePos[i]) && i < 81) i++;
  1534.  
  1535.      if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1536.            else i=1;
  1537.  
  1538.      if (Variable.VarWert.variable.Flotype <= 0.0)
  1539.             do
  1540.                switch(ActLine->NextZeile->Zeile[0])
  1541.                 {
  1542.                     case (char)TOKWHILE: i++; break;
  1543.                     case (char)TOKWEND:  i--; break;
  1544.                 }
  1545.             while((ActLine=ActLine->NextZeile)!=NULL && i);
  1546.  
  1547.            if(ForCnt < 11)
  1548.               ForCnt++;
  1549.                 else serror ("# too many while while.... #");
  1550.  return (OK);
  1551. }
  1552.  
  1553. int cwend()
  1554. {
  1555. PRGZEILE *NEXT;
  1556.  
  1557. if(ForCnt && forcalc[ForCnt-1].whilestr != NULL)
  1558.    {
  1559.      NEXT= ActLine;
  1560.      GetNextLine = FALSE;
  1561.      LinePos=forcalc[ForCnt-1].whilestr;
  1562.      if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1563.  
  1564.     if(Variable.VarWert.variable.Flotype > 0.0)
  1565.      ActLine = forcalc[ForCnt-1].Goto;
  1566.     else
  1567.      {
  1568.       if(ForCnt)ForCnt--;
  1569.       LocalFree ((LOCALHANDLE)(forcalc[ForCnt].whilestr));
  1570.       ActLine = NEXT->NextZeile;
  1571.      }
  1572.    } else serror ("# WEND WITHOUT WHILE #");
  1573. return (OK);
  1574. }
  1575.  
  1576. int cfor()
  1577. {
  1578. int error;
  1579. unsigned char *Nuntius;
  1580. BOOL STEP;
  1581.    STEP = FALSE;
  1582.    PrintBuf[0]='\0';
  1583.    if(ActLine->NextZeile!=NULL)
  1584.        forcalc[ForCnt].Goto = ActLine->NextZeile;
  1585.      else
  1586.            {
  1587.             serror("# FOR without NEXT #");
  1588.             return(ERROR_1);
  1589.            }
  1590.    Scan();
  1591.     if(Steuer != ALPHA)
  1592.       {
  1593.        serror ("# for ? #");
  1594.        return(ERROR_1);
  1595.       }
  1596.       strcpy (Variable.VarName,ScanBuffer);
  1597.       Scan();
  1598.     if(Steuer != SONDER && (*ScanBuffer != '='))
  1599.      {
  1600.       serror ("# Zuweisung ? #");
  1601.       return(ERROR_1);
  1602.      }
  1603.       Scan();
  1604.    do
  1605.     {
  1606.       strcat(PrintBuf,ScanBuffer);
  1607.       error = Scan();
  1608.     } while(strcmp(ScanBuffer,"downto") != 0 &&
  1609.               strcmp(ScanBuffer,"to") != 0 && error !=UNEOL);
  1610.  
  1611.    if(strcmp("to",ScanBuffer) != 0)
  1612.        {
  1613.           if( strcmp(ScanBuffer,"downto") != 0)
  1614.             {
  1615.               serror ("# TO expect #");
  1616.               return(ERROR_1);
  1617.             }
  1618.        }
  1619.       if(strcmp(ScanBuffer,"downto") == 0)
  1620.                forcalc[ForCnt].step = -1.0;
  1621.             else
  1622.                 forcalc[ForCnt].step = 1.0;
  1623.       Nuntius=LinePos;
  1624.       LinePos = PrintBuf;
  1625.       SetVar (&Variable,FORNEXT);
  1626.       memset(PrintBuf,'\0',ZEILENLAENGE-1);
  1627.       LinePos=Nuntius;
  1628.       Scan();
  1629.       Scan();
  1630.   while(strcmp(ScanBuffer,"step") != 0 && error !=UNEOL)
  1631.    {
  1632.      strcat(PrintBuf,ScanBuffer);
  1633.      error = Scan();
  1634.      if(strcmp("step",ScanBuffer) == 0) STEP =TRUE;
  1635.    }
  1636.       Nuntius=LinePos;
  1637.       LinePos = PrintBuf;
  1638.    if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1639.        forcalc[ForCnt].toY = Variable.VarWert.variable.Flotype;
  1640.  
  1641.      if(STEP)
  1642.        {
  1643.            LinePos=Nuntius;
  1644.            if (CalcExpression (&Variable) == ERROR_1) return (ERROR_1);
  1645.              forcalc[ForCnt].step = Variable.VarWert.variable.Flotype;
  1646.        }
  1647.  
  1648.            if(ForCnt < 11)
  1649.               ForCnt++;
  1650.                 else serror ("# too many FOR FOR.... #");
  1651.  
  1652.  return (OK);
  1653. }
  1654.  
  1655. int cnext()
  1656. {
  1657. VAR *Variable;
  1658. PRGZEILE *NEXT;
  1659.  
  1660.  if(forcalc[ForCnt-1].forX != NULL)
  1661.      {
  1662.      NEXT= ActLine;
  1663.      GetNextLine = FALSE;
  1664.      Variable = forcalc[ForCnt-1].forX;
  1665.  
  1666.  if((forcalc[ForCnt-1].step > 0.0 &&
  1667.             Variable->VarWert.variable.Flotype < forcalc[ForCnt-1].toY) ||
  1668.     (forcalc[ForCnt-1].step < 0.0 &&
  1669.             Variable->VarWert.variable.Flotype > forcalc[ForCnt-1].toY))
  1670.        {
  1671.            Variable->VarWert.variable.Flotype += forcalc[ForCnt-1].step;
  1672.             ActLine = forcalc[ForCnt-1].Goto;
  1673.        } else
  1674.            {
  1675.              if(ForCnt) ForCnt--;
  1676.              ActLine = NEXT->NextZeile;
  1677.            }
  1678.      } else serror ("# NEXT WITHOUT FOR #");
  1679.   return (OK);
  1680. }
  1681.  
  1682. int cif()
  1683. {
  1684. int     result = OK;
  1685.           if (CmpVar ()) {
  1686.             ActLine = ActLine->NextZeile;
  1687.             LinePos = ActLine->Zeile;
  1688.             result = InterpLine ();
  1689.             ActLine = ActLine->NextZeile;
  1690.           }
  1691.           else
  1692.             {
  1693.             if (ActLine->NextZeile)
  1694.               ActLine = ActLine->NextZeile;
  1695.             else
  1696.               serror ("# Kein Else-Zweig vorhanden! #");
  1697.             }
  1698. return (result);
  1699. }
  1700.  
  1701. int ccls()
  1702. {
  1703. HDC hDC;
  1704.    HideCaret(hWndglob);
  1705.    Zeile = 0;
  1706.    hDC = GetDC(hWndglob);
  1707.     Rectangle(hDC,rect.left-1,rect.top-1,rect.right+1,rect.bottom+1);
  1708.    ReleaseDC(hWndglob,hDC);
  1709.    ShowCaret(hWndglob);
  1710. return (OK);
  1711. }
  1712.  
  1713. int cbeep()
  1714. {
  1715.  Piep();
  1716.  return OK;
  1717. }
  1718.  
  1719.  
  1720. /* Funktion 'MessageBeep' gehört normalerweise zu Windows
  1721.    , macht aber noch Probleme!  Daher Ersatzfunktion "Piep".
  1722.    Sollte in neueren SDK-Versionen die "MessageBeep()"-
  1723.    Funktion fehlerfrei sein, empfiehlt es sich, sie gegen
  1724.    die "direkte" Piep-Routine auszutauschen!!!!!!!!!!!    */
  1725.  
  1726. Piep()
  1727. {
  1728.  _asm
  1729.  {
  1730.    push ax
  1731.    push bx
  1732.    mov al, 182
  1733.    out 43h, al
  1734.  
  1735.    mov ax, 6833  ;beliebiger Tonwert
  1736.    out 42h, al   ;low-Byte an Timer-Counter
  1737.    mov al, ah    ;high-Byte übertragen
  1738.    out 42h, al   ;an Timer-Counter übertragen
  1739.    in al, 61h    ;Lautsprecher-Kontroll-Bit einlesen
  1740.    or al, 11b    ;unteren Bits schalten Zustand ON
  1741.    out 61h, al   ;Lautsprecher einschalten
  1742.    mov bx, 0
  1743.    mov ax, 0
  1744.  
  1745.   warte:
  1746.    inc bl
  1747.    cmp bl, 255h  ;erster Zähler der dreistufigen Warteschleife
  1748.    jne warte
  1749.    
  1750.    sub bl, bl
  1751.    inc bh
  1752.    cmp bh, 255   ;zweiter Zähler
  1753.    jne warte 
  1754.    
  1755.    sub bl, bl
  1756.    sub bh, bh
  1757.    inc al
  1758.    cmp al, 25    ;dritter Zähler
  1759.    jne warte
  1760.    
  1761.    in al, 61h
  1762.    and al,11111100b
  1763.    out 61h, al   ;Lautsprecher ausschalten
  1764.    pop bx
  1765.    pop ax
  1766.  }
  1767. }
  1768.  
  1769. int cplay(void)
  1770. {
  1771.   register int a;
  1772.   long i,ii;
  1773.   if(KlammerTok()== 3)
  1774.    {
  1775.      OpenSound();
  1776.       ii = (long)XW2;
  1777.       ii *= 100;
  1778.       SetVoiceSound(1,MAKELONG(YW1,XW1),32767);
  1779.  
  1780.       StartSound();
  1781.  
  1782.       for (i=0;i < ii;i++)
  1783.             a=i; /* damit's nicht weg - optimiert wird */
  1784.  
  1785.       StopSound();
  1786.  
  1787.      CloseSound();
  1788.    }
  1789.     else
  1790.      fatal_error ("# PARAMETER-ERROR #");
  1791.  
  1792.  return OK;
  1793. }
  1794.  
  1795. int creadclp(void)
  1796. {
  1797.  char VStatus;
  1798.  
  1799.  Scan();
  1800.  if(Steuer==ALPHA && !ScanBuffer[1])
  1801.   {
  1802.      VStatus=ScanBuffer[0];
  1803.      Scan();
  1804.  
  1805.      if(Steuer==TRENNER)
  1806.      Scan();
  1807.  
  1808.      if(Steuer==ALPHA)
  1809.       {
  1810.        Textstr[0] = '\0';
  1811.  
  1812.        readclipbrd(hWndglob,FALSE);
  1813.        if(Textstr[0])
  1814.            {
  1815.             strcpy (Variable.VarName,ScanBuffer);
  1816.  
  1817.            if(VStatus=='S'|| VStatus=='s')
  1818.              {
  1819.               Variable.VarType = STRING;
  1820.               SetVar(&Variable,INLINE);
  1821.              } else
  1822.              {
  1823.               Variable.VarType = FLONUM;
  1824.               SetVar(&Variable,INPUT);
  1825.              }
  1826.            }
  1827.  
  1828.    }
  1829.     else serror("# Variablenname ? #");
  1830.   }
  1831.     else serror("# Variablenstatus ? #");
  1832.  return OK;
  1833. }
  1834.  
  1835. int cwritclp(void)
  1836. {
  1837.  Scan();
  1838.  if(Steuer==ALPHA)
  1839.   {
  1840.    Mehr=FALSE;
  1841.    PrintBuf[0]='\0';
  1842.    PrintVar (ScanBuffer);
  1843.    if(!IntError)
  1844.       writeclipbrd(hWndglob,PrintBuf);
  1845.   } else
  1846.      if(Steuer==STRING)
  1847.       {
  1848.           writeclipbrd(hWndglob,ScanBuffer);
  1849.       }
  1850.    else serror("# Wert ? #");
  1851.  return OK;
  1852. }
  1853.  
  1854. void Spaces(int i)
  1855. {
  1856. int j=0;
  1857.     i--;
  1858.     j = strlen((char *)TokBefDesc[i].Befehl);
  1859.     while(j++ < 14)
  1860.      (j < 2 || j > 13 ? (strcat(Questr," ")):(strcat(Questr,".")));
  1861. }
  1862.  
  1863. int ccommands()
  1864. {
  1865. int i=0;
  1866.  memset(Questr,'\0',ZEILENLAENGE-1);
  1867.   ccls();
  1868.  PRINTF("COMMANDS :");
  1869.    do {
  1870.           if(!(*Questr))
  1871.                strcpy(Questr,(char *)TokBefDesc[i++].Befehl);
  1872.                Spaces(i);
  1873.  
  1874.            while(!Questr[78])
  1875.              {
  1876.                strcat(Questr,(char *)TokBefDesc[i++].Befehl);
  1877.                Spaces(i);
  1878.              }
  1879.            if(Questr[0] > '.')
  1880.              PRINTF(Questr);
  1881.               memset(Questr,'\0',ZEILENLAENGE-1);
  1882.  
  1883.       }
  1884.    while(i < (TOKMAX-TOKMIN-1));
  1885.   PRINTF("Befehl<F1> ? Hilfe ? ");
  1886. return(OK);
  1887. }
  1888.  
  1889. int crunb()
  1890. {
  1891.           if (FirstLine)
  1892.             RUNBREAK=TRUE;
  1893.            else
  1894.               PRINTF ("# Kein Programm im Speicher! #");
  1895.  
  1896. return (OK);
  1897. }
  1898. int crun()
  1899. {
  1900.           if (FirstLine)
  1901.            {
  1902.             ActLine = FirstLine;
  1903.             HideCaret(hWndglob);
  1904.             DoProgram ();
  1905.            }
  1906.            else
  1907.               PRINTF ("# Kein Programm im Speicher! #");
  1908. return (OK);
  1909. }
  1910.  
  1911. int cende ()
  1912. {
  1913.           PRINTF ("+ Normales Programmende +");
  1914. if(RUNBREAK) RUNBREAK=FALSE;
  1915. return (FALSE);
  1916. }
  1917.  
  1918. int  cexit ()
  1919. {
  1920.   if(MessageBox(hWndglob,(LPSTR) "Wollen Sie den Interpreter verlassen ?",
  1921.                                (LPSTR)"* ENDE *",
  1922.                                   MB_OKCANCEL | MB_ICONEXCLAMATION)==IDOK)
  1923.                                     SendMessage(hWndglob,WM_DESTROY,0,0L);
  1924. return (OK);
  1925. }
  1926.  
  1927. int cmerke ()
  1928. {
  1929.  
  1930. return (OK);
  1931. }
  1932.  
  1933. int clist ()
  1934. {
  1935. PRGZEILE        *FindZeile;
  1936. char        *Line;
  1937.           if ((FindZeile = FirstLine) != NULL) {
  1938.  
  1939.                     PRINTF ("******* Aktuelles Programm auflisten: ********");
  1940.                     PRINTF (FileName);
  1941.                     while ( FindZeile) {
  1942.                       ShowLine (FindZeile);
  1943.                       FindZeile = FindZeile->NextZeile;
  1944.                     }
  1945.                     PRINTF ("******* Ende des aktuellen Programms! ********");
  1946.           }
  1947.  
  1948. return (TRUE);
  1949. }
  1950.  
  1951. void Waehlbox()
  1952. {
  1953.  lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);
  1954.  DialogBox(hInst, "Open", hWndglob, lpOpenDlg);
  1955.  FreeProcInstance(lpOpenDlg);
  1956. }
  1957.  
  1958. int cload ()
  1959. {
  1960.           Scan();
  1961.           if (Steuer == STRING)
  1962.            {
  1963.             SetFileName (ScanBuffer);
  1964.             ReadProg ();
  1965.            }
  1966.           else
  1967.            {
  1968.               Waehlbox();
  1969.             if(LoadFile) ReadProg ();
  1970.            }
  1971. return (OK);
  1972. }
  1973.  
  1974.  
  1975. int csave ()
  1976. {
  1977.  
  1978.           Scan();
  1979.           if (Steuer == STRING) {
  1980.             SetFileName (ScanBuffer);
  1981.             WriteProg ();
  1982.           }
  1983.           else
  1984.             serror ("# Kein Filename angegeben! #");
  1985. return (OK);
  1986. }
  1987.  
  1988.  
  1989. int cneu ()
  1990. {
  1991.           ClearVar();
  1992.           ClearProg ();
  1993. return (OK);
  1994. }
  1995.  
  1996. void fatal_error (char *FehlerMeldung)
  1997. {
  1998.           TextCol = -1;
  1999.           PRINTF (FehlerMeldung);
  2000.           IntError = TRUE;
  2001. }
  2002.  
  2003. void serror(char *FehlerMeldung)
  2004. {
  2005.           TextCol = -1;
  2006.           PRINTF (FehlerMeldung);
  2007.           IntError = TRUE;
  2008. }
  2009.  
  2010. void ResetError ()
  2011. {
  2012.   IntError = FALSE;
  2013. }
  2014.  
  2015. int ReadProg ()
  2016. {
  2017. PRGZEILE        NewLine;
  2018. FILE    *FilePointer;
  2019. char    ReadBuffer[255];
  2020. char    ausgabe[30];
  2021. char    *FName;
  2022.  
  2023.           if ((FName = GetFileName()) != NULL) {
  2024.            fio = OpenFile((LPSTR)FName,(LPOFSTRUCT)&fileInfo,OF_READ);
  2025.  
  2026.             if ((FilePointer = fdopen(fio,"rb")) == NULL) {
  2027.                     fatal_error (" Datei konnte nicht ge÷ffnet werden! ");
  2028.                     return (ERROR_1);
  2029.             }
  2030.           }
  2031.           else {
  2032.             fatal_error (" Ungⁿltiger Dateiname! ");
  2033.             return (ERROR_1);
  2034.           }
  2035.            cneu ();
  2036.            strcpy(ausgabe,"Lade Datei : ");
  2037.            strcat(ausgabe,FName);
  2038.            PRINTF (ausgabe);
  2039.  
  2040.           while (ReadFileLine (FilePointer,ReadBuffer)) {
  2041.             if (strlen (ReadBuffer) > 3) {
  2042.                     LinePos = ReadBuffer;
  2043.                     SkipChar ();
  2044.                     Scan ();
  2045.                     if (Steuer == ZIFFER) {
  2046.                       NewLine.LineNumber = atoi (ScanBuffer);
  2047.                       ActLine = 
  2048.                       if (MakeToken () == OK)
  2049.                         InsIntLine ();
  2050.                       else {
  2051.  
  2052.                         PRINTF ("### Ungⁿltiger Befehl gefunden! ###");
  2053.                         return (ERROR_1);
  2054.                       }
  2055.                     }
  2056.                     else {
  2057.                       fatal_error ("Fehler beim Einlesen der Datei! ");
  2058.                       return (FALSE);
  2059.                     }
  2060.             }
  2061.           }
  2062. fclose (FilePointer);
  2063. return (OK);
  2064. }
  2065.  
  2066. int ReadFileLine (FilePointer,BufPointer)
  2067. FILE    *FilePointer;
  2068. char    BufPointer[];
  2069. {
  2070. char    zeichen;
  2071. char    *ReadPointer;
  2072.           ReadPointer = BufPointer;
  2073.  
  2074.           do {
  2075.                     zeichen = *ReadPointer++ = fgetc (FilePointer);
  2076.           }       while ((zeichen != LF)&&(zeichen != '\r') && (zeichen != EOF));
  2077.  
  2078.           *(--ReadPointer) = '\0';
  2079.  
  2080.           if ((zeichen == EOF) && (ReadPointer == BufPointer))
  2081.             return (FALSE);
  2082.           else
  2083.             return (TRUE);
  2084. }
  2085.  
  2086. int WriteProg ()
  2087. {
  2088. PRGZEILE        *FindZeile;
  2089. FILE    *FilePointer;
  2090. char    ausgabe[30];
  2091. char    WriteBuffer[255];
  2092. char    *FName;
  2093. char    *Line;
  2094.  
  2095.           if ((FName = GetFileName()) != NULL) {
  2096.            strcpy(ausgabe,"Save Datei : ");
  2097.             strcat(ausgabe,FName);
  2098.              PRINTF (ausgabe);
  2099.            fio = OpenFile((LPSTR)FName,(LPOFSTRUCT)&fileInfo,OF_CREATE | OF_WRITE );
  2100.  
  2101.             if ((FilePointer = fdopen (fio,"w+b")) == NULL) {
  2102.                     fatal_error (" Datei konnte nicht ge÷ffnet werden! ");
  2103.                     return (ERROR_1);
  2104.             }
  2105.           }
  2106.           else {
  2107.             fatal_error (" Ungⁿltiger Dateiname! ");
  2108.             return (ERROR_1);
  2109.           }
  2110.  
  2111.  
  2112.           if ((FindZeile = FirstLine) != NULL) {
  2113.                     while ( FindZeile) {
  2114.                               Line = FindZeile->Zeile;
  2115.                               if (*Line) {
  2116.                                 sprintf (WriteBuffer,"%03d %s ",
  2117.                                              FindZeile->LineNumber,
  2118.                                                   TokBefDesc[(*Line-TOKMIN)&0xff].Befehl
  2119.                                                   );
  2120.                                  fprintf (FilePointer,"%s",WriteBuffer);
  2121.                                   Line++;
  2122.                                  if (*Line)
  2123.                                     {
  2124.                                      sprintf (WriteBuffer,"%s\r\n",Line);
  2125.                                      fprintf (FilePointer,"%s",WriteBuffer);
  2126.                                     } else if(WriteBuffer[0])
  2127.                                     {
  2128.                                      strcpy(WriteBuffer,"\r\n");
  2129.                                      fprintf (FilePointer,"%s",WriteBuffer);
  2130.                                     }
  2131.  
  2132.                               }
  2133.                               FindZeile = FindZeile->NextZeile;
  2134.                     }
  2135.           }
  2136. fclose(FilePointer);
  2137. return (OK);
  2138. }
  2139.  
  2140.  
  2141. void SetFileName (char  *FName)
  2142. {
  2143.  strcpy (FileName,FName);
  2144. }
  2145.  
  2146. char    *GetFileName ()
  2147. {
  2148.  return (FileName);
  2149. }
  2150.  
  2151. void ShowLine (PRGZEILE *FindZeile)
  2152. {
  2153. char    *Line;
  2154. char Ausgabe[255];
  2155.  
  2156.           Line = FindZeile->Zeile;
  2157.  if (*Line)
  2158.           {
  2159.              sprintf (Ausgabe,"%03d %s ",
  2160.                        FindZeile->LineNumber,
  2161.                        TokBefDesc[(*Line-TOKMIN)&0xff].Befehl);
  2162.              if(*Line != ';') Line++;
  2163.              if (*Line) strcat(Ausgabe,Line);
  2164.              PRINTF (Ausgabe);
  2165.           }
  2166. }
  2167.  
  2168. VAR *IsVariable (char    *Name)
  2169. {
  2170. VAR  *i;
  2171.  
  2172.   for (i = FirstVar;
  2173.        i && (strcmp(Name,i->VarName) != 0);
  2174.        i = i->NextVar);
  2175.  
  2176. return (i);
  2177. }
  2178.  
  2179. int SetVar (VAR *Wert,BOOL Input)
  2180. {
  2181. VAR             *Variable;
  2182. VAR             Value;
  2183.  
  2184.             if(Input == INPUT)
  2185.                {
  2186.                 strcpy(Value.VarName,Wert->VarName);
  2187.                  Value.VarWert.variable.Flotype = atof(Textstr);
  2188.                     Value.VarType = FLONUM;
  2189.                } else
  2190.             if(Input == INLINE)
  2191.                {
  2192.                 strcpy(Value.VarName,Wert->VarName);
  2193.                 strcpy(ScanBuffer,Textstr);
  2194.                 Value.VarType = STRING;
  2195.                }
  2196.                  else if (CalcExpression (&Value) == ERROR_1) return (ERROR_1);
  2197.  
  2198.           if ((Variable = IsVariable (Wert->VarName)) != NULL)
  2199.              {
  2200.  
  2201.              if (Variable->VarType != Value.VarType)
  2202.                {
  2203.                  serror("# falscher Variablentyp #");
  2204.                  return (FALSE);
  2205.                }
  2206.  
  2207.              if (Variable->VarType==STRING)
  2208.                     LocalFree ((LOCALHANDLE)(Variable->VarWert.variable.text));
  2209.               SetValue (&Variable->VarWert,&Value.VarWert,Value.VarType);
  2210.               if(Input == FORNEXT) forcalc[ForCnt].forX = Variable;
  2211.             return (OK);
  2212.           }
  2213.  
  2214.           if (( Variable =(VAR NEAR *) LocalAlloc(LPTR,sizeof(VAR))) == NULL) {
  2215.             PRINTF ("# Kein Speicherplatz mehr fⁿr die Variable! #");
  2216.             return (FALSE);
  2217.           }
  2218.  
  2219.           strcpy (Variable->VarName,Wert->VarName);
  2220.           Variable->VarType = Value.VarType;
  2221.           SetValue (&Variable->VarWert,&Value.VarWert,Value.VarType);
  2222.           Variable->NextVar = FirstVar;
  2223.           FirstVar = Variable;
  2224.           if(Input == FORNEXT) forcalc[ForCnt].forX = FirstVar;
  2225. return (OK);
  2226. }
  2227.  
  2228. void SetValue (NewVar,Wert,Type)
  2229. VARDEF  *NewVar,*Wert;
  2230. unsigned char   Type;
  2231. {
  2232.  
  2233.           switch (Type) {
  2234.             case  ZIFFER:
  2235.               NewVar->variable.integer = Wert->variable.integer;
  2236.             break;
  2237.             case  FLONUM:
  2238.               NewVar->variable.Flotype = Wert->variable.Flotype;
  2239.             break;
  2240.             case  ALPHA:
  2241.               NewVar->variable.zeichen = Wert->variable.zeichen;
  2242.             break;
  2243.             case  STRING:
  2244.             NewVar->variable.text = (unsigned char NEAR *)LocalAlloc (LPTR,
  2245.                                                (strlen(ScanBuffer)+1)*sizeof(char));
  2246.           if (NewVar->variable.text== NULL)
  2247.                serror ("#### Kein Speicherplatz mehr vorhanden! ####");
  2248.              else
  2249.                strcpy(NewVar->variable.text,ScanBuffer);
  2250.             break;
  2251.             default:
  2252.                 serror ("# Variablenzuweisung fⁿr diesen Typ nicht implementiert! #");
  2253.             break;
  2254.           }
  2255.  
  2256. }
  2257. int MsgBox(char *Questr)
  2258. {
  2259. WORD Options;
  2260.                     Options=0x0000;
  2261.                     if(Questr[0] == '*') Options |= MB_ICONASTERISK;
  2262.                      else
  2263.                     if(Questr[0] == 'H') Options |= MB_ICONHAND;
  2264.                      else
  2265.                     if(Questr[0] == '?') Options |= MB_ICONQUESTION;
  2266.                      else
  2267.                     if(Questr[0] == '!') Options |= MB_ICONEXCLAMATION;
  2268.                      Questr[0] = ' ';
  2269.                     if(Questr[1] == 'Y') Options |= MB_YESNO;
  2270.                      else
  2271.                     if(Questr[1] == 'C') Options |= MB_OKCANCEL;
  2272.                      else
  2273.                     if(Questr[1] == 'R') Options |= MB_RETRYCANCEL;
  2274.                      Questr[1] = ' ';
  2275.  return (MessageBox(hWndglob,(LPSTR) Questr,(LPSTR) "* ACHTUNG *",Options));
  2276. }
  2277.  
  2278. int CmpVar ()
  2279. {
  2280. unsigned char *Nuntius;
  2281.           Nuntius=LinePos;
  2282.           Scan ();
  2283.           if (Steuer == STRING)
  2284.              {
  2285.                 what = MsgBox(ScanBuffer);
  2286.               if (what==IDYES || what==IDOK) return TRUE;
  2287.                 else return FALSE;
  2288.              }
  2289.           LinePos=Nuntius;
  2290.       if (CalcExpression (&Variable) == ERROR_1) serror ("# if Fehler #");;
  2291.            if (Variable.VarWert.variable.Flotype <= 0.0)
  2292.                     return FALSE;
  2293.                        else return TRUE;
  2294.  
  2295. }
  2296.  
  2297. void Nullenweg()
  2298. {
  2299. int ncnt;
  2300.  
  2301.               ncnt=19;
  2302.               while(IntegerZahl[ncnt--]!= '.')
  2303.                      {
  2304.                      if(IntegerZahl[ncnt]> '0') break;
  2305.                         if(IntegerZahl[ncnt]=='.')
  2306.                                {
  2307.                                 IntegerZahl[ncnt]=' ';
  2308.                                 break;
  2309.                                }
  2310.                         if(IntegerZahl[ncnt]=='0')
  2311.                                IntegerZahl[ncnt]=' ';
  2312.                      }
  2313.                      IntegerZahl[ncnt+1]='\0';
  2314. }
  2315.  
  2316. void PrintVar (char *Name)
  2317. {
  2318. VAR             *Variable;
  2319.           if ((Variable = IsVariable (Name)) != NULL) {
  2320.             switch (Variable->VarType) {
  2321.               case        ZIFFER:
  2322.               sprintf(IntegerZahl,"%-10i",Variable->VarWert.variable.integer);
  2323.                 if(!Mehr || !PrintBuf[0]) sprintf (PrintBuf,"%10s",IntegerZahl);
  2324.                      else strcat(PrintBuf,IntegerZahl);
  2325.               break;
  2326.  
  2327.               case        FLONUM:
  2328.               sprintf(IntegerZahl,"%-18.6f",
  2329.                           Variable->VarWert.variable.Flotype);
  2330.                 Nullenweg();
  2331.                 if(!Mehr || !PrintBuf[0]) sprintf (PrintBuf,"%s",IntegerZahl);
  2332.                      else strcat(PrintBuf,IntegerZahl);
  2333.               break;
  2334.               case        STRING:
  2335.                 if(!Mehr || !PrintBuf[0])
  2336.                     strcpy (PrintBuf,Variable->VarWert.variable.text);
  2337.                      else strcat(PrintBuf,Variable->VarWert.variable.text);
  2338.               break;
  2339.               default:
  2340.  
  2341.                 PRINTF ("# Variablen dieses Typs k÷nnen nicht gedruckt werden! #");
  2342.               break;
  2343.             }
  2344.           }
  2345.           else {
  2346.             char buffer[40];
  2347.             sprintf (buffer,"# Variable <%s> unbekannt! #",Name);
  2348.             fatal_error (buffer);
  2349.           }
  2350. }
  2351. int ReadInt (char *Name)
  2352. {
  2353. int wert;
  2354. VAR             *Variable;
  2355.     if ((Variable = IsVariable (Name)) != NULL)
  2356.            {
  2357.             switch (Variable->VarType)
  2358.             {
  2359.               case        ZIFFER:
  2360.               wert=Variable->VarWert.variable.integer;
  2361.               break;
  2362.  
  2363.               case        FLONUM:
  2364.               wert=(int)Variable->VarWert.variable.Flotype;
  2365.               break;
  2366.               case        STRING:
  2367.               break;
  2368.               default:
  2369.  
  2370.                 PRINTF ("# Variablen dieses Typs k÷nnen nicht gedruckt werden! #");
  2371.               break;
  2372.             }
  2373.            return wert;
  2374.            }
  2375.           else {
  2376.             char buffer[40];
  2377.             sprintf (buffer,"# Variable <%s> unbekannt! #",Name);
  2378.             fatal_error (buffer);
  2379.             return (FALSE);
  2380.           }
  2381.  
  2382. }
  2383.  
  2384.  
  2385. int CalcExpression (VAR *Result)
  2386. {
  2387. PTNODE FTree;
  2388. unsigned char *Formel;
  2389.  
  2390.    Formel=LinePos;
  2391.    Scan();
  2392.    if(Steuer == EOLCHAR) return (ERROR_1);
  2393.  
  2394.     if(Steuer==STRING)
  2395.       {
  2396.           /* String - Addition/Bearbeitung hier implementieren
  2397.              und in den Scanbuffer schreiben */
  2398.  
  2399.           Result->VarType=STRING;
  2400.           return (OK);
  2401.       }
  2402.  
  2403.      FTree = CreateTree(Formel,&ErrPos,&ErrNr);
  2404.      if(ErrPos != -1)
  2405.           {
  2406.            switch(ErrNr)
  2407.             {
  2408.              case 0:  PRINTF("# Klammer nicht zu #"); break;
  2409.              case 1:  PRINTF("# Klammer nicht auf #"); break;
  2410.              case 2:  PRINTF("# Fehler beim Einlesen #"); break;
  2411.              case 3:  PRINTF("# unerwartetes Ende #"); break;
  2412.              case 4:  PRINTF("# Zeichen falsch #"); break;
  2413.              case 5:  PRINTF("# Variable nicht initialisiert #"); break;
  2414.              case 6:  PRINTF("# Zeichen falsch #"); break;
  2415.              case 7:  PRINTF("# Falscher Variablentyp #"); break;
  2416.              default: PRINTF("# undefinierter Fehler #"); break;
  2417.             }
  2418.            return (ERROR_1);
  2419.           }
  2420.           else
  2421.              {
  2422.                Result->VarWert.variable.Flotype = (double) Calc(&FTree);
  2423.                Result->VarType=FLONUM;
  2424.                DelTree(&FTree);
  2425.              }
  2426.    return (OK);
  2427. }
  2428.  
  2429. void ClearProg ()
  2430. {
  2431. PRGZEILE *Memory;
  2432.  
  2433.           ActLine = FirstLine;
  2434.  
  2435.           while (ActLine) {
  2436.           Memory = ActLine;
  2437.           ActLine = ActLine->NextZeile;
  2438.           LocalFree ((LOCALHANDLE)Memory);
  2439.           }
  2440.  
  2441.           FirstLine = ActLine = NULL;
  2442.  
  2443. }
  2444. void ClearVar()
  2445. {
  2446. VAR  *Memory;
  2447.           while (FirstVar) {
  2448.             Memory = FirstVar;
  2449.             if(Memory->VarType == STRING)
  2450.               LocalFree ((LOCALHANDLE)(Memory->VarWert.variable.text));
  2451.             FirstVar = FirstVar->NextVar;
  2452.             LocalFree ((LOCALHANDLE)Memory);
  2453.           }
  2454.           FirstVar = NULL;
  2455. }
  2456.  
  2457. void Carret(unsigned char *String)
  2458. {
  2459.     Leerstring[0]=(String[0]=='>') ? '>' : ' ';
  2460. }
  2461.  
  2462. void ErzeugeCursor(HWND hWnd)
  2463. {
  2464.  CreateCaret(hWnd,1,tm.tmAveCharWidth,tm.tmHeight);
  2465.  bCaret=TRUE;
  2466.  ShowCaret(hWnd);
  2467. }
  2468.  
  2469. void TEXTZEILE(HDC hDC,unsigned char *String)
  2470. {
  2471.   if(FontChange)
  2472.           {
  2473.            newFont = CreateFontIndirect((LPLOGFONT) &mF);
  2474.            oldFont = SelectObject(hDC,newFont);
  2475.            HideCaret(hWndglob);
  2476.           if(bCaret) DestroyCaret();
  2477.            GetTextMetrics(hDC,(LPTEXTMETRIC)&tm);
  2478.            ErzeugeCursor(hWndglob);
  2479.           }
  2480.     else if(!bCaret)
  2481.             {
  2482.              GetTextMetrics(hDC,(LPTEXTMETRIC)&tm);
  2483.              ErzeugeCursor(hWndglob);
  2484.             }
  2485.  
  2486.   if(!Drucker && !locate)
  2487.           {
  2488.            HideCaret(hWndglob);
  2489.            if(!Mono)
  2490.              SetTextColor(hDC,VIOLETT);
  2491.            Carret(String);
  2492.            TextOut(hDC,(short)0,(short)Zeile,(LPSTR)Leerstring,(short)80);
  2493.           }
  2494.  
  2495.  if(!Mono && !Drucker)
  2496.      switch(String[0])
  2497.       {
  2498.        case '>':
  2499.                  SetTextColor(hDC,VIOLETT);
  2500.                  break;
  2501.        case '#':
  2502.                  SetTextColor(hDC,ROT);
  2503.                  break;
  2504.        case '*':
  2505.                  SetTextColor(hDC,GRUEN);
  2506.                  break;
  2507.        case '+':
  2508.                  SetTextColor(hDC,BLACK);
  2509.                  break;
  2510.        default:
  2511.                SetTextColor(hDC,BLAU);
  2512.                  break;
  2513.       }
  2514.              if(!Mono) {
  2515.                            if(TextCol >= 0)
  2516.                               SetTextColor(hDC,SetRGBColor(TextCol));
  2517.  
  2518.                            if(Backgrd != 15)
  2519.                               SetBkColor(hDC,SetRGBColor(Backgrd));
  2520.                          }
  2521.             TextOut(hDC,(short)x,(short)Zeile,(LPSTR)String,(short)strlen(String));
  2522.  
  2523.            if(!locate)
  2524.               {
  2525.                 dwTextlen=GetTextExtent(hDC,(LPSTR)String,strlen(String));
  2526.                 pt=MAKEPOINT(dwTextlen);
  2527.                 LPtoDP(hDC,&pt,2);
  2528.                 SetCaretPos(x+pt.x,Zeile);
  2529.                 ShowCaret(hWndglob);
  2530.               }
  2531.  
  2532.             Zeile+=(tm.tmHeight+2);
  2533.  
  2534.       if(!Drucker && Zeile >= rect.bottom-(tm.tmHeight+2))
  2535.           {
  2536.                 Zeile=0;
  2537.                 if(!Mono && !Drucker)
  2538.                     SetTextColor(hDC,VIOLETT);
  2539.                  Carret(String);
  2540.                  TextOut(hDC,(short)0,(short)Zeile,(LPSTR)Leerstring,(short)80);
  2541.           }  /* else if(Drucker && Zeile > Blattgroesse...... */
  2542.  
  2543.   if(FontChange)
  2544.           {
  2545.            SelectObject(hDC,oldFont);
  2546.            DeleteObject(newFont);
  2547.           }
  2548.      x=0;
  2549.      locate=FALSE;
  2550. }
  2551.  
  2552. void PRINTF(unsigned char *String)
  2553. {
  2554. HDC hDC;
  2555.    if(Edit) return;
  2556.    if(PrMsgBox)
  2557.       {
  2558.        PrMsgBox=FALSE;
  2559.        what = MsgBox(String);
  2560.        return;
  2561.       }
  2562.  
  2563.    if(!Drucker)
  2564.      hDC = GetDC(hWndglob);
  2565.     else
  2566.      hDC = hPrnDC;
  2567.    TEXTZEILE(hDC,String);
  2568.    if(!Drucker)
  2569.       ReleaseDC(hWndglob,hDC);
  2570. }
  2571. DWORD SetRGBColor(int XW2)
  2572. {
  2573. DWORD FARBE;
  2574.        if(Mono) return (DWORD) 0;
  2575.                 else
  2576.                switch(XW2)
  2577.                  {
  2578.                      case 9:
  2579.                      case 1:    FARBE = BLAU;    break;
  2580.                      case 10:
  2581.                      case 2:    FARBE = GRUEN;   break;
  2582.                      case 11:
  2583.                      case 3:    FARBE = TURKIS;  break;
  2584.                      case 4:
  2585.                      case 6:
  2586.                      case 12:   FARBE = ROT;     break;
  2587.                      case 13:
  2588.                      case 5:    FARBE = VIOLETT; break;
  2589.                      case 15:
  2590.                      case 7:    FARBE = WEISS;   break;
  2591.                      case 14:   FARBE = GELB;    break;
  2592.                      case 8:
  2593.                      default:    FARBE = BLACK;   break;
  2594.                  }
  2595.    return FARBE;
  2596. }
  2597. void Zeichne(int was)
  2598. {
  2599. HDC hDC;
  2600.  
  2601.  
  2602.    if(!Drucker)
  2603.           {
  2604.            hDC = GetDC(hWndglob);
  2605.            switch(Brush)
  2606.              {
  2607.              case 1:
  2608.              case 9:  FARBBRUSH=hBlauBrush; break;
  2609.              case 2:
  2610.              case 10: FARBBRUSH=hGruenBrush; break;
  2611.              case 3:
  2612.              case 11: FARBBRUSH=hTurkisBrush; break;
  2613.              case 4 :
  2614.              case 6 :
  2615.              case 12:  FARBBRUSH=hRedBrush; break;
  2616.              case 7 :  FARBBRUSH=hGrauBrush; break;
  2617.              case 5:
  2618.              case 13: FARBBRUSH=hViolettBrush; break;
  2619.              case 14: FARBBRUSH=hGelbBrush; break;
  2620.              case 15: FARBBRUSH=hWeissBrush; break;
  2621.              default:
  2622.              case 0:
  2623.              case 8:  FARBBRUSH=hBlackBrush; break;
  2624.              }
  2625.  
  2626.              hOldBrush=SelectObject(hDC,FARBBRUSH);
  2627.  
  2628.                      switch(Pen)
  2629.                        {
  2630.                        case 1:
  2631.                        case 9:  FARBPEN=hBlauPen; break;
  2632.                        case 2:
  2633.                        case 10: FARBPEN=hGruenPen; break;
  2634.                        case 3:
  2635.                        case 11: FARBPEN=hTurkisPen; break;
  2636.                        case 4 :
  2637.                        case 6 :
  2638.                        case 12: FARBPEN=hRedPen; break;
  2639.                        case 7 : FARBPEN=hGrauPen; break;
  2640.                        case 5:
  2641.                        case 13: FARBPEN=hViolettPen; break;
  2642.                        case 14: FARBPEN=hGelbPen; break;
  2643.                        case 15: FARBPEN=hWeissPen; break;
  2644.                        default:
  2645.                        case 0:
  2646.                        case 8:  FARBPEN=hBlackPen; break;
  2647.                        }
  2648.                      hOldPen=SelectObject(hDC,FARBPEN);
  2649.           }
  2650.              else hDC = hPrnDC;
  2651.  
  2652.     switch(was)
  2653.      {
  2654.       case 0:
  2655.                /* da der DC immer neu erstellt wird müßten für moveto(x,y)
  2656.                     Variablen verwaltet werden...........
  2657.                */
  2658.                MoveTo(hDC,XW1,YW1);
  2659.                LineTo(hDC,XW2,YW2);
  2660.                break;
  2661.       case 1:
  2662.                Rectangle(hDC,XW1,YW1,XW2,YW2);
  2663.                break;
  2664.       case 2:
  2665.                Ellipse(hDC,XW1,YW1,XW2,YW2);
  2666.                break;
  2667.       case 3:
  2668.                RoundRect(hDC,XW1,YW1,XW2,YW2,XW3,YW3);
  2669.                break;
  2670.       case 4:
  2671.                Arc(hDC,XW1,YW1,XW2,YW2,XW3,YW3,XW4,YW4);
  2672.                break;
  2673.  
  2674.       case 5: SetPixel(hDC,XW1,YW1,SetRGBColor(XW2));
  2675.                 /* Variable = GetPixel in Funktion einbauen */
  2676.                break;
  2677.       case 6:
  2678.                Pie(hDC,XW1,YW1,XW2,YW2,XW3,YW3,XW4,YW4);
  2679.                break;
  2680.       case 7:
  2681.                MoveTo(hDC,XW1,YW1);
  2682.                LineTo(hDC,XW2,YW2);
  2683.                LineTo(hDC,XW3,YW3);
  2684.                LineTo(hDC,XW4,YW4);
  2685.                break;
  2686.       case 8:
  2687.                 switch(XW2)
  2688.                     {
  2689.                        case 1:
  2690.                        case 9:  FLOODFARBE=BLAU; break;
  2691.                        case 2:
  2692.                        case 10: FLOODFARBE=GRUEN; break;
  2693.                        case 3:
  2694.                        case 11: FLOODFARBE=TURKIS; break;
  2695.                        case 4 :
  2696.                        case 6 :
  2697.                        case 12: FLOODFARBE=ROT; break;
  2698.                        case 7 : FLOODFARBE=GRAU; break;
  2699.                        case 5:
  2700.                        case 13: FLOODFARBE=VIOLETT; break;
  2701.                        case 14: FLOODFARBE=GELB; break;
  2702.                        case 15: FLOODFARBE=WEISS; break;
  2703.                        default:
  2704.                        case 0:
  2705.                        case 8:  FLOODFARBE=BLACK; break;
  2706.                     }
  2707.                 FloodFill(hDC,XW1,YW1,FLOODFARBE);
  2708.                break;
  2709.        case 9:
  2710.                MoveTo(hDC,XW1,YW1);
  2711.                LineTo(hDC,XW2,YW2);
  2712.                LineTo(hDC,XW3,YW3);
  2713.                LineTo(hDC,XW4,YW4);
  2714.                LineTo(hDC,XW1,YW1);
  2715.                break;
  2716.        case 10:
  2717.                MoveTo(hDC,XW1,YW1);
  2718.                LineTo(hDC,XW2,YW1);
  2719.                LineTo(hDC,XW2,YW2);
  2720.                LineTo(hDC,XW1,YW2);
  2721.                LineTo(hDC,XW1,YW1);
  2722.                break;
  2723.      }
  2724.  
  2725.    if(!Drucker)
  2726.       {
  2727.        SelectObject(hDC,hOldPen);
  2728.        SelectObject(hDC,hOldBrush);
  2729.        ReleaseDC(hWndglob,hDC);
  2730.       }
  2731. }
  2732.