home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / qc25 / beispiel / diagopt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-25  |  25.1 KB  |  925 lines
  1. /* DIAGOPT.C - Modul mit den Optionen für das Diagrammgrafik
  2.  * -Beispielprogramm
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <conio.h>
  8. #include <graph.h>
  9. #include <pgchart.h>
  10. #include "diagdemo.h"
  11.  
  12.  
  13. /* Strukturen für System-Konfiguration und Diagrammumgebung. */
  14. extern struct videoconfig vc;
  15. extern chartenv ce;
  16.  
  17. /* Die Variablen zum Verfolgen von Steuerung und Bildschirmposition.  */
  18.  
  19. extern struct SCREENINFO si;
  20.  
  21.  
  22. /* Farben von Menüs und Eingabeaufforderungen */
  23. extern struct tagFarbe co;
  24.  
  25.  
  26. /* Zeichenfolge-Datenfelder für die Menü-Funktion. Die erste Zeichenfolge
  27.  * ist der Menütitel. Die nächsten Zeichenfolgen ungleich Null sind die
  28.  * Wahlmöglichkeiten des Menüs. Eine Null-Zeichenfolge bedeutet das Ende der
  29.  * Liste
  30.  */
  31.  
  32. char *pszAchsen[] =
  33.     { "Achse", "X Achse", "Y Achse", "" };
  34.  
  35. char *pszAchse[] =
  36.     { "?", "Gitter", "Achsentitel", "Farbe",
  37.       "Bereichstyp", "Skala", "Einteilung", "" };
  38.  
  39. char *pszAuto[] =
  40.     { "Skala", "Auto", "Manuell", "" };
  41.  
  42. char *pszRand[] =
  43.     { "Typ", "Farbe", "Stil", "" };
  44.  
  45. char *pszDiagrammFenster[] =
  46.     { "Diagramm", "Größe", "Hintergrundfarbe", "Rand", "" };
  47.  
  48. char *pszDatenFenster[] =
  49.     { "Daten", "Hintergrundfarbe", "Rand", "" };
  50.  
  51. char * pszSchriftOpt[] =
  52.     { "Schrift", "Schriftart ändern", "Zeichengröße", "" };
  53.  
  54. char *pszAusrichten[] =
  55.     { "Ausrichten", "Links", "Mittig", "Rechts", "" };
  56.  
  57. char *pszBeschriftungFenster[] =
  58.     { "Optionen", "Stelle", "Textfarbe", "Größe", "Hintergrundfarbe",
  59.       "Rand", "" };
  60.  
  61. char *pszStelle[] =
  62.     { "Stelle", "Rechts", "Unten", "Überlagerung", "" };
  63.  
  64. char *pszSkala[] =
  65.     { "Skala", "M - Minimum", "X - Maximum", "Faktor", "Titel", "" };
  66.  
  67. char *pszGroesse[] =
  68.     { "Größe", "Oben", "Links", "Unten", "Rechts", "" };
  69.  
  70. char *pszEinteilung[] =
  71.     { "Art", "Intervall", "Format", "Nachkomma", "" };
  72.  
  73. char *pszTitelOpt[] =
  74.     { "", "Text", "Farbe", "Ausrichten", "" };
  75.  
  76. char *pszTitel[] =
  77.     { "Titel", "Haupttitel", "Nebentitel", "" };
  78.  
  79. char *pszSchriftart[] =
  80.     { "Art", "Courier", "Helv", "Tms Rmn", "Modern", "Script",
  81.       "Roman", "Keine", "" };
  82.  
  83. char *pszFenster[] =
  84.     { "Fenster", "Diagramm-Fenster", "Werte-Fenster", "" };
  85.  
  86. /*  Achsen - X oder Y
  87.  *
  88.  *  Parameter: keine
  89.  */
  90. void Achsen()
  91. {
  92.     int iWahl;
  93.     static axistype *patAchse[2] = { &ce.xaxis, &ce.yaxis };
  94.  
  95.     /* Menüwahl und dann aufrufen des entsprechenden Achsenmenüs. */
  96.     PushTitel( pszAchsen[0] );
  97.     Hilfe( "'X' oder 'Y' Achse wählen", co.EingabeFarbe );
  98.     while( (iWahl = Menue( pszAchsen )) != ESCAPE )
  99.     {
  100.         /* Achsentitel ändern, je nach Wahl. */
  101.         pszAchse[0][0] = (--iWahl == 0) ? 'X' : 'Y';
  102.  
  103.         /* Achsen-Information holen für richtige Achse. */
  104.         Achse( patAchse[iWahl] );
  105.     }
  106.     PopTitel();
  107. }
  108.  
  109. /*  Achse - Wählt Achsenoptionen.
  110.  *
  111.  *  Parameter: pat - Zeiger zur Variablen axistype
  112.  */
  113. void Achse( axistype *pat )
  114. {
  115.     int iWahl;
  116.  
  117.     PushTitel( pszAchse[0] );
  118.     while( (iWahl = Menue( pszAchse )) != ESCAPE )
  119.     {
  120.  
  121.         /* Achsenoption holen.  */
  122.         switch( iWahl )
  123.         {
  124.             case 1:
  125.                 /* Gitter oder nicht? */
  126.                 iWahl = BlankMenue( "Gitter", "Gitter", "Kein Gitter" );
  127.                 switch( iWahl )
  128.                 {
  129.  
  130.                     case 1:
  131.                         /* Wenn ja, Gitterkennung setzen u. Art holen. */
  132.                pat->grid = WAHR;
  133.                Hilfe( "Zahl zwischen 0 und 10 eingeben.",
  134.                             co.EingabeFarbe );
  135.                         pat->gridstyle =
  136.                    EingabeInt( "Gitterart? ", pat->gridstyle, 0, 10 );
  137.                         break;
  138.  
  139.                     case 2:
  140.                         /* Wenn nein, Gitterkennung löschen.  */
  141.                pat->grid = FALSCH;
  142.                 }
  143.                 PopTitel();
  144.                 break;
  145.  
  146.             case 2:
  147.                 /* Optionen für Achsentitel wählen. */
  148.                 pszTitelOpt[0] = "Achsentitel";
  149.                 TitelOpt( &pat->axistitle );
  150.                 break;
  151.  
  152.             case 3:
  153.                 /* Farbe wählen. */
  154.           Hilfe( "Zahl zwischen 0 und 15 eingeben.", co.EingabeFarbe );
  155.                 pat->axiscolor =
  156.                     EingabeInt( "Achsenfarbe? ", pat->axiscolor, 0, 15 );
  157.                 break;
  158.  
  159.             case 4:
  160.                 /* Achsenbereich holen.  */
  161.                 AchsenBereich( pat );
  162.                 break;
  163.  
  164.             case 5:
  165.                 /* Achsenskala holen.  */
  166.           AchsenSkala( pat );
  167.                 break;
  168.  
  169.             case 6:
  170.                 /* Achseneinteilungs-Optionen holen.  */
  171.                 AchsenEinteilung( pat );
  172.                 break;
  173.  
  174.         }
  175.     }
  176.     PopTitel();
  177. }
  178. /*  Achsenbereich - wählt Bereich für eine Achse.
  179.  *
  180.  *  Parameter: pat - Zeiger zur Variablen axistype
  181.  */
  182. void AchsenBereich( axistype *pat )
  183. {
  184.     int iWahl;
  185.  
  186.     iWahl = BlankMenue( "Bereichstyp", "Normal", "Logarithmisch" );
  187.     switch( iWahl )
  188.     {
  189.         case 1:
  190.             /* Bereichstyp auf linear einrichten.  */
  191.             pat->rangetype = _PG_LINEARAXIS;
  192.             break;
  193.  
  194.         case 2:
  195.             /* Bereichstyp auf Log einrichten, dann nach Log-Basis fragen.*/
  196.             pat->rangetype = _PG_LOGAXIS;
  197.          Hilfe( "Wert größer oder gleich 2 eingeben.", co.EingabeFarbe );
  198.             pat->logbase = EingabeInt( "Log-Basis? ", (int)pat->logbase, 2,
  199. 0 );
  200.             break;
  201.     }
  202.     PopTitel();
  203. }
  204.  
  205. /*  AchsenSkala - Skalaoptionen für eine Achse wählen.
  206.  *
  207.  *  Parameter: pat - Zeiger zur Variablen axistype  */
  208. void AchsenSkala( axistype *pat )
  209. {
  210.     int iWahl;
  211.  
  212.     PushTitel( pszAuto[0] );
  213.     iWahl = Menue( pszAuto );
  214.     switch( iWahl )
  215.     {
  216.  
  217.         case 1:
  218.             /* AutoSkala-Kennung einsetzen.  */
  219.          pat->autoscale = WAHR;
  220.             break;
  221.  
  222.         case 2:
  223.  
  224.             /* AutoSkala-Kennung löschen und Skala-Optionen holen.  */
  225.          pat->autoscale = FALSCH;
  226.             PushTitel( pszSkala[0] );
  227.             while( (iWahl = Menue( pszSkala )) != ESCAPE )
  228.             {
  229.  
  230.                 switch( iWahl )
  231.                 {
  232.  
  233.                     case 1:
  234.                         /* Frage nach Skalenminimum.  */
  235.                Hilfe( "Bereichs-Mindestwert eingeben.", co.EingabeFarbe );
  236.                         pat->scalemin =
  237.                    (float)EingabeInt( "Minimum? ",
  238.                               (int)pat->scalemin, 1, 0 );
  239.                         break;
  240.  
  241.                     case 2:
  242.                         /* Frage nach Skalenmaximum.  */
  243.                Hilfe( "Bereichs-Höchstwert eingeben.", co.EingabeFarbe );
  244.                         pat->scalemax =
  245.                    (float) EingabeInt( "Maximum? ",
  246.                                (int)pat->scalemax, 1, 0 );
  247.                         break;
  248.  
  249.                     case 3:
  250.                         /* Frage nach Faktor der Skala.  */
  251.                Hilfe( "Skalenfaktor eingeben (mind. 1).", co.EingabeFarbe );
  252.                         pat->scalefactor =
  253.                    (float)EingabeInt( "Skalenfaktor? ",
  254.                                (int)pat->scalefactor, 1, 0 );
  255.                         break;
  256.  
  257.                     case 4:
  258.                         /* Titel der Skala ändern, dann über Menü
  259.                          * Titeloptionen holen.
  260.                          */
  261.                pszTitelOpt[0] = "Titel";
  262.                         TitelOpt( &pat->scaletitle );
  263.  
  264.                 }
  265.             }
  266.             PopTitel();
  267.     }
  268.     PopTitel();
  269. }
  270.  
  271. /*  AchsenEinteilung - Wählt Einteilungs-Optionen für eine Achse.
  272.  *
  273.  *  Parameter: pat - Zeiger zur Variablen axistype
  274.  */
  275. void AchsenEinteilung( axistype *pat )
  276. {
  277.     int iWahl;
  278.  
  279.     PushTitel( pszEinteilung[0] );
  280.     while( (iWahl = Menue( pszEinteilung )) != ESCAPE )
  281.     {
  282.         switch( iWahl )
  283.         {
  284.  
  285.             case 1:
  286.                 /* Anfrage nach Einteilungsabstand (Intervall).  */
  287.                 Hilfe( "Abstand in Dateneinheiten:", co.EingabeFarbe );
  288.                 pat->ticinterval =
  289.               EingabeFloat( "Abstand zwischen Einteilungen? ", pat->ticinterval );
  290.           pat->autoscale = FALSCH;
  291.                 break;
  292.  
  293.             case 2:
  294.                 /* Anfrage nach Einteilungsformat.  */
  295.           iWahl = BlankMenue( "Format", "Normal", "Logarithmisch" );
  296.                 if( iWahl != ESCAPE )
  297.                     pat->ticformat = iWahl;
  298.                 break;
  299.  
  300.             case 3:
  301.           /* Frage nach Anzahl der Dezimalstellen je Einteilung.  */
  302.                 pat->ticdecimals =
  303.               EingabeInt( "Dezimalstellen eingeben (0 - 9). ", pat->ticdecimals, 0, 9 );
  304.           pat->autoscale = FALSCH;
  305.                 break;
  306.         }
  307.  
  308.     }
  309.     PopTitel();
  310. }
  311.  
  312. /*  Rand - Bestimmt Informationen für Fensterrand.
  313.  *
  314.  *  Parameter: pwt - Pointer to windowtype Variable
  315.  */
  316. void Rand( windowtype *pwt )
  317. {
  318.     int iWahl;
  319.  
  320.     /* Anfrage ob Rand gewünscht ist.  */
  321.     iWahl = BlankMenue( "Rand", "Rand", "Kein Rand" );
  322.     switch( iWahl )
  323.     {
  324.  
  325.         case 1:
  326.  
  327.             /* Wenn Rand, Randkennung setzen, nach Randoptionen fragen.  */
  328.          pwt->border= WAHR;
  329.             PushTitel( pszRand[0] );
  330.             while( (iWahl = Menue( pszRand )) != ESCAPE )
  331.             {
  332.                 switch( iWahl )
  333.                 {
  334.                     case 1:
  335.                         /* Anfrage nach Randfarbe.  */
  336.                Hilfe( "Farbe im Bereich 0 - 15 eingeben.", co.EingabeFarbe );
  337.                         pwt->bordercolor =
  338.                    EingabeInt( "Randfarbe? ", pwt->bordercolor, 0, 15 );
  339.                         break;
  340.  
  341.                     case 2:
  342.                         /* Anfrage nach Randstil.  */
  343.                Hilfe( "Stil zwischen 0 - 10 eingeben.", co.EingabeFarbe );
  344.                         pwt->borderstyle =
  345.                    EingabeInt( "Randstil? ", pwt->borderstyle, 0, 10 );
  346.                 }
  347.             }
  348.             PopTitel();
  349.             break;
  350.  
  351.         case 2:
  352.             /* Wenn kein Rand, Randkennung löschen.  */
  353.          pwt->border= FALSCH;
  354.     }
  355.     PopTitel();
  356. }
  357.  
  358. /*  AndereSchrift - Hier kann der Benutzer neue Schriftart bestimmen.
  359.  *
  360.  *  Parameter: Keine
  361.  */
  362.  
  363. void AndereSchrift()
  364. {
  365.     int iWahl;
  366.     struct _fontinfo fd;
  367.                             /* Zustand der Schriftsatzsammlung */
  368.     static BOOL SchriftenRegistriert = FALSCH;
  369.  
  370.     /* Menüwahl holen und entsprechend Achsenmenü aufrufen. */
  371.     PushTitel( pszSchriftOpt[0] );
  372.     Hilfe( "Eine der angegebenen Schriftarten wählen.", co.EingabeFarbe );
  373.  
  374.     if( (iWahl = Menue( pszSchriftart )) != ESCAPE )
  375.     {
  376.         /* Will der Benutzer den System-Schriftsatz, die anderen
  377.          * Schriftsätze aus dem Register nehmen.
  378.          */
  379.         if( iWahl == 7 )
  380.         {
  381.             _unregisterfonts();
  382.          SchriftenRegistriert = FALSCH;
  383.         }
  384.  
  385.         /* Will der Benutzer andere als den System-Schriftsatz,
  386.          * sich vergewissern, daß die Schriftsätze registriert sind.
  387.          */
  388.         else
  389.         {
  390.             if( !SchriftenRegistriert )
  391.             {
  392.           if(  _registerfonts( "*.FON" ) < 0 )
  393.                 {
  394.               FehlerMldg( "Konnte Schriftsätze nicht registrieren" );
  395.                     return;
  396.                 }
  397.                 else
  398.               SchriftenRegistriert = WAHR; /* Status auf registriert
  399.                                                     rücksetzen */
  400.             }
  401.  
  402.             /* Vorige Schriftsatz-Einstellung holen */
  403.             _getfontinfo( &fd );
  404.  
  405.             SchriftWahl( iWahl - 1, fd.pixheight );
  406.         }
  407.     }
  408.  
  409.     PopTitel();
  410. }
  411.  
  412. /*  SchriftWahl - Wählt Schriftsatz aus den Schriftsatz-Bibliothek.
  413.  *
  414.  *  Parameter: WelcheSchrift - Ein Mitglied der Gruppe [COURIER, HELV,
  415.  *                      TMS_RMN, MODERN, SCRIPT, ROMAN]
  416.  *             Hoch    - Erwünschte Texthöhe in Bildpunkten
  417.  */
  418.  
  419. void SchriftWahl( int WelcheSchrift, int Hoch )
  420. {
  421.     static char *SchriftIds[] =
  422.     {
  423.         "courier", "helv", "tms rmn", "modern", "script", "roman"
  424.     };
  425.     char SetCommand[21];
  426.  
  427.  
  428.     /* Den Befehl für Senden zu _setfont aufbauen. */
  429.  
  430.     sprintf( SetCommand, "t'%s'h%dw0b", SchriftIds[WelcheSchrift], Hoch );
  431.  
  432.     if( _setfont( SetCommand ) )
  433.     {
  434.         _outtext( "Konnte Schriftsatz nicht einrichten auf " );
  435.         _outtext( SchriftIds[WelcheSchrift] );
  436.         _outtext( "." );
  437.         getch();
  438.     }
  439. }
  440.  
  441.  
  442. /*  DiagrammFenster - Holt Information über Diagrammfenster.
  443.  *
  444.  *  Parameter: Keine
  445.  */
  446. void DiagrammFenster()
  447. {
  448.     int iWahl;
  449.  
  450.     PushTitel( pszDiagrammFenster[0] );
  451.     while( (iWahl = Menue( pszDiagrammFenster )) != ESCAPE )
  452.     {
  453.  
  454.         /* Fensteroptionen holen.  */
  455.         switch( iWahl )
  456.         {
  457.  
  458.             case 1:
  459.                 /* Fenstergröße holen.  */
  460.                 FensterFormat( &ce.chartwindow );
  461.                 break;
  462.  
  463.             case 2:
  464.                 /* Frage nach Hintergrundfarbe.  */
  465.           Hilfe( "Zahl im Bereich 0 - 15 eingeben", co.EingabeFarbe );
  466.                 ce.chartwindow.background =
  467.               EingabeInt( "Hintergrundfarbe? ", ce.chartwindow.background, 0, 15 );
  468.                 break;
  469.  
  470.             case 3:
  471.  
  472.                 /* Randoptionen holen.  */
  473.                 Rand( &ce.chartwindow );
  474.  
  475.         }
  476.     }
  477.     PopTitel();
  478. }
  479.  
  480. /*  DatenFenster - Information über Datenfenster holen.
  481.  *
  482.  *  Parameter: Keine
  483.  */
  484. void DatenFenster()
  485. {
  486.     int iWahl;
  487.  
  488.     PushTitel( pszDatenFenster[0] );
  489.     while( (iWahl = Menue( pszDatenFenster )) != ESCAPE )
  490.     {
  491.  
  492.         /* Datenfenster0Menüoptionen holen.  */
  493.         switch( iWahl )
  494.         {
  495.  
  496.             case 1:
  497.                 /* Anfrage nach Hintergrundfarbe.  */
  498.           Hilfe( "Zahl im Bereich 0 - 15 eingeben", co.EingabeFarbe );
  499.                 ce.datawindow.background =
  500.               EingabeInt( "Hintergrundfarbe? ", ce.datawindow.background, 0, 15 );
  501.                 break;
  502.  
  503.             case 2:
  504.                 /* Randoptionen holen.  */
  505.                 Rand( &ce.datawindow );
  506.                 break;
  507.  
  508.         }
  509.     }
  510.     PopTitel();
  511. }
  512.  
  513. /*  SchriftOptionen - Hier kann der Benutzer den zur Darstellung
  514.  *  benutzten Schriftsatz ändern.
  515.  *
  516.  *  Parameter: Keine
  517.  */
  518.  
  519. void SchriftOptionen()
  520. {
  521.     int iWahl;
  522.     int iZeichenGroesse;
  523.     int iArtIndex;
  524.     struct _fontinfo fd;
  525.  
  526.     /* Menüwahl holen und entsprechend Achsenmenü aufrufen. */
  527.     PushTitel( pszSchriftOpt[0] );
  528.  
  529.     while( (iWahl = Menue( pszSchriftOpt )) != ESCAPE )
  530.     {
  531.         /* Gegenwärtige Schriftsatzinformation holen. */
  532.         _getfontinfo( &fd );
  533.  
  534.         switch( iWahl )
  535.         {
  536.             /* Schriftart ändern.  */
  537.             case 1:
  538.                 AndereSchrift();
  539.                 break;
  540.  
  541.             /* Ändere Buchstabengröße. */
  542.             case 2:
  543.           iZeichenGroesse = EingabeInt( "Buchstabengröße eingeben. ",
  544.                            fd.pixheight, 8, 128 );
  545.  
  546.                 for( iArtIndex = 0; iArtIndex < 6; ++iArtIndex )
  547.               if( !strcmpi( fd.facename, pszSchriftart[iArtIndex + 1] ) )
  548.                         break;
  549.  
  550.           SchriftWahl( iArtIndex, iZeichenGroesse );
  551.                 break;
  552.  
  553.             default:
  554.                 break;
  555.         }
  556.     }
  557.     PopTitel();
  558. }
  559.  
  560. /*  Ausrichten - Holt Ausrichtinformation für Überschriften.
  561.  *
  562.  *  Parameter: ptt - Zeiger zur Variablen titletype
  563.  */
  564. void Ausrichten( titletype *ptt )
  565. {
  566.     int iWahl;
  567.  
  568.     PushTitel( pszAusrichten[0] );
  569.     iWahl = Menue( pszAusrichten );
  570.     switch( iWahl )
  571.     {
  572.  
  573.         /* Set justification.  */
  574.         case 1:
  575.         case 2:
  576.         case 3:
  577.             ptt->justify = iWahl;
  578.     }
  579.     PopTitel();
  580. }
  581.  
  582. /*  Beschriftung - Fragt, ob Beschriftung erwünscht ist;
  583.  *  falls ja, werden Beschriftungsoptionen geholt.
  584.  *
  585.  *  Parameter: Keine
  586.  */
  587. void Beschriftung()
  588. {
  589.     int iWahl;
  590.  
  591.     /* Ist Beschriftung erwünscht?  */
  592.     iWahl = BlankMenue( "Beschriftung", "Beschriftung", "Keine Beschriftung" );
  593.     switch( iWahl )
  594.     {
  595.         case 1:
  596.             /* Wenn Beschriftung, Kennung setzen und Optionen holen.  */
  597.          ce.legend.legend = WAHR;
  598.             PushTitel( pszBeschriftungFenster[0] );
  599.             do
  600.             {
  601.                 iWahl = Menue( pszBeschriftungFenster );
  602.                 switch( iWahl )
  603.                 {
  604.  
  605.                     case 1:
  606.                         /* Beschriftungsstelle holen.  */
  607.                         BeschriftungStelle();
  608.                         break;
  609.  
  610.                     case 2:
  611.                         /* Anfrage nach Beschriftungsfarbe.  */
  612.                Hilfe( "Zahl im Bereich 0 - 15 eingeben.", co.EingabeFarbe );
  613.                         ce.legend.textcolor =
  614.                    EingabeInt( "Textfarbe? ", ce.legend.textcolor, 0, 15 );
  615.                         break;
  616.  
  617.                     case 3:
  618.                         /* Autom. oder manuelle Größeneinstellung holen.  */
  619.                PushTitel( "Automatisch" );
  620.                         iWahl = Menue( pszAuto );
  621.  
  622.                         /* autosize-Kennung einrichten oder löschen. Wurde
  623.                          * manuelle Größeneinstellung bestimmt, Beschrif-
  624.                          * tungsgröße holen.
  625.                          */
  626.                         switch( iWahl )
  627.                         {
  628.                             case 1:
  629.                     ce.legend.autosize = WAHR;
  630.                                 break;
  631.  
  632.                             case 2:
  633.                     ce.legend.autosize = FALSCH;
  634.                                 FensterFormat( &ce.legend.legendwindow );
  635.                         }
  636.                         PopTitel();
  637.                         break;
  638.  
  639.               case 4:
  640.                /* Anfrage nach Hintergrundfarbe.  */
  641.                Hilfe( "Zahl im Bereich 0 - 15 eingeben.", co.EingabeFarbe );
  642.                         ce.legend.legendwindow.background =
  643.                    EingabeInt( "Hintergrundfarbe? ", ce.legend.legendwindow.background, 0, 15 );
  644.                         break;
  645.  
  646.                     case 5:
  647.                         /* Randoptionen holen für Beschriftungsfenster.  */
  648.                         Rand( &ce.legend.legendwindow );
  649.                 }
  650.  
  651.             } while( iWahl != ESCAPE );
  652.             PopTitel();
  653.             break;
  654.  
  655.         case 2:
  656.             /* Ist keine Beschriftung erwünscht, Kennung löschen.  */
  657.          ce.legend.legend = FALSCH;
  658.  
  659.     }
  660.     PopTitel();
  661. }
  662.  
  663. /*  BeschriftungStelle - Holt Option für Plazierung der Beschriftung.
  664.  *
  665.  *  Parameter: Keine
  666.  */
  667. void BeschriftungStelle()
  668. {
  669.     int iWahl;
  670.  
  671.     /* Beschriftungsplazierung holen.  */
  672.     PushTitel( pszStelle[0] );
  673.     iWahl = Menue( pszStelle );
  674.     switch( iWahl )
  675.     {
  676.  
  677.         case 1:
  678.             ce.legend.place = _PG_RIGHT;
  679.             break;
  680.  
  681.         case 2:
  682.             ce.legend.place = _PG_BOTTOM;
  683.             break;
  684.  
  685.         case 3:
  686.             ce.legend.place = _PG_OVERLAY;
  687.     }
  688.     PopTitel();
  689. }
  690.  
  691. /*  BschirmModus - Holt neuen Bildschirmmodus.
  692.  *
  693.  *  Parameter: Keine
  694.  */
  695. void BschirmModus()
  696. {
  697.     int iMode, i;
  698.     char szTmp[80], szHlp[80];
  699.     static int iLegal[5][11] =
  700.     {
  701.         { 3, 4, 5, 6 },
  702.         { 4, 4, 5, 6, 64 },
  703.         { 4, 4, 5, 6, 19 },
  704.         { 7, 4, 5, 6, 13, 14, 15, 16 },
  705.         { 10, 4, 5, 6, 13, 14, 15, 16, 17, 18, 19 }
  706.     };
  707.     int iAdapter;
  708.  
  709.     PushTitel( "Modus" );
  710.  
  711.     /* Entsprechende Hilfezeile für Adapter anzeigen.  */
  712.     switch( vc.adapter )
  713.     {
  714.         case _HGC:
  715.             PopTitel();
  716.             return;
  717.         case _CGA:
  718.             iAdapter = 0;
  719.             break;
  720.         case _OCGA:
  721.             iAdapter = 1;
  722.             break;
  723.         case _MCGA:
  724.             iAdapter = 2;
  725.             break;
  726.         case _EGA:
  727.         case _OEGA:
  728.             if( vc.adapter == _MONO )
  729.             {
  730.                 PopTitel();
  731.                 return;
  732.             }
  733.             else
  734.                 iAdapter = 3;
  735.             break;
  736.         case _VGA:
  737.         case _OVGA:
  738.             iAdapter = 4;
  739.             break;
  740.     }
  741.  
  742.     /* Hilfezeile anzeigen (enthält die zulässigen Einstellungen für
  743.      * den Adapter im Computer des Benutzers.
  744.      */
  745.     for( iMode = 0, szHlp[0] = '\0'; iMode <= iLegal[iAdapter][0]; ++iMode )
  746.     {
  747.         if( iMode == 0 )
  748.          strcpy( szTmp, "Eingabe " );
  749.         else if( iMode < iLegal[iAdapter][0] )
  750.             sprintf( szTmp, "%d, ", iLegal[iAdapter][iMode] );
  751.         else
  752.          sprintf( szTmp, "oder %d", iLegal[iAdapter][iMode] );
  753.         strcat( szHlp, szTmp );
  754.     }
  755.  
  756.     WrtForm( 18 );
  757.     Hilfe( szHlp, co.EingabeFarbe );
  758.  
  759.     /* Anfrage nach Bildschirmmodus. */
  760.     for( ;; )
  761.     {
  762.      iMode = EingabeInt( "Modus? ", si.mode, 1, 64 );
  763.         for( i = 1; i <= iLegal[iAdapter][0]; ++i ) /* Wert zulässig??    */
  764.             if( iMode == iLegal[iAdapter][i] )  /* Wird passender Wert    */
  765.                 break;                          /* gefunden, for-Schleife */
  766.         if( iMode == iLegal[iAdapter][i] )      /* beenden; paßt der Wert */
  767.             break;                              /* do-Schleife beenden    */
  768.      else                                    /* sonst SIGNAL, und um     */
  769.          putchar( SIGNAL );                    /* richtigen Daten bitten */
  770.     }
  771.  
  772.     PopTitel();
  773.     if( SetGraphMode( iMode ) )
  774.         _setvideomode( _DEFAULTMODE );
  775.     else
  776.      ZeigeFehler( _PG_BADSCREENMODE );
  777.  
  778.     /* Erzwingt neue Größeneinstellung dieses Diagramms, indem die
  779.      * Rechteck-Werte für die Diagramm- und Datenfenster auf Null
  780.      * rückgesetzt werden.
  781.      */
  782.     ce.chartwindow.x1 = ce.chartwindow.x2 = ce.chartwindow.y1 =
  783.         ce.chartwindow.y2 = 0;
  784.     ce.datawindow = ce.chartwindow;
  785. }
  786.  
  787. /*  TitelOpt - Holt Titeloptionen.
  788.  *
  789.  *  Parameter: ptt - Zeiger zur Variablen titletype
  790.  */
  791. void TitelOpt( titletype *ptt )
  792. {
  793.     int iWahl;
  794.  
  795.     PushTitel( pszTitelOpt[0] );
  796.     do
  797.     {
  798.         iWahl = Menue( pszTitelOpt );
  799.         switch( iWahl )
  800.         {
  801.  
  802.             case 1:
  803.                 /* Aufforderung zu Eingabe des Titeltextes.  */
  804.           Hilfe( "Maximal 70 Zeichen lang.", co.EingabeFarbe );
  805.           EingabeString( "Text eingegeben: ", ptt->title );
  806.                 break;
  807.  
  808.             case 2:
  809.                 /* Frage nach Titelfarbe.  */
  810.           Hilfe( "Zahl im Bereich 0 - 15 eingeben.", co.EingabeFarbe );
  811.                 ptt->titlecolor =
  812.                     EingabeInt( "Titelfarbe? ", ptt->titlecolor, 0, 15 );
  813.                 break;
  814.  
  815.             case 3:
  816.                 /* Ausrichtoption holen.  */
  817.                 Ausrichten( ptt );
  818.         }
  819.      LschHilfe();
  820.  
  821.     } while( iWahl != ESCAPE );
  822.     PopTitel();
  823. }
  824.  
  825. /*  Titel - Verwaltet Menüs für Haupt- u. Nebentitel.
  826.  *
  827.  *  Parameter: Keine
  828.  */
  829. void Titel()
  830. {
  831.     int iWahl;
  832.  
  833.     PushTitel( pszTitel[0] );
  834.     do
  835.     {
  836.         iWahl = Menue( pszTitel );
  837.         switch( iWahl )
  838.         {
  839.  
  840.             case 1:
  841.              /* Menütitel einrichten und Optionen für Haupttitel holen.*/
  842.                 pszTitelOpt[0] = "Haupttitel";
  843.                 TitelOpt( &ce.maintitle );
  844.                 break;
  845.  
  846.             case 2:
  847.              /* Menütitel einrichten und Optionen für Nebentitel holen.*/
  848.                 pszTitelOpt[0] = "Nebentitel";
  849.                 TitelOpt( &ce.subtitle );
  850.         }
  851.     } while( iWahl != ESCAPE );
  852.     PopTitel();
  853. }
  854.  
  855. /*  Fenster - Wählt Diagramm- oder Datenfenster und holt dementsprechende
  856.  *  Optionen.
  857.  *
  858.  *  Parameter: Keine
  859.  */
  860. void Fenster()
  861. {
  862.     int iWahl;
  863.  
  864.     PushTitel( pszFenster[0] );
  865.     do
  866.     {
  867.  
  868.         /* Fenster wählen und dafür Optionen holen.  */
  869.         iWahl = Menue( pszFenster );
  870.         switch( iWahl )
  871.         {
  872.  
  873.             case 1:
  874.                 DiagrammFenster();
  875.                 break;
  876.  
  877.             case 2:
  878.                 DatenFenster();
  879.  
  880.         }
  881.     } while( iWahl != ESCAPE );
  882.     PopTitel();
  883. }
  884.  
  885. /*  FensterFormat - Holt Koordinaten für Position und Größe des Fensters.
  886.  *
  887.  *  Parameter: pwt - Zeiger zur Variablen windowtype
  888.  */
  889. void FensterFormat( windowtype *pwt )
  890. {
  891.     int iWahl;
  892.  
  893.     /* Get window size settings.  */
  894.     PushTitel( pszGroesse[0] );
  895.     do
  896.     {
  897.     /* Frage nach Werten für Fensterrand oben, unten, links oder rechts.  */
  898.      iWahl = Menue( pszGroesse );
  899.         switch( iWahl )
  900.         {
  901.  
  902.             case 1:
  903.                 Hilfe( "Fenster-Oberrand in Bildpunkten:", co.EingabeFarbe );
  904.                 pwt->y1 = EingabeInt( "Oben? ", pwt->y1, 0, si.yMax );
  905.                 break;
  906.  
  907.             case 2:
  908.                 Hilfe( "Rand Links in Bildpunkten:", co.EingabeFarbe );
  909.                 pwt->x1 = EingabeInt( "Links? ", pwt->x1, 0, si.xMax );
  910.                 break;
  911.  
  912.             case 3:
  913.                 Hilfe( "Fenster-Unterrand in Bildpunkten:", co.EingabeFarbe
  914. );
  915.                 pwt->y2 = EingabeInt( "Unten? ", pwt->y2, 0, si.yMax );
  916.                 break;
  917.  
  918.             case 4:
  919.                 Hilfe( "Rand Rechts in Bildpunkten:", co.EingabeFarbe );
  920.                 pwt->x2 = EingabeInt( "Rechts? ", pwt->x2, 0, si.xMax );
  921.         }
  922.     } while( iWahl != ESCAPE );
  923.     PopTitel();
  924. }
  925.