4. DOS-Anwendung mit MSVC++ erstellen, ist das möglich? (Alternativen?)

DOS-Anwendung mit MSVC++ erstellen, ist das möglich? (Alternativen?)

  • C

    Das soll ab WinXP aufwärts lauffähig sein.

    Ich hab noch Borland (Heimsoeth) Turbo C 2.0, würde aber gerne einen aktuellen Compiler nutzen, das Text-Mode (oder Konsolen) Anwendungen nur ein kleiner Ausschnitt meiner Arbeit mit C sind.

    0
  • ?

    Die neueren Betriebssysteme versuchen weitgehend die direkte Programmierung, z.B. mit Interrupts, abzublocken um den Betriebssystemkern stabil zu halten. Ausserdem war um 1990 per Interrupt in den Grafikspeicher schreiben relativ langsam. Schneller ging es, wenn man direkt in den Grafikspeicher schrieb. Aber leider kochten, mit Ausnahme von den ersten 13 Videomodi fast jeder Hersteller sein eigenes Süppchen. Das heisst, sollte ein Punkt in einer Auflösung grösser als 800 x 600 farbig auf dem Bildschirm erscheinen, musste ein auf die jeweilige Grafikkarte abgestimmter Quelltext geschrieben werden.

    Umfangreiche Menus im Textmode sind heute sehr selten geworden, meist nutzt man heute dafür Frameworks.

    MfG f.-th.

    0
  • B

    Geschwindigkeitsprobleme bei Pulldown-Menüs? Och nee...

    Alte Textmodi, zumindest Emulationen davon, müßtest Du z.B. mit der Allegro-Bibliothek hinbekommen. Die wrappt Dir auch die ganze Win-API weg und stellt eine kleine GUI mit Pulldownmenüs zur Verfügung. Alle Graphikoperationen sind einfache C-Funktionen und Du legst mit main() los.
    Ich verwende sie auch heute noch zusammen mit MSVC 8.0, eben wegen ihrer Einfachheit.
    http://www.allegro.cc - es reicht, wenn Du Dir das Binary-Paket der 4.2.2-Version für den MSVC holst.

    0
  • C

    Danke für die Antworten.

    Die Probleme mit den div. Grafikkarten sind mir wohl bekannt, programmiere ich doch seit 1988 auf dem PC (ab 1983 auf ATARI 800XL und anderen HomeComputern)
    Die Geschwindigkeitsprobleme beim Zugriff auf den Bildschirmspeicher per Interrupt kenn ich auch noch, daher habe ich mit Turbo Pascal und Assembler immer direkt im Bildschirmspeicher rumgefuscht, das hat allerdings nach dem aussterben der Grafikkarten ála Tseng ET4000 / Trident 8900 aufgehört.

    Längere Zeit hab ich dann gar nicht mehr programmiert. Vor zwei Jahren habe ich dann wieder angefangen, der Einfachheit halber allerdings mit Visual Basic 2008 Express.
    Nach dem ich mich wieder "Eingelebt" habe, habe ich vor einiger Zeit angefangen mich mit C zu beschäftigen.

    Von Allegro habe ich in verschiedenen Zusammenhängen schon mal was gehört und werde es mir mal näher anschauen. Bisher habe ich nur einmal die SDL verwendet (auch in VB.net). Hast du evtl. ein Code-Beispiel zur Hand, wo ein Text-Mode Emulation verwendet wird, damit ich mir das einmal ansehen kann?

    Ansonsten quäle ich mich grad mit den Console-Funktionen der WinAPI rum, die ja alles andere als komfortabel zu sein scheinen. High-Speed scheint damit unmöglich zu sein.
    OK, die Rechner sind heute viel schneller, aber das ist ja kein Grund "schlampig" zu werden.

    Gruß,
    CenTroniX

    0
  • B

    Allegro startet von Haus aus im Textmode - also mit Ausgabe auf Konsole.
    Hier ein kleines Code-Beispiel mit dem er einen Graphikmodus setzen will, wenn das nicht gelingt, schaltet er (auch logisch) in den Textmodus, schreibt eine Message und steigt aus. Charakteristisch ist END_OF_MAIN, was Dir letztlich die ganze WinAPI erspart. Den Includepfad für den Header angeben, alleg.lib in den Linker mit einbinden und für den Ablauf die DLL dazulegen, das war's dann.

    Muß meine Aussage bezuglich der GUI einschränken - ich denke, die läuft nur in einem Graphikmodus. Aber Du wirst sehr schnell merken, daß es sich in den Graphikmodi recht komfortabel arbeiten läßt. Textmode ist vermutlich wirklich nur noch für's Anzeigen des BIOS da 😉

    #include <allegro.h>

