Source file: /~heha/hs/spe.zip/src/SPE.cpp

/* Serial Printer Emulator:
 * emulates a serial printer on a selectable COM port
 * (port settings are adjustable too),
 * and redirects it to a Windows printer (even selectable)
 *
 * Emulation eines seriellen Druckers:
 * emuliert einen Drucker an einem auswählbaren COM-Port
 * (Anschlusseinstellungen sind ebenfalls auswählbar),
 * und leitet den Datenstrom zu einem (auch auswählbaren) Windows-Drucker
 *
 * Mit einem (käuflichen) Parallel-zu-Seriell-Umsetzer kann man so auch
 * Druckausgaben von Parallelports auffangen.
 * Für COM-Port-lose Rechner funktionieren auch USB-Seriell-Konverter.
 *
 * Siehe http://www.tu-chemnitz.de/~heha/hs/mein_msvc.htm

+140430	Voreinstellbare DIP-Schalter für ESC/P, noch ohne Dialog
	ESC "R"-Voreinstellung je nach LocaleInfo (einige europäische Länder)
	SetupDi-basierte COM-Port-Auflistung (>COM32)
+150818	Dialog mit UpDownControl; Sound-Test beim Rechtsklick auf "..."-Knopf
-150818	Dialog mit Ausgabedatei- oder Ausgabeprozess-Auswahl
*150818	Konfigurations-Speicherort HKCU statt HKLM; x64-Echse; Signierung
*150819	setjmp+longjmp statt Catch+Throw; SEH geht auch aber frisst mehr Platz.
	C++-Exceptions gehen nicht (mit msvcrt-light.lib) zu übersetzen.
-221008	Restrukturierung DCB laden und speichern
	(fehlendes GetCommDCB() kann zu Fehlern führen)
	Keine Codesignatur mehr da eigenes Zertifikat abgelaufen
	ShellExecute statt sndPlaySound wenn Endung != WAV

TODO:
 Voreinstellungs-Dialog (crlf-Handling, Seitengröße usw.) für ESC/P
 Grafikausgabe (sofern Bedarf besteht und Testdatei vorliegt)

 */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <commdlg.h>
#include <shlwapi.h>
#include <mmsystem.h>
#include <setupapi.h>
#include <devguid.h>
#include <winspool.h>
#include <shellapi.h>
#include "escp.h"

#define T(x) TEXT(x)		// Schreibfaulheit...
#define elemof(x) (sizeof(x)/sizeof(*(x)))	// Elemente eines Arrays
#define nobreak			// expliziter Durchlauf bei switch/case

#if (_MSC_VER <= 1200)	// missing common control definitions (for split button)
struct NMBCDROPDOWN{
 NMHDR   hdr;
 RECT    rcButton;
};
#define BCN_DROPDOWN	0xFFFFFB20
#define BS_SPLITBUTTON	0x0000000C
#endif

void _fastcall InitStruct(LPVOID p, UINT len) {
 LPUINT pp=(LPUINT)p;
 *pp=len; len/=sizeof(UINT); len--;
 if (len) do *++pp=0; while (--len);
}

TCHAR MBoxTitle[64];

int  vMBox(HWND Wnd, UINT id, UINT style, va_list arglist) {
 TCHAR buf1[256],buf2[1024];
 LoadString(0,id,buf1,elemof(buf1));
 wvnsprintf(buf2,elemof(buf2),buf1,arglist);
 return MessageBox(Wnd,buf2,MBoxTitle,style);
}

int _cdecl MBox(HWND Wnd, UINT id, UINT style,...) {
 return vMBox(Wnd,id,style,(va_list)(&style+1));
}

