/**************/
/* simplew.c  */
/*****************************************************************************
    PROGRAM: simplew.c
    PURPOSE: Runko yksinkertaisille Windows-ohjelmille.
               Kirjoitetaan tiedosto, jossa on funktio
                 MyDraw   (vaikkapa tiedostoon myown.c)
               sekä merkkijono
                 WindowName
               ja tehdään projekti, jossa on tiedostot
                 simplew.c
                 myown.c
                 simplew.def
               ja käännetään!  Siinä se!
                     
    Editor:  Vesa Lappalainen 15.8.1992


- tulostimen vaihto
- tulostuksen keskeytys (kolmio-ohjelma)

*****************************************************************************/
#include <windows.h>            /* Tarvitaan kaikissa Windows C-ohjelmissa  */
#include <string.h>
#include <commdlg.h>
#include "tulmenu.h"
#define CALLBACK_E CALLBACK _export

#define MAINWNAME "SimpleWClass" /* Tunniste, jolla ikkunaluokka tunnetaan  */

#define LSTRCPY(s1,s2) {lstrcpyn((LPSTR)s1,(LPCSTR)s2,sizeof(s1)); s1[sizeof(s1)-1]=0; }

extern char *WindowName;
extern void MyDraw(HWND hWnd,HDC hdc);

typedef struct {
  int BreakPrinting; 
  HWND PrinterDialogHWND;
  HANDLE hInstance;
  FARPROC PrinterDlgFunc;
  FARPROC PrinterBreakFunc;
  HANDLE hPrinterDC;
  char DriverName[80];
  char DeviceName[80];
  char PortName[80];
  PRINTDLG  pd;
} PrinterType;

static PrinterType GP = {0,0};


/****************************************************************************/
int PrinterSetup(void)
{
  LPDEVNAMES lpDevNames;

  /*
   * PrintDlg displays the common dialog box for printing. The
   * PRINTDLG structure should be initialized with appropriate values.
   */
  if ( !GP.pd.lStructSize ) { /* Vain ekalla kerralla alustettavat */
    GP.pd.lStructSize = sizeof(PRINTDLG);
    GP.pd.Flags       = 0;
  }

  GP.pd.hwndOwner   = NULL;
  GP.pd.hDevMode    = NULL;
  GP.pd.hDevNames   = NULL;
  GP.pd.hDC         = 0;

  PrintDlg(&GP.pd);
  lpDevNames = (LPDEVNAMES) GlobalLock(GP.pd.hDevNames);

  LSTRCPY(GP.DriverName,lpDevNames + lpDevNames->wDriverOffset);
  LSTRCPY(GP.DeviceName,lpDevNames + lpDevNames->wDeviceOffset);
  LSTRCPY(GP.PortName  ,lpDevNames + lpDevNames->wOutputOffset);
  GlobalUnlock(GP.pd.hDevNames);
  GlobalFree(GP.pd.hDevNames);
  GlobalFree(GP.pd.hDevMode);
  return 0;
}

/****************************************************************************/
HANDLE get_printer(void)
{
  char s[200],*Ptype,*Pdriver,*Pport;
  if ( !GP.DriverName[0] ) {
    GetProfileString("WINDOWS","DEVICE","",s,sizeof(s));
    if ( (Ptype   = strtok(s,","))    == NULL ||
         (Pdriver = strtok(NULL,",")) == NULL ||
         (Pport   = strtok(NULL,",")) == NULL) return 0;
  }
  else {
    Pdriver = GP.DriverName;
    Ptype   = GP.DeviceName;
    Pport   = GP.PortName; 
  }
  return CreateDC(Pdriver,Ptype,Pport,NULL);
}

