Quelltext /~heha/hs/graphwin.zip/graphwin.c

#pragma option -d -WS -k-
/* -d	doppelte Strings zusammenfassen
   -WS	Windows-Applikation, "intelligente" Rückrufe (via SS==DS)
   -k-	kein Standard-Stapelrahmen
 */
#include <windows.h>
#include <string.h>	//memset
#include <stdlib.h>	//exit
#include <dos.h>	//_argc, _argv
#include "graphwin.h"	//anstelle <graphics.h>
/* Wrapper für die GRAPHICS.LIB ... */

/* zurzeit: fest für VGA-Auflösung, alle 3 Modi */

/* Interne Arbeisweise, Schlüssel-Funktionen:
 > Eine Bitmap verkörpert die Zeichenfläche, notwendig zur Restaurierung
   teilweise verdeckter Flächen (Notwendigkeit bei allen Fenster-Systemen)
 > Im DirectDraw-Modus wird gleichzeitig in das Fenster gezeichnet;
   ansonsten wird die Bitmap bei "Arbeitspausen" hineinkopiert
 > Die Funktion gdiproc() ist eine universelle Hülle für solche Doppelt-
   und (später?) Dreifachzeichnungen
 > Eine Reihe GDI-Objekte (Stift, Schrift, Hintergrund) wird stets parat
   gehalten und per ChangeGdiObject() in allen Kontexten gewechselt
 > Bei Moduswechseln wird die Fenstergröße an die dargestellte Pixelzahl
   angepasst, und zwar bei WM_GetMinMaxInfo(!) 

   Bekannte Unzulänglichkeiten und Fehler:
 - Fehlende Emulation der Palette (Win95 DibDraw erforderlich??) 
 - Inkorrekte Emulation der Hintergrundfarbe (wegen Palette im Original)
 - Vorgabe des Fensters auf VGA-VGAHI (besser: Textmodus)
 - Dürftige Emulation der CONIO (war nicht ursprünglicher Gegenstand)
 - Fenstergrößen-Einstellung noch ohne Zoom und/oder Rollbalken
 - Windows-Füllmuster unterscheiden sich von denen der GRAPHICS.LIB
 - Emulation großer Aspektverhältnisse (z.B. VGALO) ist ebenso verzerrt
 - Keine Windows-Fonts verfügbar, die wie die .CHR-Schriften aussehen
 - Kein Signalhandler-Aufruf beim beabsichtigten Schließen des Fensters
 - Projekt sollte mit "Warnung bei doppelten Symbolen AUS" übersetzt werden!

   Bereits implementierte "Features":
 + Hauptprogramm startet mit main(), nicht mit WinMain()
 + Verwendung des "originalen" DOS-Zeichensatzes für identisches Aussehen
 + Einige Textmodus-typische Funktionen, insbesondere clrscr()
 + Caret- (=Schreibmarken-) Unterstützung - hat EASYWIN auch
 + Unterstützung von Cursor- und Funktionstasten (hat EASYWIN NICHT!)
 + Saubere OEM-Zeichensatz-Unterstützung, auch bei den Tastencodes
 + Sinus-Tabelle (sollte künftig auch extern zugreifbar sein)
 + Direktes Zeichnen sowohl ins Fenster als auch in Hintergrund-Bitmap,
   ermöglicht Beobachtung des Bildaufbaus (="DirectDraw")
 + Indirektes Zeichnen mit Aktualisierung (nur) bei Tastaturabfragen und
   yield() ist schneller, bisweilen schneller als DOS
 + Ganzzahlige Vergrößerung ist vorgesehen
 + Warnung beim "Killen" des Programms, Meldungstext auf deutsch umstellbar
 + Automatisches Schließen des Fensters bei Programmende, wenn nichts
   auf dem Bildschirm steht

   Evtl. vorgesehen:
 * "Dritter Mitschnitt" in Speicher-Metadatei ermöglicht das Neuzeichnen bei
   wechselnder Hintergrundfarbe und Zwischenablage-Export im Vektorformat
 * Durchgängige CONIO-Unterstützung
 * Unterstützung von "bunten" ANSI-Sequenzen

   haftmann#software, 08/02
   Bugfix 12/02 bei initgraph() sowie CrtWindow in .H-Datei
 */

/* Alle Variablen initialisiert Windows mit 0 */
BOOL	CanClose;

//HANDLE	ghInstance;
HWND	CrtWindow;
static HDC	ghScreenDC,ghActiveDC,ghVisualDC;
static HBITMAP ghNullBitmap;	// für DC-Freigabe erforderlich
static HBITMAP	pages[4];	// mehr als 4 Seiten hat kein Modus
/* Die Bitmaps haben die Auflösung des Windows-Bildschirms,
   für maximale Geschwindigkeit von BitBlt() */
static int activepage,visualpage;
int scale=1;		// für vergrößerte Darstellung, später POINT
static int width,height,numpages,colors;
static struct textsettingstype	gTextSettings;
static struct usercharsizetype {
   int multx,divx,multy,divy; }	gUserCharSize={1,1,1,1};
static struct viewporttype	gViewport;	// für Viewport-bezogene Funktionen
static struct linesettingstype	gLineSettings;
static struct arccoordstype	gArcCoords;
static struct palettetype	gDefaultPalette,gPalette;
static struct fillsettingstype	gFillSettings;
static int gGraphResult;
static int gGraphDriver;	// 0=Textmodus, 1..9,10=CGA..VGA,PC3270
static int gGraphMode;		// je nach GraphDriver
static int gInGraphMode;	// entscheidet über Cursor-Darstellung
static int gColor,gBkColor;	// Farb-Indizes (0..15)
static POINT gAspect;		// Seitenverhältnis (setzbar!)
static char gDriverName[16]="GRAPHWIN";
static BYTE gFillPattern[13][8]={		// funktionieren noch nicht!
 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},	// EMPTY_FILL
 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},	// SOLID_FILL
 {0x00,0x00,0xFF,0x00,0x00,0x00,0xFF,0x00},	// LINE_FILL		---
 {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80},	// LTSLASH_FILL		///
 {0x03,0x06,0x0C,0x18,0x30,0x60,0xC0,0x81},	// SLASH_FILL		///
 {0x81,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03},	// BKSLASH_FILL		\\\ .
 {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01},	// LTBKSLASH_FILL	\\\ .
 {0x11,0x22,0x44,0x88,0x11,0x22,0x44,0x88},	// HATCH_FILL		///
 {0x11,0xAA,0x44,0xAA,0x11,0xAA,0x44,0xAA},	// XHATCH_FILL		XXX
 {0x01,0x02,0x04,0x08,0x80,0x40,0x20,0x10},	// INTERLEAVE_FILL	\/\ .
 {0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00},	// WIDE_DOT_FILL
 {0x00,0x66,0x66,0x00,0x00,0x66,0x66,0x00},	// CLOSE_DOT_FILL
 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};	// USER_FILL