static TCHAR ModeString[64]=T("COM1 9600,n,8,1");	// idiotischerweise kommt Parität vor Datenbits
/* Wirkung der Suffixe ",p" (Hardware-Protokoll), ",x" (XON/XOFF-Protokoll)
   und keiner (ohne Protokoll) bei BuildCommDCB(ModeString,&DCB):
Suffix		",p"	",x"	ohne
fOutxCtsFlow	1	0	0
fOutxDsrFlow	1	0	0
fDtrControl	2	1	1
fRtsControl	2	1	1
fOutX		0	1	0
fInX		0	1	0
*/
struct{
 WORD TimeOutMs;	// TimeOut zur Druckjob-Beendigung in ms
 BYTE PrintFilter;	// 0==RAW, 1==ESC/P, 2==ESC/P2, 3==Dateiausgabe, 4==Standardeingabe für Prozess
 BYTE keepdef;		// Veränderungen durch Druckersteuerkommandos persistent halten
			// 1 = Zwischen Einzelaufträgen
			// 2 = Zusätzlich zwischen Neustarts von SPE.exe (also Reboots)
 POINTS PageOffset;	// Verschiebung der Druckdaten auf dem Papier in mm
 DEFAULTS def;		// DIP-Schalter (Mäuseklavier), siehe <escp.h>
}Config;
COMMTIMEOUTS to;
static TCHAR StartSound[MAX_PATH],EndSound[MAX_PATH];
static TCHAR PrinterName[MAX_PATH];

//Hilfsfunktion
static LONG RegQueryValueExL(HKEY hKey,LPCTSTR Tag,PVOID pValue,DWORD Len) {
 return RegQueryValueEx(hKey,Tag,NULL,NULL,(LPBYTE)pValue,&Len);
}

static TCHAR Key0[]=T("Software\\h#s\\SPE");
static TCHAR Key1[]=T("Port");
static TCHAR Key2[]=T("PrinterName");
static TCHAR Key3[]=T("StartSound");
static TCHAR Key4[]=T("EndSound");
static TCHAR Key5[]=T("Config");

static void LoadSettings() {
 HKEY hKey;
// Wenns mit Laden schief geht, wenigstens sinnvoll initialisieren
 Config.TimeOutMs=5000;
// Schlüssel-Zweig öffnen
 if (RegOpenKeyEx(HKEY_CURRENT_USER,Key0,0,KEY_QUERY_VALUE,&hKey)) return;
 RegQueryValueExL(hKey,Key1,ModeString,sizeof ModeString);
 RegQueryValueExL(hKey,Key2,PrinterName,sizeof PrinterName);
 RegQueryValueExL(hKey,Key3,StartSound,sizeof StartSound);
 RegQueryValueExL(hKey,Key4,EndSound,sizeof EndSound);
 RegQueryValueExL(hKey,Key5,&Config,sizeof(Config));
 RegCloseKey(hKey);
}

//Hilfsfunktion
static LONG RegSetValueExSZ(HKEY hKey,LPCTSTR Tag,LPCTSTR Value) {
 if (!Value || !*Value) return RegDeleteValue(hKey,Tag);
 else return RegSetValueEx(hKey,Tag,0,REG_SZ,
   (PBYTE)Value,(lstrlen(Value)+1)*sizeof(TCHAR));
}

static void SaveSettings() {
 HKEY hKey;
 DWORD dispo;
// Schlüssel-Zweig öffnen
 if (RegCreateKeyEx(HKEY_CURRENT_USER,Key0,0,
   NULL,REG_OPTION_NON_VOLATILE,KEY_SET_VALUE,NULL,&hKey,&dispo)) return;
// eine Beschreibung schreiben (damit der Anwender weiß, worum es geht)
 RegSetValueExSZ(hKey,0,MBoxTitle);
 RegSetValueExSZ(hKey,Key1,ModeString);
 RegSetValueExSZ(hKey,Key2,PrinterName);
 RegSetValueExSZ(hKey,Key3,StartSound);
 RegSetValueExSZ(hKey,Key4,EndSound);
 RegSetValueEx(hKey,Key5,0,REG_BINARY,(PBYTE)&Config,sizeof(Config));
 RegCloseKey(hKey);
}