int main()
{
   allegro_init();
   if (set_gfx_mode(GFX_SAFE, 640, 480, 0, 0) != 0) {
      set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
      allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
      return 1;
   }
   set_palette(desktop_palette);
   clear_to_color(screen, makecol(255, 255, 255));
   text_mode(makecol(255, 255, 255));

   readkey();
   return 0;
}
END_OF_MAIN();

    Ich weiß nicht, ob es so einfach mit der SDL geht, aber die kommt hier eigentlich auch meistens recht gut an.

    Im FAQ liegt auch noch ein Artikel über eine Improved Console:
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-131915.html

    p.s.:
    Ich weiß immer noch nicht, was Du unter Highspeed verstehst. Heutige Programme produzieren in hochauflösenden Graphikmodi Frames/sec., die von vertikaler Synchronisation kaum noch dargestellt werden können, und das menschliche Auge hat auch noch eine gewisse Trägheit.
    Wenn alles im windowed mode im normalen Windows Screen läuft, dann wird natürlich alles emuliert und da geht Speed verloren. Allegro geht aber auch auf DirectX rüber wenn gewünscht - nur eine Frage des aktivierten Graphikmodus.

    0
  • B

    Ich hänge Dir gerade nochmal das Sample für andere Graphikmodi (und Texte in Graphikmodi) dran. Kannst ja mal schauen.
    Die Examples sind dabei, wenn Du den Allegro-Sourcecode holst, den Du aber nicht übersetzen solltest, das wird diffizil. Nutze die fertigen Binaries, die es extra gibt.

    void test(int colordepth)
{
   PALETTE pal;
   int x;

   /* set the screen mode */
   set_color_depth(colordepth);

   if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) != 0)
      return;

   /* in case this is a 256 color mode, we'd better make sure that the
    * palette is set to something sensible. This function generates a
    * standard palette with a nice range of different colors...
    */
   generate_332_palette(pal);
   set_palette(pal);

   acquire_screen();

   clear_to_color(screen, makecol(0, 0, 0));

   text_mode(-1);
   textprintf(screen, font, 0, 0, makecol(255, 255, 255), "%d bit color...", colordepth);

   /* use the makecol() function to specify RGB values... */
   textout(screen, font, "Red",     32, 80,  makecol(255, 0,   0  ));
   textout(screen, font, "Green",   32, 100, makecol(0,   255, 0  ));
   textout(screen, font, "Blue",    32, 120, makecol(0,   0,   255));
   textout(screen, font, "Yellow",  32, 140, makecol(255, 255, 0  ));
   textout(screen, font, "Cyan",    32, 160, makecol(0,   255, 255));
   textout(screen, font, "Magenta", 32, 180, makecol(255, 0,   255));
   textout(screen, font, "Grey",    32, 200, makecol(128, 128, 128));

   /* or we could draw some nice smooth color gradients... */
   for (x=0; x<256; x++) {
      vline(screen, 192+x, 112, 176, makecol(x, 0, 0));
      vline(screen, 192+x, 208, 272, makecol(0, x, 0));
      vline(screen, 192+x, 304, 368, makecol(0, 0, x));
   }

   textout_centre(screen, font, "<press a key>", SCREEN_W/2, SCREEN_H-16, makecol(255, 255, 255));

   release_screen();

   readkey();
}

int main()
{
   allegro_init();
   install_keyboard(); 

   /* try each of the possible color depths... */
   test(8);
   test(15);
   test(16);
   test(24);
   test(32);

   return 0;
}

END_OF_MAIN();
    0
  • C

    Erst einmal Danke für die Beispiele.

    Was ich mit HighSpeed meine:

    Wenn ich z.b. im DOS-TextModus eine Pulldownmenü erstelle und die Auswahlmarke durch Veränderung der Hintergrundfarbe des gewählten Eintrages realisiere, dann ich das sehr schnell in direkt möglich.

    Hier ein kleines Beispiel (Prinzip-Code):

    struct EinZeichen {
  BYTE Attribut;
  UCHAR Zeichen;
}

EinZeichen *VideoMem[25][80];  //Array für den Bildschirmspeicher [Zeile][Spalte]
VideoMem = 0xb8000 ;  //Adresse des Bildschirmspeichers

short X = 45;
short Y = 3;
short Count = 10;

for (short C=0; C < Count - 1; ++C) {
  (*VideoMem[Y][X + C]).Attribut = 0xF2;  //Vordergrund- und Hintegrundfarbe setzen;
}

    Ich Assembler ginge das auch noch direkter/schneller.

    Mir ist klar, das man das so in einer Win32-Konsolenanwendung nicht machen kann.
    Im Moment probiere ich mit ReadConsoleOutputAttribute und WriteConsoleOutputAttribute (WinAPI) rum.

    Bei Allegro, SDL usw. muss ich die ganze Zeichenkette incl. Hintergrund neu zeichnen, was natürlich viel mehr Zeit braucht, als das direkte ändern eines Attribut-Bytes im Bildschirmspeicher.

    Ich suche eben ein Möglichkeit, das ähnlich einfach und elegant hin zu bekommen wie früher. Kann sein, das ich damit total auf dem Holzweg bin.

    0
  • B

    Jener 'Holzweg' ist mittlerweile in der Fußgängerzone einer recht groß gewordenen Stadt 😉

    0
  • C

    Naja, dann werde ich mir mal Allegro näher ansehen und einen Schritt in die Gegenwart wagen. Hab sogar noch ein Buch zu C und Allegro gefunden - in meinem Bücheregal.

    0
  • B

    Bin möglicherweise sogar noch ein wenig älter, klebe genauso an alten Dingen, und es hat mir sehr weh getan als Shade mir eingehämmert hat das DOS tot! tot! tot! ist. 😉
    Wenn Du aber behutsam mit C anfangen willst, und mit nicht allzu viel modernem Overhead erschlagen werden willst, dann könnte Allegro ideal sein.
    Dabei ist Allegro alles andere als out (auch wenn es ebenfalls noch aus dem letzten Jahrtausend kommt). Für die neue 5er-Version lassen sie sich sehr viel Zeit und wollen AllegroGL mit einbinden - und ein paar Python-Dinge habe ich da auch schon drin gesehen.
    Wenn Du mal hängst und eine Frage hast, die ich hier in der Flut der Postings übersehe - normalerweise gibt es dann Leute, die mich in den Hintern treten, dass da noch was offen ist 😉

    0
Anmelden zum Antworten