static HPEN	ghPen,ghoPen;		// Linienfarbe (Standard:Weiß)
static HBRUSH	ghBrush,ghoBrush;	// Füllfarbe (Standard: Schwarz?}
static HFONT	ghFont,ghoFont;		// Schrift ("Terminal")
static HFONT	ghFont2;		// Aktuelle "Schönschrift" für outtextxy 
static COLORREF rgbpalette[MAXCOLORS+1]={
 0x000000L,0xC00000L,0x00C000L,0xC0C000L,
 0x0000C0L,0xC000C0L,0x0080C0L,0xC0C0C0L,
 0x808080L,0xFF8080L,0x80FF80L,0xFFFF80L,
 0x8080FFL,0xFF80FFL,0x80FFFFL,0xFFFFFFL};
static char *FontNames[5]={
 "Terminal",				// DEFAULT_FONT
 "Times New Roman",			// TRIPLEX_FONT
 "Small Fonts",				// SMALL_FONT
 "Arial",				// SANS_SERIF_FONT
 "MS Gothic"};				// GOTHIC_FONT


void far pascal yield(void) {
 MSG M;

 while (PeekMessage(&M, 0, 0, 0, PM_REMOVE)) {
  if (M.message==WM_QUIT) exit(255);
  TranslateMessage(&M);
  DispatchMessage(&M);
 }
}

void far pascal setwindowtitle(char far*title) {
 lstrcpyn(_WindowTitle,title,sizeof(_WindowTitle));
 SetWindowText(CrtWindow,title);
}

/* von EasyWin gekupfert: */
HANDLE	__hInstance;
HANDLE	__hPrev;
int	__cmdShow;
extern WORD  (*__ReadBufFPtr)(char *Buffer, WORD Count);
extern void  (*__WriteBufFPtr)(char *Buffer, WORD Count);
char	_WindowTitle[80];
char *	_InactiveTitle="(Inactive %s)";
char *	_KillWarning="Program is running!\nKill now?\n\n"
		     "(You may loose data from this application)";
static char	KeyBuffer[16];
static int	KeyCount;
static POINT	CharSize={8,16};// Größe der Zeichenzelle in Pixel
static POINT	FontSize={8,12};// Größe des verwendeten Fonts in Pixel
static POINT	FontCenter;	// zur Zentrierung der Zeichen in Zeichenzellen
static int	caret=2;	// Höhe des Cursors in Pixel
static BOOL	Changed;
static BOOL	CanTerminate;	// TRUE wenn Bildschirm leer
static BOOL	Reading;	// Caret im Textmodus zeigen
BOOL	_AutoTracking=TRUE;
BOOL	_CheckEOF=TRUE;
BOOL	_CheckBreak=TRUE;
BOOL	_DirectDraw=TRUE;
POINT	_Cursor;		// Schreibmarken-Position in Zeichenzellen
POINT	_ScreenSize;		// Fenster-Größe in Zeichenzellen

void pascal invalidate(void) {
 if (Changed) {
  InvalidateRect(CrtWindow,NULL,FALSE);
  Changed=FALSE;
 }
}

BOOL _KeyPressed(void) {
 invalidate();
//  CanTerminate=FALSE;		// Wenn etwas geschrieben wurde, Fenster nicht schließen!
 yield();
 return KeyCount;
}

static HANDLE cdecl gdiproc(FARPROC func,int argc,...) {
/* Allgemeine Kapsel von GDI-Zeichenfunktionen
 * argc enthält die Anzahl der folgenden int-Argumente
 * LONG- und FAR*-Argumente müssen in der Reihenfolge HIGH-LOW (verdreht)
 * übergeben werden
 *
 * Besondere Bits von argc:
 * Bit15: Keine sichtbaren Veränderungen, verzögertes blt wird unterdrückt.
 * Bit14: Bild ist leer, beendendes Programm darf das Fenster schließen
 *
 * Returnwert ist der von ghActiveDC, also von der Hintergrund-Bitmap
 * 
 * Wie zum Geier schreibt man in diesem Inline-Assembler ein Unterprogramm???
 */
 HANDLE retu;
 asm{ 	cld
	mov	ax,[ghActiveDC]
	 push	ax
	 lea	si,argc
	 lodsw
         mov	ah,0
	 xchg	cx,ax
         jcxz	l2
 }l1: asm{
	 lodsw
	 push	ax
	 loop	l1
 }l2: asm{
	 call	[func]
        mov	[retu],ax
	mov	ax,[visualpage]
	cmp	ax,[activepage]
        jne	exi		//niemals auf den Bildschirm!
	cmp	[_DirectDraw],0
	jz	le		//verzögert bltten
	mov	ax,[ghScreenDC]
 }sub: asm{
	 push	ax
	 lea	si,argc
	 lodsw
         mov	ah,0
	 xchg	cx,ax
         jcxz	l4
 }l3: asm{
	 lodsw
	 push	ax
	 loop	l3
 }l4: asm{
	 call	[func]
        jmp	exi
 }le:
  if (!(argc&0x8000)) Changed=TRUE;	//nur wenn zeichnende Operation
 exi:
 if (!(argc&0xC000)) CanTerminate=FALSE;// Wenn zeichnend und nicht leer 
 return retu;
}

static void _ShowCursor(void) {
/* Action nur im Textmodus! */
 if (gInGraphMode) return;
 CreateCaret(CrtWindow,0,CharSize.x*scale,caret*scale);
 SetCaretPos(_Cursor.x*CharSize.x*scale,((_Cursor.y+1)*CharSize.y-caret)*scale);
 ShowCaret(CrtWindow);
}