static void EnabOffsets(HWND Wnd) {
 BOOL ena=(unsigned)(Config.PrintFilter-1)<2;
 EnableWindow(GetDlgItem(Wnd,22),ena);
 EnableWindow(GetDlgItem(Wnd,122),ena);
 EnableWindow(GetDlgItem(Wnd,23),ena);
 EnableWindow(GetDlgItem(Wnd,123),ena);
 int show=Config.PrintFilter<3?SW_SHOW:SW_HIDE;
 ShowWindow(GetDlgItem(Wnd,13),show);	// Combobox
 show^=SW_SHOW^SW_HIDE;			// umkehren
 ShowWindow(GetDlgItem(Wnd,24),show);	// Edit
 ShowWindow(GetDlgItem(Wnd,25),show);	// Button
 TCHAR s[64],*sp=s;
 s[LoadString(0,6,s,elemof(s)-1)+1]=0;
 for (show=2;show<Config.PrintFilter;sp+=lstrlen(sp)+1) show++;
 SetDlgItemText(Wnd,21,sp);
}

static WNDPROC DefButtonProc;
static void DoStartSound();
static void DoEndSound();

// Ungefähr das Verhalten eines SplitButtons nachmachen, für Windows XP.
// Optisch wird nichts verändert.
static LONG_PTR CALLBACK NotifyProc(HWND Wnd, UINT msg, WPARAM wParam, LPARAM lParam) {
 switch (msg) {
  case WM_GETDLGCODE: return CallWindowProc(DefButtonProc,Wnd,msg,wParam,lParam)|DLGC_WANTARROWS;
  case WM_KEYDOWN: if (wParam!=VK_DOWN) break; else nobreak; // seltsamerweise geht auch Cursor Hoch!
  case WM_CONTEXTMENU: {
   NMBCDROPDOWN h;
   h.hdr.hwndFrom=Wnd;
   h.hdr.idFrom=GetDlgCtrlID(Wnd);
   h.hdr.code=BCN_DROPDOWN;
   GetWindowRect(Wnd,&h.rcButton);
   MapWindowPoints(0,Wnd,(POINT*)&h.rcButton,2);
   SendMessage(GetParent(Wnd),WM_NOTIFY,h.hdr.idFrom,(LPARAM)&h);
  }return 0;
 }
 return CallWindowProc(DefButtonProc,Wnd,msg,wParam,lParam);
}

static void MkSplitButton(HWND Wnd) {
 if (LOBYTE(GetVersion())>=6) {
  DWORD style=GetWindowLong(Wnd,GWL_STYLE);
  style|=BS_SPLITBUTTON;
  SetWindowLong(Wnd,GWL_STYLE,style);
 }else{
  DefButtonProc=SubclassWindow(Wnd,NotifyProc);
 }
}

static TCHAR stPortName[]=T("PortName");