/****************************************************************************/
int CALLBACK_E PrinterBreak(HDC hPrinterDC,int code)
{
#pragma argsused
  MSG msg;
  while ( !GP.BreakPrinting && PeekMessage(&msg,NULL,NULL,NULL,TRUE) )
    if ( !IsDialogMessage(GP.PrinterDialogHWND,&msg ) ) {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  return ( !GP.BreakPrinting );
}

/****************************************************************************/
int CALLBACK_E PrinterDialogFunction(HWND hWnd,unsigned message,
                                     WPARAM wParam,LPARAM lParam)
{
#pragma argsused
  switch (message) {
    case WM_COMMAND:
      return ( GP.BreakPrinting = TRUE );

    case WM_INITDIALOG:
      SetFocus(GetDlgItem(hWnd,IDCANCEL));
      return TRUE;
  }
  return FALSE;
}


/****************************************************************************/
int FreePrinterRes(void)
{
  FreeProcInstance(GP.PrinterBreakFunc);
  FreeProcInstance(GP.PrinterDlgFunc);
  DeleteDC(GP.hPrinterDC);
  return 0;
}

/****************************************************************************/
int StartPrinting(HWND hWnd)
{
  int i;
  GP.BreakPrinting = 0;
  GP.hPrinterDC = get_printer();
  GP.PrinterDlgFunc   = MakeProcInstance((FARPROC)PrinterDialogFunction,GP.hInstance);
  GP.PrinterBreakFunc = MakeProcInstance((FARPROC)PrinterBreak,GP.hInstance);

  i = Escape(GP.hPrinterDC,SETABORTPROC,NULL,(LPSTR)(long)GP.PrinterBreakFunc,NULL);
  i++;

  if ( Escape(GP.hPrinterDC,STARTDOC,4," ",NULL) < 0 ) {
    MessageBox(hWnd,"Printer not responding!","",MB_OK | MB_ICONHAND);
    FreePrinterRes();
    return 0;
  }

  GP.PrinterDialogHWND = CreateDialog(GP.hInstance,"BreakPrinter",hWnd,
                                      (DLGPROC)GP.PrinterDlgFunc);

  return 1;
}

/****************************************************************************/
int StopPrinting(void)
{
  if ( !GP.BreakPrinting ) {
    Escape(GP.hPrinterDC, NEWFRAME, 0 , 0L, 0L);
    Escape(GP.hPrinterDC, ENDDOC, 0 , 0L, 0L);
  }
  DestroyWindow(GP.PrinterDialogHWND);
  FreePrinterRes();
  return 1;
}

/****************************************************************************/
LONG CALLBACK_E MainWndProc(HWND hWnd, unsigned message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;

    switch (message)  {

      case WM_PAINT:            /* Viesti: Piirrä ikkuna uudelleen       */
        if ( BeginPaint(hWnd,&ps) )
          MyDraw(hWnd,ps.hdc);
        EndPaint(hWnd,&ps);
        return (NULL);

      case WM_COMMAND:
        switch ( wParam ) {

          case IDM_FILE_PRINT:
            if ( StartPrinting(hWnd) ) {
              TextOut(GP.hPrinterDC,20,50,"Hello World",11);
              MyDraw(hWnd,GP.hPrinterDC);
              StopPrinting();
            }
            return NULL;

          case IDM_FILE_PRINTER_SETUP:
            PrinterSetup();
            return NULL;

          case IDM_FILE_EXIT:
            SendMessage(hWnd,WM_DESTROY,0,0);
            return NULL;
          default: break;
        }
        break;

      case WM_DESTROY:          /* Viesti: ikkuna hävitetään              */
        PostQuitMessage(0);
        return (NULL);

      default:                  /* Antaa Windowsin käsitellä muut         */
        break;
    }
    return (DefWindowProc(hWnd, message, wParam, lParam));
}

/****************************************************************************/
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine, int nCmdShow)
{
#pragma argsused
    WNDCLASS  wc;   /* Ikkunaluokka                                         */
    HWND    hWnd;   /* Pääikkunan kahva                                     */
    MSG msg;        /* Viesti                                               */

    GP.hInstance = hInstance;

    if (!hPrevInstance) {       /* Onko muita esiintymiä käynnisssä?        */
      wc.style         = NULL;           wc.lpfnWndProc    = MainWndProc;   
      wc.cbClsExtra    = 0;              wc.cbWndExtra     = 0;              
      wc.hInstance     = hInstance;       
      wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION); 
      wc.hCursor       = LoadCursor(NULL, IDC_ARROW);   
      wc.hbrBackground = GetStockObject(WHITE_BRUSH); 
      wc.lpszMenuName  = "PRINTMENU";    wc.lpszClassName  = MAINWNAME;
      if (!RegisterClass(&wc)) return (FALSE);  
    }

    hWnd = CreateWindow(MAINWNAME,WindowName,WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,       
                        NULL,NULL,hInstance,NULL);
    if (!hWnd) return (FALSE);
    ShowWindow(hWnd, nCmdShow);     /* Näytetään ikkuna                     */
    UpdateWindow(hWnd);             /* Lähetetään WM_PAINT viesti           */

    while (GetMessage(&msg,NULL,NULL,NULL)) {
        TranslateMessage(&msg);     /* Tulkitaan virtuaaliset näp. koodit   */
        DispatchMessage(&msg);      /* Lähetetään viesti ikkunalle          */
    }
    return (msg.wParam);      /* Palautetaan PostQuitMessage-funktion arvo  */
}