static void _HideCursor(void) {
/* Action nur im Textmodus! */
 if (gInGraphMode) return;
 HideCaret(CrtWindow);
 DestroyCaret();
}

static void _TrackCursor(void) {
/* Keine Action bei Fenster ohne Rollbalken */
}

int _ReadKey(void) {
 int readkey;

 _TrackCursor();
 if (!_KeyPressed()) {
  Reading=TRUE;  if (GetFocus()==CrtWindow) _ShowCursor();
  do; while (!_KeyPressed());
  Reading=FALSE; if (GetFocus()==CrtWindow) _HideCursor();
 }
 readkey=KeyBuffer[0];
 --KeyCount;
 memmove(KeyBuffer,KeyBuffer+1,KeyCount);
 return readkey;
}

static void pascal NewLine(void) {
 _Cursor.x=0;
 _Cursor.y++;
 if (_Cursor.y>=_ScreenSize.y) {
  _Cursor.y--;
  gdiproc((FARPROC)ScrollDC,10,0,-CharSize.y,0,0,0,0,0,0,0,0);
  gdiproc((FARPROC)PatBlt,6,0,_Cursor.y*CharSize.y,width,CharSize.y,
    HIWORD(BLACKNESS),LOWORD(BLACKNESS));
 }
}

static void pascal textout(char*buf,int slen) {
 POINT curs;
 RECT R;

 curs.x=_Cursor.x*CharSize.x;
 curs.y=_Cursor.y*CharSize.y;
 SetRect(&R,curs.x,curs.y,curs.x+CharSize.x*slen,curs.y+CharSize.y);
 if (!buf) slen=0;
 gdiproc((FARPROC)ExtTextOut,10,curs.x+FontCenter.x,curs.y+FontCenter.y,
   ETO_OPAQUE,HIWORD(&R),LOWORD(&R),_SS,LOWORD(buf),slen,0,0);
}

static void pascal PutText(char*buf,int slen) {
 textout(buf,slen);
 _Cursor.x+=slen;
 if (_Cursor.x>=_ScreenSize.x) NewLine();
}

void _WriteBuf(char *Buffer, WORD Count) {
// int slen;

/* {
  char b2[256];
  wvsprintf(b2,"CharSize=%d:%d",&CharSize);
  MessageBox(CrtWindow,b2,Buffer,0);
 } */
 gdiproc((FARPROC)SaveDC,0x8000);		//Viewport retten
 gdiproc((FARPROC)SetViewportOrg,0x8002,0,0);
 gdiproc((FARPROC)SelectClipRgn,0x8001,0);	//Falls vorhanden, Clipping weg
 while (Count>0) {
  switch (*Buffer) {
   case 13:	NewLine(); break;
   case 10:	break;
   case  9: {
    PutText(NULL,8-_Cursor.x%8);		//1..8 Leerzeichen
   }break;
   case  8: if (_Cursor.x>0) {
    --_Cursor.x;
    PutText(NULL,1);
    --_Cursor.x;
   }break;
   case  7:	MessageBeep(0); break;
   default:	PutText(Buffer,1);
  }
  ++Buffer;
  --Count;
 }
 if (_AutoTracking) _TrackCursor();
 gdiproc((FARPROC)RestoreDC,0x8001,-1);
}

void _WriteChar(char Ch) {
 _WriteBuf(&Ch,1);
}

WORD _ReadBuf(char *Buffer, WORD Count) {
/* realisiert einen einfachen Zeileneditor */
 unsigned char Ch;
 WORD I;

 I=0;
 do {
  Ch = _ReadKey();
  if (Ch==8) {		//Rückschritt
   if (I > 0) {
    --I;
    _WriteChar(8);
   }
  }else if (Ch>=32) {
   if (I<Count) {
    Buffer[I++]=Ch;
    _WriteChar(Ch);
   }
  }
 }while (!((Ch==13) || (_CheckEOF && (Ch==26))));
 if (I<Count-2) {
  Buffer[I++]=Ch;
  if (Ch==13) {
   Buffer[I++] = 10;
   _WriteChar(13);
  }
 }
 _TrackCursor();
 return I;
}

void _CursorTo(int x, int y) {
 _Cursor.x=max(0,min(x,_ScreenSize.x-1));
 _Cursor.y=max(0,min(y,_ScreenSize.y-1));
}

/* Ende EasyWin-gekupferte Sachen */

#define selobj(obj) gdiproc((FARPROC)SelectObject,0x8001,(obj))
#define setcol(proc,c) {COLORREF farbe=(c);\
 gdiproc((FARPROC)(proc),0x8002,HIWORD(farbe),LOWORD(farbe));}

static void pascal CheckPageLoaded(int page) {
/* Bitmap-Seiten werden bei Bedarf erzeugt */
 if (!pages[page]) {
  pages[page]=CreateCompatibleBitmap(ghScreenDC,width,height);
 }
}

static void pascal SetPages(int x,int y,int z,int c) {
/* erzeugt z Bitmap-Ebenen der Größe x*y der Farbtiefe c wie gewünscht */
 int i;
 if (ghNullBitmap) {
  SelectObject(ghActiveDC,ghNullBitmap);
  if (activepage!=visualpage) SelectObject(ghVisualDC,ghNullBitmap);
 }
 for (i=0; i<numpages; i++) {
  if (pages[i] && DeleteObject(pages[i])) pages[i]=0;
  if (i<z) pages[i]=CreateCompatibleBitmap(ghScreenDC,x,y);
 }
 activepage=0;
 visualpage=0;
 width=x;
 height=y;
 numpages=z;
 colors=c;
 if (z) {
  CheckPageLoaded(0);
  ghNullBitmap=SelectObject(ghActiveDC,pages[0]);	// 1. Ebene aktiv
/* Dummerweise kann man eine Bitmap nicht gleich in zwei Kontexte stellen! */
  clearviewport();
  SetWindowPos(CrtWindow,0,0,0,10000,10000,SWP_NOMOVE|SWP_NOZORDER);
 }
 FontCenter.x=(CharSize.x-FontSize.x)/2;
 FontCenter.y=(CharSize.y-FontSize.y)/2;
}