static INT_PTR CALLBACK SetupDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
 switch (Msg) {
  case WM_INITDIALOG: {
   TCHAR s[256],*sp;
   HWND w;
   CreateUpDownControl(WS_VISIBLE|WS_CHILD|WS_BORDER|UDS_ALIGNRIGHT|UDS_ARROWKEYS|UDS_HOTTRACK|UDS_NOTHOUSANDS|UDS_SETBUDDYINT,
     0,0,0,0,Wnd,112,0,GetDlgItem(Wnd,12),1000,0,Config.TimeOutMs/1000);
   SetDlgItemText(Wnd,16,StartSound);
   SetDlgItemText(Wnd,18,EndSound);
   s[LoadString(0,5,s,elemof(s)-1)+1]=0;
   w=GetDlgItem(Wnd,20);	// Combobox
   for(sp=s;*sp;sp+=lstrlen(sp)+1) {
    ComboBox_AddString(w,sp);	// Combobox füllen
   }
   ComboBox_SetCurSel(w,Config.PrintFilter);
   CreateUpDownControl(WS_VISIBLE|WS_CHILD|WS_BORDER|UDS_ALIGNRIGHT|UDS_ARROWKEYS|UDS_HOTTRACK|UDS_NOTHOUSANDS|UDS_SETBUDDYINT,
     0,0,0,0,Wnd,122,0,GetDlgItem(Wnd,22),500,-500,Config.PageOffset.x);
   CreateUpDownControl(WS_VISIBLE|WS_CHILD|WS_BORDER|UDS_ALIGNRIGHT|UDS_ARROWKEYS|UDS_HOTTRACK|UDS_NOTHOUSANDS|UDS_SETBUDDYINT,
     0,0,0,0,Wnd,123,0,GetDlgItem(Wnd,23),500,-500,Config.PageOffset.y);
   SetDlgItemText(Wnd,24,PrinterName);
   MkSplitButton(GetDlgItem(Wnd,17));
   MkSplitButton(GetDlgItem(Wnd,19));
   EnabOffsets(Wnd);
   SendMessage(Wnd,WM_TIMER,1,0);
  }return TRUE;

  case WM_DEVICECHANGE: SetTimer(Wnd,1,2500,NULL); break;

  case WM_TIMER: if (wParam==1) {
   KillTimer(Wnd,wParam);
// serielle Schnittstellen (neu) listen (bei jedem WM_DEVICECHANGE bspw. für USB)
   HWND hCombo=GetDlgItem(Wnd,10);
   ComboBox_ResetContent(hCombo);
   HANDLE devs=SetupDiGetClassDevs(&GUID_DEVCLASS_PORTS,NULL,0,DIGCF_PRESENT);
   if (devs!=INVALID_HANDLE_VALUE) {
    DWORD ComNr=StrToInt(ModeString+3);	// Einsbasierte Ist-Portnummer
    SP_DEVINFO_DATA devInfo;
    devInfo.cbSize=sizeof devInfo;
    for (DWORD i=0; SetupDiEnumDeviceInfo(devs,i,&devInfo); i++) {
     HKEY hKey;
     TCHAR s[16];
     *s=0;
     if ((hKey=SetupDiOpenDevRegKey(devs,&devInfo,DICS_FLAG_GLOBAL,0,DIREG_DEV,KEY_READ))
       ==INVALID_HANDLE_VALUE) continue;
     RegQueryValueExL(hKey,stPortName,s,sizeof s);
     RegCloseKey(hKey);
     if (*s=='C') {		// Fehlschläge und LPTx ausfiltern
      int idx=ComboBox_AddString(hCombo,PTSTR(s));
      DWORD num=StrToInt(s+3);	// auch hier: einsbasiert
      ComboBox_SetItemData(hCombo,idx,num);
      if (num==ComNr) ComboBox_SetCurSel(hCombo,idx);
     }
    }
    SetupDiDestroyDeviceInfoList(devs);
   }
// Drucker (neu) listen (richtig bei WM_DEVICECHANGE?)
   DWORD NeedBytes=0,ArrLen,LastError;
   PRINTER_INFO_5 *pPI=NULL;
   hCombo=GetDlgItem(Wnd,13);
   ComboBox_ResetContent(hCombo);
   do{	// Endlosschleife, um dem Multitasksystem wechselnde Drucker zu erlauben
    LastError=0;
    if (EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
      NULL,5,(LPBYTE)pPI,NeedBytes,&NeedBytes,&ArrLen)) break;
    LastError=GetLastError();
    if (pPI) LocalFree(pPI);
    pPI=(PRINTER_INFO_5*)LocalAlloc(LPTR,NeedBytes);
   }while(pPI && LastError==ERROR_INSUFFICIENT_BUFFER);
   if (!pPI || LastError) break;
   for(UINT i=0; i<ArrLen; i++) {
    int idx=ComboBox_AddString(hCombo,pPI[i].pPrinterName);
    if (!lstrcmpi(pPI[i].pPrinterName,PrinterName))
      ComboBox_SetCurSel(hCombo,idx);
   }
   LocalFree(pPI);
  }break;
  
  case WM_NOTIFY: {
   NMHDR*h=(NMHDR*)lParam;
   if (h->code==BCN_DROPDOWN) {
    NMBCDROPDOWN*h=(NMBCDROPDOWN*)lParam;
    HMENU m=CreatePopupMenu();
    TCHAR s[32];
    LoadString(0,9,s,elemof(s));
    AppendMenu(m,MF_STRING,2,s);
    MapWindowPoints(h->hdr.hwndFrom,0,(POINT*)&h->rcButton,2);
    if (TrackPopupMenu(m,TPM_LEFTALIGN|TPM_TOPALIGN|TPM_RETURNCMD|TPM_RIGHTBUTTON,
      h->rcButton.left,h->rcButton.bottom,0,Wnd,NULL)==2) switch (h->hdr.idFrom) {
     case 17: {
      GetDlgItemText(Wnd,16,StartSound,elemof(StartSound));
      DoStartSound();
     }break;
     case 19: {
      GetDlgItemText(Wnd,18,EndSound,elemof(EndSound));
      DoEndSound();
     }break;
    }
    DestroyMenu(m);
   }
  }break;

  case WM_COMMAND: switch (LOBYTE(wParam)) {
   case 10: switch (GET_WM_COMMAND_CMD(wParam,lParam)) {
    case CBN_SELCHANGE: {
     TCHAR buf[elemof(ModeString)], *rest=StrChr(ModeString,' ');
     if (rest) ++rest;
     wnsprintf(buf,elemof(buf),T("COM%u %s"),
       ComboBox_GetItemData((HWND)lParam,ComboBox_GetCurSel((HWND)lParam)),
       rest);
     StrCpyN(ModeString,buf,elemof(ModeString));
    }break;
   }break;

   case 11: {
    TCHAR ComName[8];
    wnsprintf(ComName,elemof(ComName),T("COM%u"),StrToInt(ModeString+3));
    COMMCONFIG cc;
    InitStruct(&cc,sizeof cc);
    cc.dcb.DCBlength=sizeof cc.dcb;
    BuildCommDCB(ModeString,&cc.dcb);
    if (CommConfigDialog(ComName,Wnd,&cc)) {
     static const TCHAR*stopbits[]={T("1"),T("1.5"),T("2")};
     const TCHAR*proto=T("");
     if (cc.dcb.fInX) proto=T(",x");
     else if (cc.dcb.fOutxDsrFlow) proto=T(",p");
     wnsprintf(ModeString,elemof(ModeString),
       T("%s %u,%c,%u,%s%s"),
       ComName,
       cc.dcb.BaudRate,
       "noems"[cc.dcb.Parity],		// no/odd/even/mark/space
       cc.dcb.ByteSize,
       stopbits[cc.dcb.StopBits],	// 1.5 gibt's praktisch nie
       proto
     );
    }
   }break;

   case 13: switch (GET_WM_COMMAND_CMD(wParam,lParam)) {
    case CBN_SELCHANGE: {
     ComboBox_GetLBText((HWND)lParam,ComboBox_GetCurSel((HWND)lParam),PrinterName);
    }break;
   }break;

   case 17:
   case 19:	// Dateiauswahl für WAV-Dateien
   case 25: {	// Dateiauswahl für PRN-Datei oder ausführbare Datei
    int strid=3;
    OPENFILENAME ofn;
    TCHAR FileName[MAX_PATH];
    TCHAR Filter[256];
    wParam--;
    InitStruct(&ofn,sizeof(ofn));
    ofn.lpstrFile=FileName;
    ofn.nMaxFile=elemof(FileName);
    ofn.lpstrFilter=Filter;
    ofn.Flags=OFN_HIDEREADONLY|OFN_FILEMUSTEXIST;
    if (wParam==24) {
     strid=Config.PrintFilter-3+7;
     if (Config.PrintFilter==3) ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
    }
    Filter[LoadString(0,strid,Filter,elemof(Filter)-1)+1]=0;
    GetDlgItemText(Wnd,(int)wParam,FileName,elemof(FileName));
    if ((ofn.Flags&OFN_FILEMUSTEXIST?GetOpenFileName:GetSaveFileName)(&ofn)) {
     SetDlgItemText(Wnd,(int)wParam,FileName);
    }
   }break;

   case 20: switch (GET_WM_COMMAND_CMD(wParam,lParam)) { // Druckerfilter
    case CBN_SELCHANGE: {
     Config.PrintFilter=ComboBox_GetCurSel((HWND)lParam);
     EnabOffsets(Wnd);	// Dialog verändern
    }break;
   }break;

   case IDOK: {
    BOOL ok;
    UINT id;
    HWND hWndItem=GetDlgItem(Wnd,10);
    if (ComboBox_GetCurSel(hWndItem)<0) {
     SetFocus(hWndItem);
     break;	// nicht OK!
    }
    if ((int)Config.PrintFilter<0) {
     SetFocus(GetDlgItem(Wnd,20));
     break;	// nicht OK!
    }
    if (Config.PrintFilter<3) {
     hWndItem=GetDlgItem(Wnd,13);
     if (ComboBox_GetCurSel(hWndItem)<0) {
      SetFocus(hWndItem);
      break;	// nicht OK!
     }
    }else GetDlgItemText(Wnd,24,PrinterName,elemof(PrinterName));
    id=22;
    Config.PageOffset.x=GetDlgItemInt(Wnd,id,&ok,TRUE);
    if (!ok) goto editfail;	// nicht OK!
    id=23;
    Config.PageOffset.y=GetDlgItemInt(Wnd,id,&ok,TRUE);
    if (!ok) goto editfail;	// nicht OK!
    id=12;
    Config.TimeOutMs=GetDlgItemInt(Wnd,id,&ok,FALSE)*1000;
    if (!Config.TimeOutMs) {	// Fehler, muss >0 sein
editfail:
     hWndItem=GetDlgItem(Wnd,id);
     Edit_SetSel(hWndItem,0,-1);
     SetFocus(hWndItem);
     break;	// kein EndDialog()
    }
    GetDlgItemText(Wnd,16,StartSound,elemof(StartSound));
    GetDlgItemText(Wnd,18,EndSound,elemof(EndSound));
   }nobreak;
   case IDCANCEL: {
    EndDialog(Wnd,LOWORD(wParam));
   }break;
  }break;
 }
 return FALSE;
}

