home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / qc25 / beispiel / diagsupt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-25  |  14.0 KB  |  498 lines
  1. /* CHRTSUPT.C - Unterstützungsmodul für das Diagrammgrafik-Beispielprogramm */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdarg.h>
  6. #include <string.h>
  7. #include <conio.h>
  8. #include <graph.h>
  9. #include <pgchart.h>
  10. #include <stdarg.h>
  11. #include "diagdemo.h"
  12.  
  13. /* Variablen zur Menüverwaltung.  */
  14. int cMenueEbene = 0;                 /* Gegenwärtige Menüebene   */
  15. char *szMenueTitel[10];              /* Stapel von Menütiteln */
  16.  
  17. char *pszBlankMenue[4];
  18.  
  19. /* Die Variablen zum Verfolgen von Steuerung und Bildschirmposition.  */
  20. struct SCREENINFO si;
  21.  
  22. /* */
  23. struct tagFarbe co;
  24.  
  25. /*  BlankMenü - Holt Antworten zu zwei bestimmten Wahlmöglichkeiten.
  26.  *
  27.  *  Parameter: pchTitel - Titelzeichenfolge für Menü
  28.  *             pchWahl1 - Zeichenfolge für Wahlmöglichkeit 1
  29.  *             pchWahl2 - Zeichenfolge für Wahlmöglichkeit 2
  30.  *
  31.  *  Ergibt:    Return: Anzahl der Wahlmöglichkeiten oder ESCAPE
  32.  */
  33. int BlankMenue( char *pchTitel, char *pchWahl1, char *pchWahl2 )
  34. {
  35.     int iWahl;
  36.  
  37.     /* Titel und Wahlmöglichkeiten initialisieren.  */
  38.     pszBlankMenue[0] = pchTitel;
  39.     pszBlankMenue[1] = pchWahl1;
  40.     pszBlankMenue[2] = pchWahl2;
  41.     pszBlankMenue[3] = "\0";
  42.     PushTitel( pszBlankMenue[0]);
  43.  
  44.     while( WAHR )
  45.     {
  46.     /* Nur Anfangsbuchstaben einer der Wahlmöglichkeiten akzeptieren,
  47.      * oder ESC.
  48.      */
  49.      iWahl = Menue( pszBlankMenue );
  50.         switch( iWahl )
  51.         {
  52.             case 1:
  53.             case 2:
  54.             case ESCAPE:
  55.                 return iWahl;
  56.         }
  57.     }
  58. }
  59.  
  60. /*  LschForm - Löscht den Innenbereich der Bildschirmanzeige
  61.  *
  62.  *  Parameter: Keine
  63.  */
  64. void LschForm()
  65. {
  66.  
  67.     /* Bildschirm-Teilausschnitt einrichten und löschen, dann ganzen
  68.      * Bildschirm rücksetzen.
  69.      */
  70.     _settextwindow( si.top, 1, si.bot, 80 );
  71.     _clearscreen( _GWINDOW );
  72.     _settextwindow( 1, 1, 25, 80 );
  73.  
  74. }
  75.  
  76. /*  LschHilfe - Clears the current help Zeile.
  77.  *
  78.  *  Parameter: None
  79.  */
  80. void LschHilfe()
  81. {
  82.     /* Hilfezeilenzähler um 1 verringern und die Zeile löschen.  */
  83.     _settextwindow( --si.help, 1, si.help, 80 );
  84.     _clearscreen( _GWINDOW );
  85.     _settextwindow( 1, 1, 25, 80 );
  86. }
  87.  
  88. /*  FehlerMldg - Bringt eine Fehlermeldung.
  89.  *
  90.  *  Parameter: pchMdg - Zeichenfolge der Fehlermeldung
  91.  */
  92. void FehlerMldg( char *pchMdg )
  93. {
  94.  
  95.     /* Warnsignal, Fehlerfarbe festlegen, dann Fehlermeldung und
  96.      * 'Weiter'-Frage ausgeben.
  97.      */
  98.     putch( SIGNAL );
  99.     Hilfe( pchMdg, co.FehlerFarbe );
  100.     Hilfe( "Weiter durch Drücken beliebiger Taste.", co.FehlerFarbe );
  101.  
  102.     /* Auf Tastendruck warten und Hilfezeilen löschen.  */
  103.     getch();
  104.     LschHilfe();
  105.     LschHilfe();
  106.  
  107. }
  108.  
  109. /*  Hilfe - Zeigt eine Hilfezeile auf dem Bildschirm.
  110.  *
  111.  *  Parameter: pchMdg - Zeichenfolge der Fehlermeldung
  112.  *             sFarbe - Farbe für Meldung
  113.  */
  114. void Hilfe( char *pchMdg, short sFarbe )
  115. {
  116.  
  117.     struct rccoord rcCursor;
  118.  
  119.     /* Gegenwärtige Cursorposition speichern.  */
  120.     rcCursor = _gettextposition();
  121.  
  122.    /* Hilfezeile ausgeben und Hilfezeilen-Positionsvariable um 1 erhöhen. */
  123.     AusgabePos( si.help++, 5, pchMdg, sFarbe );
  124.  
  125.     /* Cursorposition wiederherstellen.  */
  126.     _settextposition( rcCursor.row, rcCursor.col );
  127.  
  128. }
  129.  
  130. /*  EingabeChar - Fragt nach und ergibt Eingabezeichen.
  131.  *
  132.  *  Parameter: pchFrage  - Zeichenfolge für Anfrage
  133.  *             pchAkzept - Zeichenfolge akzeptabler Zeichen (Groß- und
  134.  *                         Kleinschreibung werden unterschieden)
  135.  *
  136.  *  Ergibt:    Eingegebenes Zeichen
  137.  */
  138. char EingabeChar( char *pchFrage, char *pchAkzept )
  139. {
  140.     char chAntwort;
  141.  
  142.     /* Anfrage ausgeben.  */
  143.     AusgabePos( si.mid, 10, pchFrage, co.EingabeFarbe );
  144.  
  145.     /* Schleife weiterführen bis Antwort gültig ist.  */
  146.     while( WAHR )
  147.     {
  148.         chAntwort = toupper( getch() );
  149.  
  150.         /* Zeichen anzeigen und ergeben, wenn gültig, sonst Warnsignal.  */
  151.         if( *strchr( pchAkzept, chAntwort) )
  152.         {
  153.          _settextcolor( co.InfoFarbe );
  154.             putch( chAntwort );
  155.             return chAntwort;
  156.         }
  157.         else
  158.          putch( SIGNAL );
  159.     }
  160. }
  161.  
  162. /*  EingabeInt - Fragt nach und ergibt Ganzzahlwert innerhalb eines
  163.  *  bestimmten Bereiches.
  164.  *
  165.  *  Parameter: pchFrage - Zeichenfolge für Anfrage
  166.  *             iAlt - Voriger Wert
  167.  *             iMin - Mindestwert des Bereichs
  168.  *             iMax - Höchstwert des Bereichs
  169.  *
  170.  *  Ergibt:    Vom Benutzer eingegebene Ganzzahl
  171.  */
  172. int EingabeInt( char *pchFrage, int iAlt, int iMin, int iMax )
  173. {
  174.     int i;
  175.     char szTmp[70];
  176.  
  177.     /* Zur Eingabe einer Zeichenfolge auffordern, diese dann zu Ganzzahl
  178.      * umwandeln bis sich ein Wert innerhalb des bestimmten Bereichs ergibt.
  179.      * Diesen Wert schließlich ergeben.
  180.      */
  181.     do
  182.     {
  183.      EingabeString( pchFrage, itoa( iAlt, szTmp, 10) );
  184.         i = atoi( szTmp );
  185.     } while( !InBereich( i, iMin, iMax) );
  186.     return i;
  187. }
  188.  
  189. /*  EingabeFloat - Fordert zur Eingabe eines Gleitkommawerts auf und
  190.  *               ergibt diesen.
  191.  *
  192.  *  Parameter: pchFrage - Zeichenfolge für Aufforderung
  193.  *             fAlt - Voriger Wert
  194.  *
  195.  *  Ergibt:    Vom Benutzer eingegebene Gleitkommazahl
  196.  */
  197. float EingabeFloat( char *pchFrage, float fAlt )
  198. {
  199.     char szTmp[70];
  200.  
  201.     /* Zur Eingabe einer Zeichenfolge auffordern, zu Gleitkomma umwandeln */
  202.     sprintf( szTmp, "%f", fAlt );
  203.     EingabeString( pchFrage, szTmp );
  204.     return atof( szTmp );
  205. }
  206.  
  207. /*  EingabeString - Aufforderung zur Eingabe einer Zeichenfolge. Bis erstes
  208.  *  Zeichen eingegeben ist, wird vorige Zeichenfolge gezeigt, dann durch
  209.  *  neue Eingabe ersetzt.
  210.  *
  211.  *  Parameter: pchFrage - Zeichenfolge für Aufforderung
  212.  *             pchAlt   - Zwischenspeicher für vorige Zeichenfolge; muß groß
  213.  *                        genug für neue Zeichenfolge sein.
  214.  *
  215.  *  Ergibt:    Zeiger zu pchAlt, wo nun neue Zeichenfolge vorliegt
  216.  */
  217. char *EingabeString( char *pchFrage, char *pchAlt )
  218. {
  219.     char szTmp[81], ch;
  220.     int x = 5, y = si.mid;
  221.  
  222.     /* Aufforderung in Ausschnittmitte ausgeben.  */
  223.     LschForm();
  224.     AusgabePos( y, x, pchFrage, co.EingabeFarbe );
  225.     x += strlen( pchFrage );
  226.  
  227.     /* Vorigen Wert zur Bezugnahme ausgeben.  */
  228.     _outtext( pchAlt );
  229.     _settextposition( y, x );
  230.  
  231.     /* Auf Eingabe warten, danach alte Zeichenfolge löschen.  */
  232.     while( !(ch = kbhit()) )
  233.         ;
  234.     memset( szTmp, ' ', 80 );
  235.     szTmp[80] = '\0';
  236.     AusgabePos( y, x, szTmp, -1 );
  237.  
  238.     /* Neue Zeichenfolge holen und zu Ergebnis machen. Wenn Null-
  239.      * Zeichenfolge (EINGABE-Taste gedrückt), ist alter Wert das Ergebnis.
  240.      */
  241.     _settextcolor( co.InfoFarbe );
  242.     _settextposition( y, x );
  243.     szTmp[0] = 70;             /* Einlesebare Maximallänge */
  244.     cgets( szTmp );
  245.     if( szTmp[1] > 0 )         /* Wurden überhaupt Zeichen eingelesen?  */
  246.     {
  247.         strcpy( pchAlt, &szTmp[2] );
  248.         return &szTmp[2];
  249.     }
  250.     else
  251.     {
  252.         _settextposition( y, x );
  253.         return pchAlt;
  254.     }
  255. }
  256.  
  257. /*  InBereich - Prüft ob Ganzzahl innerhalb des bestimmten Bereichs liegt.
  258.  *
  259.  *  Parameter: iWert - Zu prüfende Ganzzahl
  260.  *             iMin  - Mindestwert des Bereichs
  261.  *             iMax  - Höchstwert des Bereichs
  262.  *
  263.  *  Ergibt:    WAHR sofern innerhalb des Bereichs, sonst FALSCH
  264.  */
  265. BOOL InBereich( int Value, int iMin, int iMax )
  266. {
  267.     /* Bereich prüfen und WAHR ergeben wenn gültig, sonst FALSCH. Bitte zu
  268.      * beachten, daß (iMin >= iMax) nur als Anweisung verstanden wird, auf
  269.      * den Mindestwert zu prüfen; Höchstwert gibt es keinen.
  270.      */
  271.     if( Value >= iMin )
  272.         if( (Value <= iMax) || (iMin >= iMax) )
  273.          return WAHR;
  274.     else
  275.     {
  276.      FehlerMldg( "Ungültiger Wert." );
  277.      return FALSCH;
  278.     }
  279. }
  280.  
  281. /* Menü - Zeichnet Menü auf Bildschirm; ergibt Anzahl der Wahlmöglichkeiten.
  282.  *
  283.  * Parameter: Datenfeld der Menü-Zeichenfolgen
  284.  *
  285.  * Ergibt: Zahl für die aus dem Menü getroffene Wahl
  286.  */
  287. int Menue( char *pszMenueListe[] )
  288. {
  289.     int iItem, cItem, yItem, x = 10;
  290.     char chAntwort;
  291.  
  292.     /* Menü-Wahlmöglichkeiten zählen.  */
  293.     for( cItem = 1; *pszMenueListe[cItem]; cItem++ )
  294.         ;
  295.     --cItem;
  296.  
  297.  
  298.     /* Form löschen und Wahlmöglichkeiten des Menüs ausgeben.  */
  299.     WrtForm( 10 + cItem );
  300.     for( iItem = 1, yItem = 8; iItem <= cItem; iItem++, yItem++ )
  301.     {
  302.      AusgabePos( yItem, x, pszMenueListe[iItem], co.EingabeFarbe );
  303.      PrintChar( yItem, x, pszMenueListe[iItem][0], co.HellFarbe );
  304.     }
  305.     ++yItem;
  306.  
  307.     /* Aufforderung und Hilfe anzeigen.  */
  308.     if( strcmpi( pszMenueListe[0], "Hauptmenü" ) )/* Falls nicht Hauptmenü */
  309.      Hilfe( "Anfangsbuchstaben Ihrer Wahl eingeben, bzw. zurück mit ESC.",
  310.             co.EingabeFarbe );
  311.     else
  312.      Hilfe( "Anfangsbuchstaben Ihrer Wahl eingeben; mit \"E\" beenden.",
  313.             co.EingabeFarbe );
  314.  
  315.     AusgabePos( yItem, x += 5, "Ihre Wahl? ", co.InfoFarbe );
  316.     x += 11;
  317.  
  318.     /* Schleife bis zu brauchbarer Wahl; Warnsignal bei ungültiger Wahl. */
  319.     while( WAHR )
  320.     {
  321.         _settextposition( yItem, x );
  322.         chAntwort = toupper( getch() );
  323.  
  324.         /* Zurück - aufgrund Drücken von ESC.  */
  325.         if( chAntwort == 27 )
  326.         {
  327.             LschHilfe();
  328.             return ESCAPE;
  329.         }
  330.  
  331.         /* Unter Wahlmöglichkeit nach entsprechendem Anfangsbuchstaben
  332.          * suchen. Dann betreffende Wahlmöglichkeit als Ergebnis ausgeben
  333.          * und Hilfezeile löschen.
  334.          */
  335.         for( iItem = 1; iItem <= cItem; iItem++ )
  336.         {
  337.          if( chAntwort == toupper( pszMenueListe[iItem][0]) )
  338.             {
  339.                 putch( chAntwort );
  340.                 LschHilfe();
  341.                 return iItem;
  342.             }
  343.         }
  344.  
  345.         /* Hierher kommt man nur, wenn keine brauchbare Wahlmöglichkeit
  346.          * gefunden wurde; deshalb Warnsignal und Vorgang wiederholen.
  347.          */
  348.      putch( SIGNAL );
  349.     }
  350. }
  351.  
  352. /*  PopTitel - Einen Menütitel aus dem Menüstapel entnehmen.
  353.  *
  354.  *  Parameter: Keine
  355.  */
  356. void PopTitel()
  357. {
  358.     szMenueTitel[--cMenueEbene] = "";
  359. }
  360.  
  361. /*  AusgabePos - Druckt an den bestimmten Koordinaten (Reihe/Spalte)
  362.  *            eine Zeichenfolge in der festgelegten Farbe .
  363.  *
  364.  *  Parameter: row        - Reihe wo Ausgabe der Zeichenfolge beginnen soll
  365.  *             col        - Spalte wo Ausgabe der Zeichenfolge beginnen soll
  366.  *             lpszString - Null-abgeschlossene Zeichenfolge
  367.  *             sFarbe     - Farbe zur Ausgabe der Zeichenfolge (-1 wenn
  368.  *                          AusgabePos die Farbe unverändert belassen soll)
  369.  */
  370. void AusgabePos(int row, int column, char far * lpszString, short sFarbe)
  371. {
  372.     if( sFarbe != -1L )
  373.         _settextcolor( sFarbe );
  374.     _settextposition( row, column );
  375.     _outtext( lpszString );
  376. }
  377.  
  378. /*  PrintChar - Druckt an den bestimmten Koordinaten (Reihe/Spalte)
  379.  *              eine Zeichenfolge in der festgelegten Farbe .
  380.  *
  381.  *  Parameter: row        - Reihe wo Ausgabe der Zeichenfolge beginnen soll
  382.  *             col        - Spalte wo Ausgabe der Zeichenfolge beginnen soll
  383.  *             cChar      - Zu druckendes Zeichen
  384.  *             sFarbe     - Farbe zur Ausgabe der Zeichenfolge (-1 wenn
  385.  *                          AusgabePos die Farbe unverändert belassen soll)
  386.  */
  387. void PrintChar(int row, int column, char cChar, short sFarbe)
  388. {
  389.     char szTiny[2];
  390.  
  391.     szTiny[0] = cChar;
  392.     szTiny[1] = '\0';
  393.     AusgabePos( row, column, szTiny, sFarbe );
  394. }
  395.  
  396. /*  PushTitel - Legt einen Menütitel zuf den Menüstapel.
  397.  *
  398.  *  Parameter: pchTitel - abzulegende Titelzeichenfolge
  399.  */
  400. void PushTitel( char *pchTitel )
  401. {
  402.     szMenueTitel[cMenueEbene++] = pchTitel;
  403. }
  404.  
  405. /*  SetDisplayColors - Farben auf Wert einrichten, die dem vorhandenen
  406.  *                     Videoadapter entsprechen.
  407.  *
  408.  * Parameter: Keine
  409.  */
  410. void SetDisplayColors()
  411. {
  412.     if( ismono( si.mode ) )
  413.     {
  414.      co.EingabeFarbe  = M_INPUTCOLOR;
  415.      co.HellFarbe = M_HILITECOLOR;
  416.      co.FormFarbe   = M_FORMCOLOR;
  417.      co.TitelFarbe  = M_TITLECOLOR;
  418.         co.FehlerFarbe  = M_ERRORCOLOR;
  419.      co.InfoFarbe   = M_INFOCOLOR;
  420.     }
  421.     else
  422.     {
  423.      co.EingabeFarbe  = C_INPUTCOLOR;
  424.      co.HellFarbe = C_HILITECOLOR;
  425.      co.FormFarbe   = C_FORMCOLOR;
  426.      co.TitelFarbe  = C_TITLECOLOR;
  427.         co.FehlerFarbe  = C_ERRORCOLOR;
  428.      co.InfoFarbe   = C_INFOCOLOR;
  429.     }
  430. }
  431.  
  432. /*  SAusgabePos - Zeichenfolge über sprintf() formatieren und mit
  433.  *             AusgabePos zum Bildschirm ausgeben.
  434.  *
  435.  *  Parameter: iReihe  - Reihe, wo Anzeige anfangen soll
  436.  *             iSplt   - Spalte, and der Anzeige anfangen soll
  437.  *             szFmt   - Formatierfolge (für richtige Schreibweise von
  438.  *                       Formatierfolgen siehe Begleitliteratur der
  439.  *                       Laufzeitbibliothek).
  440.  *             ...     - Auszugebende Variablen
  441.  */
  442. void SAusgabePos( int iReihe, int iSplt, char * szFmt, ... )
  443. {
  444.     char szTmp[81];
  445.     va_list Marke;
  446.     va_list saveMarke;
  447.  
  448.     va_start( Marke, szFmt );
  449.     saveMarke = Marke;
  450.     vsprintf( szTmp, szFmt, Marke );
  451.     va_end( Marke );
  452.  
  453.     AusgabePos( iReihe, iSplt, szTmp, -1 );
  454. }
  455.  
  456. /*  WrtForm - Zeigt Bildschirmformat.
  457.  *
  458.  *  Parameter: yBot - Reihennummer der untersten Reihe
  459.  */
  460. void WrtForm( int yBot )
  461. {
  462.     int i;
  463.     char szTmp[81];
  464.  
  465.     /* Rechts oben die Copyright-Meldung ausgeben.  */
  466.     _clearscreen( _GCLEARSCREEN );
  467.     AusgabePos( 1, 55, "Diagrammgrafik - Demo", co.TitelFarbe );
  468.  
  469.     /* Die obere Trennzeile löschen.  */
  470.     memset( szTmp, ' ', 79 );
  471.     szTmp[79] = 0;
  472.     AusgabePos( 2, 55, "(C) 1990, Microsoft", co.TitelFarbe );
  473.  
  474.     /* Alle ebenen des Menütitels anzeigen.  */
  475.     _settextposition( 5, 5 );
  476.     for( i = 0; i < cMenueEbene; i++ )
  477.     {
  478.         if( i )
  479.             _outtext( " - " );
  480.      _outtext( szMenueTitel[i] );
  481.     }
  482.  
  483.     /* Obere Trennzeile anzeigen.  */
  484.     memset( szTmp, 196, 80 );
  485.     szTmp[80] = 0;
  486.     AusgabePos( 6, 1, szTmp, co.FormFarbe );
  487.  
  488.     /* Untere Trennzeile anzeigen.  */
  489.     AusgabePos( yBot, 1, szTmp, co.FormFarbe );
  490.  
  491.     /* Globale Bildschirm-Variablen einrichten.  */
  492.  
  493.     si.help = yBot + 1;
  494.     si.top = 7;
  495.     si.bot = yBot - 1;
  496.     si.mid = (si.top + si.bot) / 2;
  497. }
  498.