void far pascal internal_initgraph(int x, int y, int z, int c) {
 int i;
 gAspect.x=GetDeviceCaps(ghScreenDC,ASPECTX);
 gAspect.y=GetDeviceCaps(ghScreenDC,ASPECTY);
 gDefaultPalette.size=MAXCOLORS+1;
 for (i=0; i<=MAXCOLORS; i++) gDefaultPalette.colors[i]=i;
 gPalette=gDefaultPalette;
 SetPages(x,y,z,c);
 graphdefaults();
 gInGraphMode=TRUE;	// kein Cursor!
}

static HANDLE pascal ChangeGdiObject(HANDLE*ghandle,HANDLE nhandle) {
 HANDLE ret=selobj(nhandle);
 if (*ghandle==ret) DeleteObject(ret);
 *ghandle=nhandle;
 return ret;
}

static void pascal PenChange(void) {
//aufzurufen bei Änderung der Linienart, Linienstärke oder Vordergrundfarbe
 static int PenStyles[5]={
   PS_SOLID,PS_DOT,PS_DASHDOT,PS_DASH,PS_DASHDOTDOT};	//upattern nicht umsetzbar!
 ChangeGdiObject(&ghPen,CreatePen(
   PenStyles[gLineSettings.linestyle],
   gLineSettings.thickness,
   rgbpalette[gPalette.colors[gColor]]));
}

static void pascal CheckFont2(void) {
//Test und Laden Schönschrift-Font
/* Sehr wacklige Angelegenheit:
   Sehen die Fonts passend aus?
   Stimmen Größen und Abstände?
   UserCharSize sollte eingebaut werden! */
 if (!ghFont2) {
  if (gTextSettings.font) {
   ghFont2=CreateFont(gTextSettings.charsize*8,0/*gTextSettings.charsize*4*/,
   gTextSettings.direction?900:0,0,700,0,0,0,
   ANSI_CHARSET,0,0,0,0,
   FontNames[gTextSettings.font]);
  }else{
   ghFont2=CreateFont(8,8,0,
   gTextSettings.direction?900:0,0,0,0,0,
   OEM_CHARSET,0,0,0,0,
   FontNames[0]);
  }
 }
}

static void pascal Font2Change(void) {
//Bei Veränderungen den geladenen Font verwerfen
 if (ghFont2) {
  DeleteObject(ghFont2);
  ghFont2=0;
 }
}

static BOOL pascal NeedConvert(LPCSTR s) {
 if (!s) return FALSE;
 for (;*s;s++) {
  if ((BYTE)(*s)>=0x80) return TRUE;
 }
 return FALSE;
}

static void pascal MakeGdiObjects(void) {
 ghoPen=  ChangeGdiObject(&ghPen,  CreatePen(PS_SOLID,1,rgbpalette[15]));
 ghoBrush=ChangeGdiObject(&ghBrush,CreateSolidBrush(rgbpalette[15]));
 ghoFont= ChangeGdiObject(&ghFont, CreateFont(FontSize.y,FontSize.x,
   0,0,0,0,0,0,OEM_CHARSET,0,0,0,0,FontNames[0]));
 setcol(SetTextColor,rgbpalette[7]);	// grau wie BIOS
 setcol(SetBkColor,rgbpalette[0]);	// schwarz wie BIOS
 gdiproc(SetBkMode,0x8001,OPAQUE);
 _ScreenSize.x=width/CharSize.x;
 _ScreenSize.y=height/CharSize.y;
 gViewport.right=width-1;
 gViewport.bottom=height-1;
 gViewport.clip=1;
}

static void pascal DestroyGdiObjects(void) {
 ChangeGdiObject(&ghFont, ghoFont);
 ChangeGdiObject(&ghBrush,ghoBrush);
 ChangeGdiObject(&ghPen,  ghoPen);
 Font2Change();
}

/********************************************
 * Ersatz für EASYWIN- und CONIO-Funktionen *
 ********************************************/

void textmode(int newmode) {
 if (newmode==-1) return;
 FontSize.x=CharSize.x=8;
 FontSize.y=12;
 CharSize.y=16;
 _ScreenSize.y=25;
 if (newmode&64) {
  _ScreenSize.y=50;
  FontSize.y=CharSize.y=8;
  newmode&=~64;
 }
 _ScreenSize.x=80;
 switch (newmode) {
  case 0:
  case 1: _ScreenSize.x=40;
  FontSize.x=FontSize.y=CharSize.x=CharSize.y=16;
 }
 ChangeGdiObject(&ghFont,CreateFont(FontSize.y,FontSize.x,0,0,0,0,0,0,
   OEM_CHARSET,0,0,0,0,FontNames[0]));
 SetPages(_ScreenSize.x*CharSize.x,_ScreenSize.y*CharSize.y,1,16);
 gInGraphMode=FALSE;
}

void gotoxy(int x, int y) { _CursorTo(x-1,y-1); }

void clreol(void) {
 textout(NULL,_ScreenSize.x-_Cursor.x);
}

void clrscr(void) {
 gdiproc((FARPROC)PatBlt,0x4006,0,0,width,height,
   HIWORD(BLACKNESS),LOWORD(BLACKNESS));
 CanTerminate=TRUE;		// Da ist nichts mehr zu sehen
}

void _setcursortype(int cur_t) {
 switch (cur_t) {
  case 0: caret=0;		// _NOCURSOR
  case 1: caret=CharSize.y;	// _SOLIDCURSOR
  case 2: caret=2;		// _NORMALCURSOR
 }
}

void _InitEasyWin(void) {}	// gar nichts tun!

/************************************
 * Hilfsfunktionen für GRAPHICS.LIB *
 ************************************/

static unsigned char sintab[91]={
 0, 4, 9, 13, 18, 22, 27, 31, 35, 40, 44, 49, 53, 57, 62, 66, 70,
 75, 79, 83, 87, 91, 96, 100, 104, 108, 112, 116, 120, 124, 127, 131, 135,
 139, 143, 146, 150, 153, 157, 160, 164, 167, 171, 174, 177, 180, 183, 186,
 190, 192, 195, 198, 201, 204, 206, 209, 211, 214, 216, 219, 221, 223, 225,
 227, 229, 231, 233, 235, 236, 238, 240, 241, 243, 244, 245, 246, 247, 248,
 249, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255, 255};