// Wie Windows NT auf allen Windows-Versionen (da fehlt ein shlwapi.Beep?)
#ifdef _M_IX86
static BOOL MyBeep(DWORD dwFreq, DWORD dwDuration) {
 if ((long)GetVersion()>=0) return Beep(dwFreq,dwDuration);
 else{	// Win32s, Win9x/Me
  if (dwFreq<1843200L/0x10000/2) return FALSE;
  dwFreq=1843200L/2/dwFreq;	// Teilerwert
  _asm{
	cli
	mov	al,0xB6	// Timer2: Rechteckgenerator, 16bit
	out	0x43,al
	mov	eax,dwFreq
	out	0x42,al	// Timer2: Endwert Low-Teil setzen
	xchg	ah,al
	out	0x42,al	// Timer2: Endwert High-Teil setzen
	in	al,0x61
	or	al,0x03
	out	0x61,al	// Ein- und Ausgang des Timer2 freischalten
	sti
  }
  Sleep(dwDuration);
  _asm{
	cli
	in	al,0x61
	and	al,~0x03
	out	0x61,al	// Ein- und Ausgang des Timer2 sperren
	sti
  }
  return TRUE;
 }
}
#else
#define MyBeep Beep
#endif

static DWORD WINAPI TwoBeep(void*p) {
 return MyBeep(LOWORD(p),200) && MyBeep(HIWORD(p),200);
}