static int pascal isin(int angle) {
 int negflag,y;
 angle%=360;
 negflag=angle>=180;
 if (negflag) angle-=180;		// Quadranten III und IV
 if (angle>90) angle=180-angle;		// Quadranten II und IV
 y=sintab[angle];
 if (negflag) y=-y;
 return y;
}

static int pascal icos(int angle) {
 return isin(angle+90);
}

int far pascal _ret(int x) {
 return x;
}

/*******************************************
 * Funktionsnachbildungen der GRAPHICS.LIB *
 *******************************************/

void far arc(int x, int y, int stangle, int endangle, int radius) {
 ellipse(x,y,stangle,endangle,radius,MulDiv(radius,gAspect.y,gAspect.x));
}

#pragma argsused
void far cdecl bar(int left, int top, int right, int bottom) {
 right++;
 bottom++;
 gdiproc((FARPROC)FillRect,3,HIWORD((LPRECT)&left),LOWORD((LPRECT)&left),
   ghBrush);
}

void far bar3d(int left, int top, int right, int bottom, int depth,
  int topflag) {
 gdiproc((FARPROC)Rectangle,4,left,top,right+1,bottom+1);
 gdiproc((FARPROC)SaveDC,0x8000);		//Position retten
 moveto(right,top);
 lineto(right+depth,top-depth/2);
 lineto(right+depth,bottom-depth/2);
 lineto(right,bottom);
 if (topflag) {
  moveto(right+depth,top-depth/2);
  lineto(left+depth,top-depth/2);
  lineto(left,top);
 }
 gdiproc((FARPROC)RestoreDC,0x8001,-1);
}

void far circle(int x, int y, int radius) {
 POINT rad;

 rad.x=radius;
 rad.y=MulDiv(radius,gAspect.y,gAspect.x);
 selobj(GetStockObject(HOLLOW_BRUSH));
 gdiproc((FARPROC)Ellipse,4,x-rad.x,y-rad.y,x+rad.x+1,y+rad.y+1);
 selobj(ghBrush);
}

void far cleardevice(void) {
 setviewport(0,0,getmaxx(),getmaxy(),0);
 clearviewport();
}

void far clearviewport(void) {
 clrscr();
 moveto(0,0);
}

void far closegraph() {
 gGraphDriver=0;
 textmode(3);
}

void far detectgraph(int far *graphdriver, int far *graphmode) {
 *graphdriver=VGA;
 *graphmode=VGAHI;
}

void far drawpoly(int c, const int far *p) {
 gdiproc((FARPROC)Polyline,3,HIWORD(p),LOWORD(p),c);
}

void far ellipse(int x, int y, int stang, int endang, int xr, int yr) {
 gArcCoords.x=x;
 gArcCoords.y=y;
 gArcCoords.xstart=x+MulDiv(icos(stang),xr,255);
 gArcCoords.ystart=y-MulDiv(isin(stang),yr,255);
 gArcCoords.xend=x+MulDiv(icos(endang),xr,255);
 gArcCoords.yend=y-MulDiv(isin(endang),yr,255);
 gdiproc((FARPROC)Arc,8,x-xr,y-yr,x+xr+1,y+yr+1,
   gArcCoords.xstart,gArcCoords.ystart,gArcCoords.xend,gArcCoords.yend);
}

void far fillellipse(int x, int y, int xr, int yr) {
 gdiproc((FARPROC)Ellipse,4,x-xr,y-yr,x+xr+1,y+yr+1);
}

void far fillpoly(int c, const int far *p) {
 gdiproc((FARPROC)Polygon,3,HIWORD(p),LOWORD(p),c);
}

void far floodfill(int x, int y, int b) {
//kann das auf der Zeichenfläche gemacht werden?
 COLORREF farbe;
 if ((unsigned)b>getmaxcolor()) return;
 farbe=rgbpalette[gPalette.colors[b]];
 gdiproc((FARPROC)FloodFill,4,x,y,HIWORD(farbe),LOWORD(farbe));
}

void far getarccoords(struct arccoordstype far *arccoords) {
 *arccoords=gArcCoords;
}

void far getaspectratio(int far *xasp, int far *yasp) {
 *xasp=gAspect.x;
 *yasp=gAspect.y;
}

int far getbkcolor(void)	{ return gBkColor; }
int far getcolor(void)		{ return gColor; }
struct palettetype far * far getdefaultpalette(void) {
				  return &gDefaultPalette; }
char *far getdrivername(void)	{ return gDriverName; }
void far getfillpattern(char far *pattern) {
 hmemcpy(pattern,gFillPattern[USER_FILL],8);
}
void far getfillsettings (struct fillsettingstype far *fillinfo) {
 *fillinfo=gFillSettings;
}
int far getgraphmode(void)	{ return gGraphMode; }

void far getimage(int left, int top, int right, int bottom,
  void far *bitmap) {
 HBITMAP bm;
 HDC dc;
 int w,h;

 w=right+1-left; h=bottom+1-top;
 bm=CreateCompatibleBitmap(ghScreenDC,w,h);
 dc=CreateCompatibleDC(ghScreenDC);
 SelectObject(dc,bm);
 BitBlt(dc,0,0,w,h,ghActiveDC,left,top,SRCCOPY);
 SelectObject(dc,ghNullBitmap);
 DeleteDC(dc);
 ((LPWORD)bitmap)[0]=w;
 ((LPWORD)bitmap)[1]=h;
 ((LPWORD)bitmap)[2]=bm;
}

void far getlinesettings(struct linesettingstype far *lineinfo) {
 *lineinfo=gLineSettings;
}

int far getmaxcolor(void)	{ return 15;}
int far getmaxmode(void)	{ return 2;}

#pragma argsused
char * far getmodename(int mode_number) {
 static char buf[16];
 wsprintf(buf,"%d x %d WIN",width,height);
 return buf;
}

int far getmaxx(void) {return width-1;}
int far getmaxy(void) {return height-1;}

void far getmoderange(int graphdriver, int far* lowmode, int far* himode) {
//So ziemlich jeder Modus wird hier unterstützt
 if (graphdriver) {
  *lowmode=0;
  *himode=2;
 }
}

void far getpalette(struct palettetype far *palette) {
 *palette=gPalette;
}

int far getpalettesize(void)		{ return gPalette.size; }

unsigned far getpixel(int x, int y) {
 COLORREF c;
 c=GetPixel(ghActiveDC,x,y);
 for (x=0; x<=MAXCOLORS; x++) if (c==rgbpalette[x]) return x;
 return 0;
}


void far gettextsettings(struct textsettingstype far* texttypeinfo) {
 *texttypeinfo=gTextSettings;
}

void far getviewsettings(struct viewporttype far* viewport) {
 *viewport=gViewport;
}

int far getx(void) {return (int)(LOWORD(GetCurrentPosition(ghActiveDC)));}
int far gety(void) {return (int)(HIWORD(GetCurrentPosition(ghActiveDC)));}

void far graphdefaults(void) {
 setviewport(0,0,getmaxx(),getmaxy(),0);
 moveto(0,0);
 gPalette=gDefaultPalette;
 setcolor(15);
 setbkcolor(0);
 setfillstyle(SOLID_FILL,15);
 settextjustify(LEFT_TEXT,TOP_TEXT);
 settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
}

char *far grapherrormsg(int errorcode) {
 static char* msg[]={
    "Ok","NoInitGraph","NotDetected","FileNotFound",
    "InvalidDriver","NoLoadMem","NoScanMem","NoFloodMem",
    "FontNotFound","NoFontMem","InvalidMode","Error",
    "IOerror","InvalidFont","InvalidFontNum","InvalidDeviceNum",
    "InvalidVersion"};
 errorcode=-errorcode;
 if ((unsigned)errorcode>18) return NULL;
 return msg[errorcode];
}

int far graphresult(void) {
 register int ret=gGraphResult;
 gGraphResult=0;
 return ret;
}

#pragma argsused
void far initgraph(int far *graphdriver,
  int far *graphmode, const char far *pathtodriver) {
 if (*graphdriver==DETECT) detectgraph(graphdriver,graphmode);
 gGraphDriver=*graphdriver;
 setgraphmode(*graphmode);
}

void far pascal initgraph2(int x, int y, int z, int c) {
 gGraphDriver=UNIVERSAL;		// alles mögliche
 internal_initgraph(x,y,z,c);
}

#pragma argsused
void far _cdecl line(int x1, int y1, int x2, int y2) {
 gdiproc((FARPROC)Polyline,3,HIWORD((LPPOINT)&x1),LOWORD((LPPOINT)&x1),2);
}

void far linerel(int x, int y) {
 lineto(getx()+x,gety()+y);
}

void far lineto(int x, int y) {
 gdiproc((FARPROC)LineTo,2,x,y);
}

void far moverel(int x, int y) {
 moveto(getx()+x,gety()+y);
}

void far moveto(int x, int y) {
 gdiproc((FARPROC)MoveTo,0x8002,x,y);
}

void far outtext(const char far *textstring) {
 outtextxy(0x8000U,0x8000U,textstring);	// Spezial-Code
}

void far outtextxy(int x, int y, const char far *textstring) {
 static WORD horzalign[3]={TA_LEFT,TA_CENTER,TA_RIGHT};
 static WORD vertalign[3]={TA_BOTTOM,TA_BASELINE,TA_TOP}; //TA_VCENTER gibt's nicht
 char near*ansi=NULL;
 WORD slen=lstrlen(textstring);

 CheckFont2();
 selobj(ghFont2);
 gdiproc((FARPROC)SetTextAlign,0x8001,
   ((unsigned)x==0x8000U && (unsigned)y==0x8000U ? TA_UPDATECP : TA_NOUPDATECP)
   | (gTextSettings.direction
   ? horzalign[gTextSettings.vert]  | vertalign[2-gTextSettings.horiz]
   : horzalign[gTextSettings.horiz] | vertalign[gTextSettings.vert]));
 gdiproc((FARPROC)SetBkMode,0x8001,TRANSPARENT);
 if (gTextSettings.font && NeedConvert(textstring)) {
  ansi=(char near*)LocalAlloc(LMEM_FIXED,slen);
  OemToAnsiBuff(textstring,ansi,slen);	//ohne Null, wird nicht gebraucht
  textstring=ansi;	//Zeiger umsetzen
 }
 gdiproc((FARPROC)TextOut,5,x,y,HIWORD(textstring),LOWORD(textstring),slen);
 if (ansi) LocalFree((HANDLE)ansi);
 gdiproc((FARPROC)SetBkMode,0x8001,OPAQUE);
 gdiproc((FARPROC)SetTextAlign,0x8001,0);
 selobj(ghFont);
}

void far pieslice(int x, int y, int stangle, int endangle, int radius) {
 gdiproc((FARPROC)Pie,8,x-radius,y-radius,x+radius+1,y+radius+1,
   x+icos(stangle),y-isin(stangle),x+icos(endangle),y-isin(endangle));
}

void far putimage(int left, int top, const void far *bitmap, int op) {
 int w=((LPWORD)bitmap)[0];
 int h=((LPWORD)bitmap)[1];
 HBITMAP bm=((LPWORD)bitmap)[2];
 HDC dc=CreateCompatibleDC(ghScreenDC);
 static DWORD rops[]={SRCCOPY,SRCINVERT,SRCPAINT,SRCAND,NOTSRCCOPY};

 if ((unsigned)op>=4) return;
 SelectObject(dc,bm);
 gdiproc((FARPROC)BitBlt,9,left,top,w,h,dc,0,0,HIWORD(rops[op]),LOWORD(rops[op]));
 SelectObject(dc,ghNullBitmap);
 DeleteDC(dc);
}

void far putpixel(int x, int y, int c) {
 COLORREF farbe;
 if ((unsigned)c>MAXCOLORS) return;
 farbe=rgbpalette[gPalette.colors[c]];
 gdiproc((FARPROC)SetPixel,4,x,y,HIWORD(farbe),LOWORD(farbe));
}

void far rectangle(int left, int top, int right, int bottom) {
 selobj(GetStockObject(HOLLOW_BRUSH));
 gdiproc((FARPROC)Rectangle,4,left,top,right+1,bottom+1);
 selobj(ghBrush);
}