static DWORD WINAPI Exec(void*p) {
 const TCHAR*filename=(const TCHAR*)p;
 return DWORD(ShellExecute(0,0,filename,0,0,SW_SHOWDEFAULT));
}

static bool DoSound(const TCHAR*filename) {
 if (!filename) return false;
 if (!*filename) return false;
// Der Returnwert von sndPlaySound ist immer true auch wenn's keine Audiodatei ist!
// Daher Endung angucken
 if (!StrCmpI(PathFindExtension(filename),T(".wav"))
 && sndPlaySound(filename,SND_ASYNC)) return true;
// ShellExecute kann muddeln. Daher über gesonderten Thread starten
 CreateThread(0,0,Exec,(void*)filename,0,0);
 return true;
}

static void DoStartSound() {
 if (!DoSound(StartSound)) CreateThread(0,0,TwoBeep,(void*)MAKELONG(300,400),0,0);
// Nicht beim Piepsen blockieren, sofort (parallel) Drucker öffnen
}

static void DoEndSound() {
 if (!DoSound(EndSound)) CreateThread(0,0,TwoBeep,(void*)MAKELONG(400,300),0,0);
}

// Enthält der Dateiname einen Stern,
// wird dieser durch eine Dezimalzahl ersetzt und eine neue Datei erzeugt.
// Wenn nicht, wird die Datei zum Anhängen geöffnet.
static HANDLE CreateUniqueOrAppend(PTSTR filename) {
 //_tcsftime()...
 HANDLE ret=0;
 PTSTR p=StrChr(filename,'*');
 if (p) {
  *p=0;					// String dort zerhacken
  for (DWORD i=1;;i++) {
   TCHAR fname[MAX_PATH];
   wnsprintf(fname,elemof(fname),T("%s%u%s"),filename,i,p+1);
   ret=CreateFile(fname,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_NEW,0,0);
   if (ret!=INVALID_HANDLE_VALUE) break;		// Neue Datei erfolgreich erzeugt
   ret=0;
   if (GetLastError()!=ERROR_ALREADY_EXISTS) break;	// sonstige Fehler brechen ab
  }
  *p='*';				// zurück-ersetzen
 }else{
  ret=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_ALWAYS,0,0);
  if (ret==INVALID_HANDLE_VALUE) ret=0;
  else if (GetLastError()==ERROR_ALREADY_EXISTS) SetFilePointer(ret,0,NULL,FILE_END);
 }
 return ret;
}