void far restorecrtmode(void) {
// gGraphDriver=0;
 textmode(3);
}

void far sector(int x, int y, int stang, int endang, int xr, int yr) {
 gdiproc((FARPROC)Pie,8,x-xr,y-yr,x+xr+1,y+yr+1,
   x+icos(stang),y-isin(stang),x+icos(endang),y-isin(endang));
}

void far setactivepage(int page) {
 BOOL already_there;
 if ((unsigned)page>=(unsigned)numpages) return;
 if (page==activepage) return;
 already_there=pages[page];
 CheckPageLoaded(page);
 activepage=page;
 SelectObject(ghActiveDC,pages[page]);
 if (!already_there) {
  PatBlt(ghActiveDC,0,0,width,height,BLACKNESS);
 }
}

void far setallpalette(const struct palettetype far *palette) {
 gPalette=*palette;
}

void far setaspectratio(int xasp, int yasp) {
 gAspect.x=xasp;
 gAspect.y=yasp;
}

void far setbkcolor(int color) {
 if ((unsigned)color>getmaxcolor()) return;
 gBkColor=color;
 setcol(SetBkColor,rgbpalette[gPalette.colors[color]]);
}

void far setcolor(int color) {
 if ((unsigned)color>getmaxcolor()) return;
 gColor=color;
 setcol(SetTextColor,rgbpalette[gPalette.colors[color]]);
 PenChange();
}

void far setfillpattern(const char far *upattern, int color) {
 hmemcpy(gFillPattern[USER_FILL],upattern,8);
 setfillstyle(USER_FILL,color);
}

void far setfillstyle(int pattern, int color) {
 HBRUSH br;
 static int HatchIndex[]={HS_HORIZONTAL,HS_FDIAGONAL,HS_FDIAGONAL,HS_BDIAGONAL,HS_BDIAGONAL,
   HS_CROSS,HS_DIAGCROSS,HS_VERTICAL,HS_CROSS,HS_CROSS};

 gFillSettings.pattern=pattern;
 gFillSettings.color=color;
 switch (gFillSettings.pattern) {
  case EMPTY_FILL: br=GetStockObject(HOLLOW_BRUSH); break;
  case SOLID_FILL: br=CreateSolidBrush(rgbpalette[gPalette.colors[gFillSettings.color]]); break;
  case USER_FILL: {
   HBITMAP bm;
   WORD bits[8];
   BYTE *bp;
   int i;
   for (bp=gFillPattern[gFillSettings.pattern],i=0; i<8; i++) bits[i]=*bp++;
   bm=CreateBitmap(8,8,1,1,bits);
   br=CreatePatternBrush(bm);
   DeleteObject(bm);
  }break;
  default: br=CreateHatchBrush(HatchIndex[gFillSettings.pattern-LINE_FILL],
    rgbpalette[gPalette.colors[color]]);
 }
 ChangeGdiObject(&ghBrush,br);
}

#pragma argsused
void far setgraphmode(int mode) {
 static int vgalines[3]={200,350,480};
 if (!gGraphDriver) return;
 if ((unsigned)mode>2) return;
 gGraphMode=mode;
 internal_initgraph(640,vgalines[mode],mode<2?2:1,MAXCOLORS+1);
}

#pragma argsused
void far setlinestyle(int linestyle, unsigned upattern, int thickness) {
 if ((unsigned)linestyle>USERBIT_LINE) return; 
 gLineSettings=*(struct linesettingstype*)&linestyle;
 PenChange();
}

void far setpalette(int colornum, int color) {
 if ((unsigned)colornum>=gPalette.size) return;
 if ((unsigned)color>getmaxcolor()) return;
 gPalette.colors[colornum]=color;
}

void far setrgbpalette(int colornum, int red, int green, int blue) {
 if ((unsigned)colornum>=gPalette.size) return;
 ((RGBQUAD*)(&rgbpalette[colornum]))->rgbRed=red;
 ((RGBQUAD*)(&rgbpalette[colornum]))->rgbGreen=green;
 ((RGBQUAD*)(&rgbpalette[colornum]))->rgbBlue=blue;
 //normalerweise und nur bei 256-Farben-Displays möglich: RealizePalette()
 //Paletten-Animation ist, weil selten verwendet, nicht vorgesehen.
}

void far settextjustify(int horiz, int vert) {
 if ((unsigned)horiz>2) return;
 if ((unsigned)vert>2) return;
 gTextSettings.horiz=horiz;
 gTextSettings.vert=vert;
 Font2Change();
}

void far settextstyle(int font, int direction, int charsize) {
 gTextSettings.font=font<5?font:0;
 gTextSettings.direction=direction;
 gTextSettings.charsize=charsize;
 Font2Change();
}

#pragma argsused
void far setusercharsize(int multx, int divx, int multy, int divy) {
 gUserCharSize=*(struct usercharsizetype*)&multx;
 Font2Change();
}

void far cdecl setviewport(int left, int top, int right, int bottom, int clip) {
 HRGN hRegion;
 gdiproc((FARPROC)SelectClipRgn,0x8001,0);	// Falls vorhanden, Clipping entfernen
 gViewport=*(struct viewporttype*)&left;
 if (clip) {
  hRegion=CreateRectRgn(left,top,right+1,bottom+1);
  gdiproc((FARPROC)SelectClipRgn,0x8001,hRegion);
  DeleteObject(hRegion);
 }
 gdiproc((FARPROC)SetViewportOrg,2,left,top);
}

void far setvisualpage(int page) {
 if ((unsigned)page>=(unsigned)numpages) return;
 if (page==visualpage) return;
 CheckPageLoaded(page);
 if (activepage!=visualpage) SelectObject(ghVisualDC,ghNullBitmap);
 visualpage=page;
 if (activepage!=visualpage) SelectObject(ghVisualDC,pages[page]);
 Changed=TRUE;
 if (_DirectDraw) {
  invalidate();
  UpdateWindow(CrtWindow);	// Sofort aktualisieren
 }
}

void far setwritemode(int mode) {
 gdiproc((FARPROC)SetROP2,0x8001,mode ? R2_XORPEN : R2_COPYPEN);
}