int TransferJob(HANDLE hCom) {
#ifndef _DEBUG
 to.ReadTotalTimeoutConstant=0;
 SetCommTimeouts(hCom,&to);
// zunächst unendlich blockieren, bis das erste Zeichen kommt
 DWORD ev;
 ClearCommError(hCom,&ev,NULL);
 SetCommMask(hCom,EV_RXCHAR);
 if (!WaitCommEvent(hCom,&ev,NULL)) return -1;
 SetCommMask(hCom,0);
#endif
 DoStartSound();
#ifndef _DEBUG
// fortan per TimeOut blockieren, um das letzte Zeichen des Druckjobs abzuschätzen
 to.ReadTotalTimeoutConstant=Config.TimeOutMs;
 SetCommTimeouts(hCom,&to);
#endif
 switch (Config.PrintFilter) {
  case 4: {
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
   InitStruct(&si,sizeof(si));
   si.dwFlags=STARTF_USESTDHANDLES;
   si.hStdInput=hCom;
   CreateProcess(NULL,PrinterName,NULL,NULL,TRUE,0,NULL,NULL,&si,&pi);
   WaitForSingleObject(pi.hProcess,INFINITE);
   DoEndSound();
  }break;

  case 3: {	// Dateiausgabe
   HANDLE hFile=CreateUniqueOrAppend(PrinterName);
   if (!hFile) return -2;
   BYTE buffer[1024];
   DWORD br,bw;
   while (ReadFile(hCom,buffer,sizeof(buffer),&br,NULL) && br) {
    if (!WriteFile(hFile,buffer,br,&bw,NULL) || br!=bw) {
     CloseHandle(hFile);
     return -2;
    }
   }
   DoEndSound();
   CloseHandle(hFile);
  }break;

  case 1:
  case 2: {	// Ausgabe mit ESC/P-Interpretation an (GDI-)Drucker
   HDC dc=CreateDC((int)GetVersion()>=0?T("WINSPOOL"):NULL,PrinterName,NULL,NULL);
   if (!dc) goto Ende0;
   DOCINFO di;
   InitStruct(&di,sizeof(di));
   di.lpszDocName=MBoxTitle;
   StartDoc(dc,&di);
   if (!Config.def.ly) ESCP::Default(&Config.def);	// Zeilenabstand Null nicht zulassen!
   ESCP escp;
   escp.Init(&Config.def);			// Vorgaben einsetzen
   escp.Offset.x=MulDiv(Config.PageOffset.x,21600,254);
   escp.Offset.y=MulDiv(Config.PageOffset.y,21600,254);
   escp.mode=Config.PrintFilter;
   escp.f=hCom;
   escp.dc=dc;
   escp.Filter();
   if (Config.keepdef) {
    escp.Save(&Config.def);			// Vorgaben retten
    if (Config.keepdef&2) SaveSettings();	// persistent sogar über Reboots
   }
   EndDoc(dc);
   DeleteDC(dc);
   DoEndSound();
  }break;
  
  case 0: {
   HANDLE hPrinter;
   if (!OpenPrinter(PrinterName,&hPrinter,NULL)) goto Ende0;
   DOC_INFO_1 di;
   InitStruct(&di,sizeof(di));
   di.pDocName=MBoxTitle;
// di.pOutputFile=T("d:\\ttt.prn");	// Test!!
   di.pDatatype=T("RAW");
   if (!StartDocPrinter(hPrinter,1,(LPBYTE)&di)) goto Ende1;
   if (!StartPagePrinter(hPrinter)) goto Ende2;
   BYTE buffer[1024];
   DWORD br,bw;
   while (ReadFile(hCom,buffer,sizeof(buffer),&br,NULL) && br) {
    if (!WritePrinter(hPrinter,buffer,br,&bw) || br!=bw) goto Ende3;
   }
   DoEndSound();
   if (!EndPagePrinter(hPrinter)) goto Ende2;
   if (!EndDocPrinter(hPrinter)) goto Ende1;
   if (!ClosePrinter(hPrinter)) goto Ende0;
   return 0;
Ende3: EndPagePrinter(hPrinter);
Ende2: EndDocPrinter(hPrinter);
Ende1: ClosePrinter(hPrinter);
  }
Ende0: return -2;
 }
 return 0;
}

int WinMainCRTStartup() {
 HANDLE hCom;
 LPTSTR Args;
 Args=PathGetArgs(GetCommandLine());

 LoadString(0,0,MBoxTitle,elemof(MBoxTitle));
// Vorgaben laden
 LoadSettings();
// Benutzerabfrage (bei Notwendigkeit oder Kommandozeilenschalter)
 if (!StrToInt(ModeString+3) || !PrinterName[0] || *Args) {
rep1:
  if (DialogBox(0,MAKEINTRESOURCE(1),0,SetupDlgProc)!=IDOK) ExitProcess(0);
  SaveSettings();
 }
#ifdef _DEBUG
 static TCHAR ComName[]=T("Draft.prn");
#else
 TCHAR ComName[12];
// serielle Schnittstelle öffnen
 wnsprintf(ComName,elemof(ComName),T("\\\\.\\COM%u"),StrToInt(ModeString+3));
#endif
 hCom=CreateFile(ComName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,0);
 if (hCom==INVALID_HANDLE_VALUE) switch (MBox(0,4,MB_RETRYCANCEL,StrToInt(ModeString+3))) {
  case IDRETRY: goto rep1;
  default: ExitProcess(3);
 }
#ifndef _DEBUG
 DCB dcb;
 dcb.DCBlength=sizeof dcb;
 GetCommState(hCom,&dcb);
 BuildCommDCB(ModeString,&dcb);
// COMx [baud=b] [parity=p] [data=d] [stop=s] [to={on|off}]
//	[xon={on|off}] [odsr={on|off}] [octs={on|off}] [dtr={on|off|hs}]
//	[rts={on|off|hs|tg}] [idsr={on|off}]
// oder
// COMx baud,parity,data,stop [,[xp]]
 SetCommState(hCom,&dcb);
#endif
 for (;;) switch (TransferJob(hCom)) {
#ifdef _DEBUG
  case 0: ExitProcess(0);	// Debug: Keine Wiederholungen
#endif
  case -1: switch (MBox(0,1,MB_RETRYCANCEL,StrToInt(ModeString+3))) {
   case IDRETRY: CloseHandle(hCom); goto rep1;
  }ExitProcess(1);
  case -2: switch (MBox(0,2,MB_RETRYCANCEL,PrinterName)) {
   case IDRETRY: CloseHandle(hCom); goto rep1;
  }ExitProcess(2);
 }
// Dieses Programm kann nur gekillt werden.
 return 0;
}

/*******************
 * Hilfsfunktionen *
 *******************/

#ifdef _M_IX86
#if (_MSC_VER>=1400)
#define _alloca_probe _alloca_probe_16
#endif
extern "C" void _declspec(naked) _cdecl _alloca_probe() {
 _asm{	dec	eax
	and	al,0xFC
	sub	esp,eax			// make room
	jmp	dword ptr[esp+eax]	// fetch return address and jump
 }
}
#elif defined(_M_AMD64)
extern "C" void __chkstk() {}		// As all allocations are << 4KByte, stack checking is never needed.
#endif
Detected encoding: UTF-80