long far pascal textextent(const char far *textstring) {
 long ret;
 CheckFont2();
 SelectObject(ghActiveDC,ghFont2);
 ret=GetTextExtent(ghActiveDC,textstring,lstrlen(textstring));
 SelectObject(ghActiveDC,ghFont);
 return ret;
}

int far textheight(const char far *textstring) {
 return HIWORD(textextent(textstring));
}

int far textwidth(const char far *textstring) {
 return LOWORD(textextent(textstring));
}

/********************************************
 * Hier geht's mit richtigem Windows weiter *
 ********************************************/

long far pascal GraphWndProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
 switch (Msg) {
  case WM_CREATE: {
   CrtWindow=Wnd;
   ghScreenDC=GetDC(Wnd);
   ghActiveDC=CreateCompatibleDC(ghScreenDC);
   ghVisualDC=CreateCompatibleDC(ghScreenDC);
   SetPages(640,400,1,16);	//mit VGA-Textmodus-Emulation geht's los!
   MakeGdiObjects();
  }break;

  case WM_SETFOCUS:  if (Reading) _ShowCursor(); break;
  case WM_KILLFOCUS: if (Reading) _HideCursor(); break;

  case WM_QUERYENDSESSION:
  case WM_CLOSE: {
   if (CanClose || MessageBox(Wnd,_KillWarning,_WindowTitle,
     MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2)==IDYES) break;
     			// DefWindowProc() schließt - nur bei WM_Close
  }return 0;		// nicht schließen!

  case WM_KEYDOWN: {
   if ((VK_PRIOR<=wParam && wParam<=VK_DOWN)
   || (VK_INSERT<=wParam && wParam<=VK_HELP)
   || (VK_F1<=wParam && wParam<=VK_SCROLL)) {
    if (KeyCount<sizeof(KeyBuffer)-1) {
     KeyBuffer[KeyCount++]='\0';
     KeyBuffer[KeyCount++]=LOBYTE(HIWORD(lParam));
    }
   }
  }break;

  case WM_GETMINMAXINFO: {
   RECT R;
   SetRect(&R,0,0,width*scale,height*scale);
   AdjustWindowRect(&R,WS_OVERLAPPEDWINDOW,FALSE);
   ((LPPOINT)(lParam))[4].x=R.right-R.left;
   ((LPPOINT)(lParam))[4].y=R.bottom-R.top;
  }break;

  case WM_CHAR: {
   if (_CheckBreak  && (wParam==3)) DestroyWindow(Wnd);
   if (KeyCount<sizeof(KeyBuffer)) {
    AnsiToOemBuff((LPSTR)&wParam,KeyBuffer+KeyCount++,1);	// convert the character!
   }
  }break;

  case WM_PAINT: {
   PAINTSTRUCT ps;
   HDC src_dc= activepage!=visualpage ? ghVisualDC : ghActiveDC;
   BeginPaint(Wnd,&ps);
   if (scale==1) BitBlt(ps.hdc,0,0,width,height,src_dc,0,0,SRCCOPY);
   else StretchBlt(ps.hdc,0,0,width*scale,height*scale,src_dc,0,0,width,height,SRCCOPY);
   EndPaint(Wnd,&ps);
  }return 0;

  case WM_DESTROY: {
   DestroyGdiObjects();
   SetPages(0,0,0,0);
   DeleteDC(ghActiveDC);
   DeleteDC(ghVisualDC);
   ReleaseDC(Wnd,ghScreenDC);
   PostQuitMessage(0);
  }break;
 }
 return DefWindowProc(Wnd,Msg,wParam,lParam);
}

static void pascal EndMessageLoop(void) {
/* zum Stehenlassen des inaktiven Fensters */
 MSG Msg;
 char Title[128];

 invalidate();
 wsprintf(Title,_InactiveTitle,(char far*)_WindowTitle);
 SetWindowText(CrtWindow,Title);
 CanClose=TRUE;
 while (GetMessage(&Msg,0,0,0)) {
  TranslateMessage(&Msg);
  DispatchMessage(&Msg);
 }
}

//Deklaration von main()
int main(int argc,char**argv,char**envp);

#pragma argsused
int pascal WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine,
  int nCmdShow) {
 int ret;
 BOOL IsWin9x;
 char fontname[80];


 if (!hPrevInstance) {
  WNDCLASS wc;
  memset(&wc,0,sizeof(wc));
  wc.lpfnWndProc=GraphWndProc;
  wc.hInstance=hInstance;
  wc.hIcon=LoadIcon(0,IDI_APPLICATION);
  wc.hCursor=LoadCursor(0,IDC_ARROW);
  wc.lpszClassName="GRAPHWIN";
  RegisterClass(&wc);
 }
 GetModuleFileName(hInstance, _WindowTitle, sizeof(_WindowTitle));
 OemToAnsi(_WindowTitle, _WindowTitle);
 __ReadBufFPtr =_ReadBuf;
 __WriteBufFPtr=_WriteBuf;
 IsWin9x=HIBYTE(LOWORD(GetVersion()))>=95;
 if (IsWin9x) {
  ret=GetWindowsDirectory(fontname,sizeof(fontname)-7);
  if (fontname[ret-1]!='\\') fontname[ret++]='\\';
  lstrcpy(fontname+ret,"FONTS\\");
  ret+=6;
 }else{
  ret=GetSystemDirectory(fontname,sizeof(fontname)-1);
  if (fontname[ret-1]!='\\') fontname[ret++]='\\';
 }
 GetPrivateProfileString("386Enh","woafont","dosapp.fon",
   fontname+ret,sizeof(fontname)-ret,"SYSTEM.INI");
 AddFontResource(fontname);

 CreateWindow("GRAPHWIN",_WindowTitle,
   (WS_OVERLAPPEDWINDOW&~WS_MAXIMIZEBOX)|WS_VISIBLE,
   CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
   0,0,hInstance,NULL);

 ret=main(_argc,_argv,environ);
 if (CanTerminate) DestroyWindow(CrtWindow);
 EndMessageLoop();
 RemoveFontResource(fontname);
 return ret; 
}
Vorgefundene Kodierung: ANSI (CP1252)4
Umlaute falsch? - Datei sei ANSI-kodiert (CP1252)