dlls/wineps.drv/driver.c

   1 /*
   2  * Exported functions from the PostScript driver.
   3  *
   4  * [Ext]DeviceMode, DeviceCapabilities, AdvancedSetupDialog.
   5  *
   6  * Will need ExtTextOut for winword6 (urgh!)
   7  *
   8  * Copyright 1998  Huw D M Davies
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winnls.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "prsht.h"
  34 #include "ddk/winddiui.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "psdrv.h"
  39 #include "psdlg.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  42
  43 typedef struct
  44 {
  45     WORD cbSize;
  46     WORD Reserved;
  47     HANDLE hPrinter;
  48     LPCWSTR pszPrinterName;
  49     PDEVMODEW pdmIn;
  50     PDEVMODEW pdmOut;
  51     DWORD cbOut;
  52     DWORD fMode;
  53 } DOCUMENTPROPERTYHEADERW;
  54
  55 /* convert points to paper size units (10th of a millimeter) */
  56 static inline int paper_size_from_points( float size )
  57 {
  58     return size * 254 / 72;
  59 }
  60
  61 INPUTSLOT *find_slot( PPD *ppd, const DEVMODEW *dm )
  62 {
  63     INPUTSLOT *slot;
  64
  65     LIST_FOR_EACH_ENTRY( slot, &ppd->InputSlots, INPUTSLOT, entry )
  66         if (slot->WinBin == dm->dmDefaultSource)
  67             return slot;
  68
  69     return NULL;
  70 }
  71
  72 PAGESIZE *find_pagesize( PPD *ppd, const DEVMODEW *dm )
  73 {
  74     PAGESIZE *page;
  75
  76     LIST_FOR_EACH_ENTRY( page, &ppd->PageSizes, PAGESIZE, entry )
  77         if (page->WinPage == dm->dmPaperSize)
  78             return page;
  79
  80     return NULL;
  81 }
  82
  83 DUPLEX *find_duplex( PPD *ppd, const DEVMODEW *dm )
  84 {
  85     DUPLEX *duplex;
  86     WORD win_duplex = dm->dmFields & DM_DUPLEX ? dm->dmDuplex : 0;
  87
  88     if (win_duplex == 0) return NULL; /* Not capable */
  89
  90     LIST_FOR_EACH_ENTRY( duplex, &ppd->Duplexes, DUPLEX, entry )
  91         if (duplex->WinDuplex == win_duplex)
  92             return duplex;
  93
  94     return NULL;
  95 }
  96
  97 /************************************************************************
  98  *
  99  *              PSDRV_MergeDevmodes
 100  *
 101  * Updates dm1 with some fields from dm2
 102  *
 103  */
 104 void PSDRV_MergeDevmodes( PSDRV_DEVMODE *dm1, const DEVMODEW *dm2, PRINTERINFO *pi )
 105 {
 106     /* some sanity checks here on dm2 */
 107
 108     if(dm2->dmFields & DM_ORIENTATION) {
 109         dm1->dmPublic.dmOrientation = dm2->dmOrientation;
 110         TRACE("Changing orientation to %d (%s)\n",
 111               dm1->dmPublic.dmOrientation,
 112               dm1->dmPublic.dmOrientation == DMORIENT_PORTRAIT ?
 113               "Portrait" :
 114               (dm1->dmPublic.dmOrientation == DMORIENT_LANDSCAPE ?
 115                "Landscape" : "unknown"));
 116     }
 117
 118     /* NB PaperWidth is always < PaperLength */
 119     if (dm2->dmFields & DM_PAPERSIZE)
 120     {
 121         PAGESIZE *page = find_pagesize( pi->ppd, dm2 );
 122
 123         if (page)
 124         {
 125             dm1->dmPublic.dmPaperSize = dm2->dmPaperSize;
 126             dm1->dmPublic.dmPaperWidth  = paper_size_from_points( page->PaperDimension->x );
 127             dm1->dmPublic.dmPaperLength = paper_size_from_points( page->PaperDimension->y );
 128             dm1->dmPublic.dmFields |= DM_PAPERSIZE | DM_PAPERWIDTH | DM_PAPERLENGTH;
 129             TRACE("Changing page to %s %d x %d\n", debugstr_w(page->FullName),
 130                   dm1->dmPublic.dmPaperWidth,
 131                   dm1->dmPublic.dmPaperLength );
 132
 133             if (dm1->dmPublic.dmSize >= FIELD_OFFSET(DEVMODEW, dmFormName) + CCHFORMNAME * sizeof(WCHAR))
 134             {
 135                 lstrcpynW(dm1->dmPublic.dmFormName, page->FullName, CCHFORMNAME);
 136                 dm1->dmPublic.dmFields |= DM_FORMNAME;
 137             }
 138         }
 139         else
 140             TRACE("Trying to change to unsupported pagesize %d\n", dm2->dmPaperSize);
 141     }
 142
 143     else if((dm2->dmFields & DM_PAPERLENGTH) &&
 144        (dm2->dmFields & DM_PAPERWIDTH)) {
 145         dm1->dmPublic.dmPaperLength = dm2->dmPaperLength;
 146         dm1->dmPublic.dmPaperWidth = dm2->dmPaperWidth;
 147         TRACE("Changing PaperLength|Width to %dx%d\n",
 148               dm2->dmPaperLength,
 149               dm2->dmPaperWidth);
 150         dm1->dmPublic.dmFields &= ~DM_PAPERSIZE;
 151         dm1->dmPublic.dmFields |= (DM_PAPERLENGTH | DM_PAPERWIDTH);
 152     } else if(dm2->dmFields & (DM_PAPERLENGTH | DM_PAPERWIDTH)) {
 153       /* You might think that this would be allowed if dm1 is in custom size
 154          mode, but apparently Windows reverts to standard paper mode even in
 155          this case */
 156         FIXME("Trying to change only paperlength or paperwidth\n");
 157         dm1->dmPublic.dmFields &= ~(DM_PAPERLENGTH | DM_PAPERWIDTH);
 158         dm1->dmPublic.dmFields |= DM_PAPERSIZE;
 159     }
 160
 161     if(dm2->dmFields & DM_SCALE) {
 162         dm1->dmPublic.dmScale = dm2->dmScale;
 163         TRACE("Changing Scale to %d\n", dm2->dmScale);
 164     }
 165
 166     if(dm2->dmFields & DM_COPIES) {
 167         dm1->dmPublic.dmCopies = dm2->dmCopies;
 168         TRACE("Changing Copies to %d\n", dm2->dmCopies);
 169     }
 170
 171     if (dm2->dmFields & DM_DEFAULTSOURCE)
 172     {
 173         INPUTSLOT *slot = find_slot( pi->ppd, dm2 );
 174
 175         if (slot)
 176         {
 177             dm1->dmPublic.dmDefaultSource = dm2->dmDefaultSource;
 178             TRACE("Changing bin to '%s'\n", slot->FullName);
 179         }
 180         else
 181             TRACE("Trying to change to unsupported bin %d\n", dm2->dmDefaultSource);
 182     }
 183
 184    if (dm2->dmFields & DM_DEFAULTSOURCE )
 185        dm1->dmPublic.dmDefaultSource = dm2->dmDefaultSource;
 186    if (dm2->dmFields & DM_PRINTQUALITY )
 187        dm1->dmPublic.dmPrintQuality = dm2->dmPrintQuality;
 188    if (dm2->dmFields & DM_COLOR )
 189        dm1->dmPublic.dmColor = dm2->dmColor;
 190    if (dm2->dmFields & DM_DUPLEX && pi->ppd->DefaultDuplex && pi->ppd->DefaultDuplex->WinDuplex != 0)
 191        dm1->dmPublic.dmDuplex = dm2->dmDuplex;
 192    if (dm2->dmFields & DM_YRESOLUTION )
 193        dm1->dmPublic.dmYResolution = dm2->dmYResolution;
 194    if (dm2->dmFields & DM_TTOPTION )
 195        dm1->dmPublic.dmTTOption = dm2->dmTTOption;
 196    if (dm2->dmFields & DM_COLLATE )
 197        dm1->dmPublic.dmCollate = dm2->dmCollate;
 198    if (dm2->dmFields & DM_FORMNAME )
 199        lstrcpynW(dm1->dmPublic.dmFormName, dm2->dmFormName, CCHFORMNAME);
 200    if (dm2->dmFields & DM_BITSPERPEL )
 201        dm1->dmPublic.dmBitsPerPel = dm2->dmBitsPerPel;
 202    if (dm2->dmFields & DM_PELSWIDTH )
 203        dm1->dmPublic.dmPelsWidth = dm2->dmPelsWidth;
 204    if (dm2->dmFields & DM_PELSHEIGHT )
 205        dm1->dmPublic.dmPelsHeight = dm2->dmPelsHeight;
 206    if (dm2->dmFields & DM_DISPLAYFLAGS )
 207        dm1->dmPublic.dmDisplayFlags = dm2->dmDisplayFlags;
 208    if (dm2->dmFields & DM_DISPLAYFREQUENCY )
 209        dm1->dmPublic.dmDisplayFrequency = dm2->dmDisplayFrequency;
 210    if (dm2->dmFields & DM_POSITION )
 211        dm1->dmPublic.dmPosition = dm2->dmPosition;
 212    if (dm2->dmFields & DM_LOGPIXELS )
 213        dm1->dmPublic.dmLogPixels = dm2->dmLogPixels;
 214    if (dm2->dmFields & DM_ICMMETHOD )
 215        dm1->dmPublic.dmICMMethod = dm2->dmICMMethod;
 216    if (dm2->dmFields & DM_ICMINTENT )
 217        dm1->dmPublic.dmICMIntent = dm2->dmICMIntent;
 218    if (dm2->dmFields & DM_MEDIATYPE )
 219        dm1->dmPublic.dmMediaType = dm2->dmMediaType;
 220    if (dm2->dmFields & DM_DITHERTYPE )
 221        dm1->dmPublic.dmDitherType = dm2->dmDitherType;
 222    if (dm2->dmFields & DM_PANNINGWIDTH )
 223        dm1->dmPublic.dmPanningWidth = dm2->dmPanningWidth;
 224    if (dm2->dmFields & DM_PANNINGHEIGHT )
 225        dm1->dmPublic.dmPanningHeight = dm2->dmPanningHeight;
 226
 227     return;
 228 }
 229
 230
 231 typedef struct
 232 {
 233     PRINTERINFO *pi;
 234     PSDRV_DEVMODE *dlgdm;
 235 } PSDRV_DLGINFO;
 236
 237 /****************************************************************
 238  *       PSDRV_PaperDlgProc
 239  *
 240  * Dialog proc for 'Paper' propsheet
 241  */
 242 static INT_PTR CALLBACK PSDRV_PaperDlgProc(HWND hwnd, UINT msg,
 243                                            WPARAM wParam, LPARAM lParam)
 244 {
 245   PSDRV_DLGINFO *di;
 246   int i, Cursel;
 247   PAGESIZE *ps;
 248   DUPLEX *duplex;
 249   RESOLUTION *res;
 250
 251   switch(msg) {
 252   case WM_INITDIALOG:
 253     di = (PSDRV_DLGINFO*)((PROPSHEETPAGEA*)lParam)->lParam;
 254     SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)di);
 255
 256     i = Cursel = 0;
 257     LIST_FOR_EACH_ENTRY(ps, &di->pi->ppd->PageSizes, PAGESIZE, entry) {
 258       SendDlgItemMessageA(hwnd, IDD_PAPERS, LB_INSERTSTRING, i,
 259                           (LPARAM)ps->FullName);
 260       if(di->pi->Devmode->dmPublic.dmPaperSize == ps->WinPage)
 261         Cursel = i;
 262       i++;
 263     }
 264     SendDlgItemMessageA(hwnd, IDD_PAPERS, LB_SETCURSEL, Cursel, 0);
 265
 266     CheckRadioButton(hwnd, IDD_ORIENT_PORTRAIT, IDD_ORIENT_LANDSCAPE,
 267                      di->pi->Devmode->dmPublic.dmOrientation ==
 268                      DMORIENT_PORTRAIT ? IDD_ORIENT_PORTRAIT :
 269                      IDD_ORIENT_LANDSCAPE);
 270
 271     if (list_empty( &di->pi->ppd->Duplexes ))
 272     {
 273         ShowWindow(GetDlgItem(hwnd, IDD_DUPLEX), SW_HIDE);
 274         ShowWindow(GetDlgItem(hwnd, IDD_DUPLEX_NAME), SW_HIDE);
 275     }
 276     else
 277     {
 278         i = Cursel = 0;
 279         LIST_FOR_EACH_ENTRY( duplex, &di->pi->ppd->Duplexes, DUPLEX, entry )
 280         {
 281             SendDlgItemMessageA(hwnd, IDD_DUPLEX, CB_INSERTSTRING, i,
 282                                 (LPARAM)(duplex->FullName ? duplex->FullName : duplex->Name));
 283             if(di->pi->Devmode->dmPublic.dmDuplex == duplex->WinDuplex)
 284                 Cursel = i;
 285             i++;
 286         }
 287         SendDlgItemMessageA(hwnd, IDD_DUPLEX, CB_SETCURSEL, Cursel, 0);
 288     }
 289
 290     if (list_empty( &di->pi->ppd->Resolutions ))
 291     {
 292         int len, res;
 293         WCHAR buf[256];
 294
 295         res = di->pi->ppd->DefaultResolution;
 296         len = swprintf(buf, ARRAY_SIZE(buf), L"%d", res);
 297         buf[len++] = ' ';
 298         LoadStringW(PSDRV_hInstance, IDS_DPI, buf + len, ARRAY_SIZE(buf) - len);
 299         SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_ADDSTRING, 0, (LPARAM)buf);
 300         SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_SETITEMDATA, 0, MAKELONG(res, res));
 301         Cursel = 0;
 302     }
 303     else
 304     {
 305         int resx, resy;
 306
 307         Cursel = 0;
 308         resx = resy = di->pi->ppd->DefaultResolution;
 309
 310         if (di->pi->Devmode->dmPublic.dmFields & DM_PRINTQUALITY)
 311             resx = resy = di->pi->Devmode->dmPublic.dmPrintQuality;
 312
 313         if (di->pi->Devmode->dmPublic.dmFields & DM_YRESOLUTION)
 314             resy = di->pi->Devmode->dmPublic.dmYResolution;
 315
 316         if (di->pi->Devmode->dmPublic.dmFields & DM_LOGPIXELS)
 317             resx = resy = di->pi->Devmode->dmPublic.dmLogPixels;
 318
 319         LIST_FOR_EACH_ENTRY(res, &di->pi->ppd->Resolutions, RESOLUTION, entry)
 320         {
 321             int len;
 322             WCHAR buf[256];
 323             DWORD idx;
 324
 325             if (res->resx == res->resy)
 326                 len = swprintf(buf, ARRAY_SIZE(buf), L"%d", res->resx);
 327             else
 328                 len = swprintf(buf, ARRAY_SIZE(buf), L"%dx%d", res->resx, res->resy);
 329             buf[len++] = ' ';
 330             LoadStringW(PSDRV_hInstance, IDS_DPI, buf + len, ARRAY_SIZE(buf) - len);
 331             idx = SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_ADDSTRING, 0, (LPARAM)buf);
 332             SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_SETITEMDATA, idx, MAKELONG(res->resx, res->resy));
 333
 334             if (res->resx == resx && res->resy == resy)
 335                 Cursel = idx;
 336         }
 337     }
 338     SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_SETCURSEL, Cursel, 0);
 339
 340     break;
 341
 342   case WM_COMMAND:
 343     di = (PSDRV_DLGINFO *)GetWindowLongPtrW(hwnd, DWLP_USER);
 344     switch(LOWORD(wParam)) {
 345     case IDD_PAPERS:
 346       if(HIWORD(wParam) == LBN_SELCHANGE) {
 347         Cursel = SendDlgItemMessageA(hwnd, LOWORD(wParam), LB_GETCURSEL, 0, 0);
 348         i = 0;
 349         LIST_FOR_EACH_ENTRY(ps, &di->pi->ppd->PageSizes, PAGESIZE, entry) {
 350             if(i >= Cursel) break;
 351             i++;
 352         }
 353         TRACE("Setting pagesize to item %d, WinPage %d (%s), PaperSize %.2fx%.2f\n", Cursel,
 354               ps->WinPage, debugstr_w(ps->FullName), ps->PaperDimension->x, ps->PaperDimension->y);
 355         di->dlgdm->dmPublic.dmPaperSize = ps->WinPage;
 356         di->dlgdm->dmPublic.dmFields |= DM_PAPERSIZE;
 357
 358         di->dlgdm->dmPublic.dmPaperWidth  = paper_size_from_points(ps->PaperDimension->x);
 359         di->dlgdm->dmPublic.dmPaperLength = paper_size_from_points(ps->PaperDimension->y);
 360         di->dlgdm->dmPublic.dmFields |= DM_PAPERLENGTH | DM_PAPERWIDTH;
 361
 362         if (di->dlgdm->dmPublic.dmSize >= FIELD_OFFSET(DEVMODEW, dmFormName) + CCHFORMNAME * sizeof(WCHAR))
 363         {
 364             lstrcpynW(di->dlgdm->dmPublic.dmFormName, ps->FullName, CCHFORMNAME);
 365             di->dlgdm->dmPublic.dmFields |= DM_FORMNAME;
 366         }
 367         SendMessageW(GetParent(hwnd), PSM_CHANGED, 0, 0);
 368       }
 369       break;
 370     case IDD_ORIENT_PORTRAIT:
 371     case IDD_ORIENT_LANDSCAPE:
 372       TRACE("Setting orientation to %s\n", wParam == IDD_ORIENT_PORTRAIT ?
 373             "portrait" : "landscape");
 374       di->dlgdm->dmPublic.dmOrientation = wParam == IDD_ORIENT_PORTRAIT ?
 375         DMORIENT_PORTRAIT : DMORIENT_LANDSCAPE;
 376       di->dlgdm->dmPublic.dmFields |= DM_ORIENTATION;
 377       SendMessageW(GetParent(hwnd), PSM_CHANGED, 0, 0);
 378       break;
 379     case IDD_DUPLEX:
 380       if(HIWORD(wParam) == CBN_SELCHANGE) {
 381         Cursel = SendDlgItemMessageA(hwnd, LOWORD(wParam), CB_GETCURSEL, 0, 0);
 382         i = 0;
 383         LIST_FOR_EACH_ENTRY( duplex, &di->pi->ppd->Duplexes, DUPLEX, entry )
 384         {
 385             if (i >= Cursel) break;
 386             i++;
 387         }
 388         TRACE("Setting duplex to item %d Winduplex = %d\n", Cursel, duplex->WinDuplex);
 389         di->dlgdm->dmPublic.dmDuplex = duplex->WinDuplex;
 390         di->dlgdm->dmPublic.dmFields |= DM_DUPLEX;
 391         SendMessageW(GetParent(hwnd), PSM_CHANGED, 0, 0);
 392       }
 393       break;
 394
 395     case IDD_QUALITY:
 396       if (HIWORD(wParam) == CBN_SELCHANGE)
 397       {
 398         LPARAM data;
 399         int resx, resy;
 400
 401         Cursel = SendDlgItemMessageW(hwnd, LOWORD(wParam), CB_GETCURSEL, 0, 0);
 402         data = SendDlgItemMessageW(hwnd, IDD_QUALITY, CB_GETITEMDATA, Cursel, 0);
 403
 404         resx = LOWORD(data);
 405         resy = HIWORD(data);
 406         TRACE("Setting resolution to %dx%d\n", resx, resy);
 407
 408         di->dlgdm->dmPublic.dmPrintQuality = resx;
 409         di->dlgdm->dmPublic.dmFields |= DM_PRINTQUALITY;
 410
 411         di->dlgdm->dmPublic.dmYResolution = resy;
 412         di->dlgdm->dmPublic.dmFields |= DM_YRESOLUTION;
 413
 414         if (di->pi->Devmode->dmPublic.dmFields & DM_LOGPIXELS)
 415         {
 416             di->dlgdm->dmPublic.dmLogPixels = resx;
 417             di->dlgdm->dmPublic.dmFields |= DM_LOGPIXELS;
 418         }
 419
 420         SendMessageW(GetParent(hwnd), PSM_CHANGED, 0, 0);
 421       }
 422       break;
 423     }
 424     break;
 425
 426   case WM_NOTIFY:
 427    {
 428     NMHDR *nmhdr = (NMHDR *)lParam;
 429     di = (PSDRV_DLGINFO *)GetWindowLongPtrW(hwnd, DWLP_USER);
 430     switch(nmhdr->code) {
 431     case PSN_APPLY:
 432       *di->pi->Devmode = *di->dlgdm;
 433       SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, PSNRET_NOERROR);
 434       return TRUE;
 435
 436     default:
 437       return FALSE;
 438     }
 439     break;
 440    }
 441
 442   default:
 443     return FALSE;
 444   }
 445   return TRUE;
 446 }
 447
 448 /******************************************************************************
 449  *           DrvDocumentPropertySheets (wineps.drv.@)
 450  */
 451 LONG WINAPI DrvDocumentPropertySheets(PROPSHEETUI_INFO *info, LPARAM lparam)
 452 {
 453     DOCUMENTPROPERTYHEADERW *dph;
 454     PRINTERINFO *pi;
 455
 456     TRACE("(info=%p, lparam=%Id)\n", info, lparam);
 457
 458     dph = (DOCUMENTPROPERTYHEADERW *)(info ? info->lParamInit : lparam);
 459
 460     if (!(pi = PSDRV_FindPrinterInfo(dph->pszPrinterName))) return ERR_CPSUI_GETLASTERROR;
 461
 462     if (!info || info->Reason == PROPSHEETUI_REASON_INIT)
 463     {
 464         /* If dph->fMode == 0, return size of DEVMODE structure */
 465         if (!dph->fMode || !dph->pdmOut)
 466         {
 467             dph->cbOut = pi->Devmode->dmPublic.dmSize + pi->Devmode->dmPublic.dmDriverExtra;
 468             return dph->cbOut;
 469         }
 470
 471         /* If DM_MODIFY is set, change settings in accordance with pdmIn */
 472         if ((dph->fMode & DM_MODIFY) && dph->pdmIn)
 473         {
 474             TRACE("DM_MODIFY set. devIn->dmFields = %08lx\n", dph->pdmIn->dmFields);
 475             PSDRV_MergeDevmodes(pi->Devmode, dph->pdmIn, pi);
 476         }
 477
 478         /* If DM_PROMPT is set, present modal dialog box */
 479         if (dph->fMode & DM_PROMPT)
 480         {
 481             PROPSHEETPAGEW psp;
 482             PSDRV_DLGINFO *di;
 483
 484             if (!info)
 485             {
 486                 ERR("DM_PROMPT passed with NULL PROPSHEETUI_INFO\n");
 487                 return ERR_CPSUI_GETLASTERROR;
 488             }
 489
 490             di = malloc(sizeof(*di));
 491             if (!di)
 492                 return ERR_CPSUI_ALLOCMEM_FAILED;
 493             info->UserData = (ULONG_PTR)di;
 494
 495             di->dlgdm = malloc(sizeof(*di->dlgdm));
 496             if (!di->dlgdm)
 497                 return ERR_CPSUI_ALLOCMEM_FAILED;
 498
 499             memset(&psp, 0, sizeof(psp));
 500             di->pi = pi;
 501             *di->dlgdm = *pi->Devmode;
 502             psp.dwSize = sizeof(psp);
 503             psp.hInstance = PSDRV_hInstance;
 504             psp.pszTemplate = L"PAPER";
 505             psp.pszIcon = NULL;
 506             psp.pfnDlgProc = PSDRV_PaperDlgProc;
 507             psp.lParam = (LPARAM)di;
 508
 509             if (!info->pfnComPropSheet(info->hComPropSheet, CPSFUNC_ADD_PROPSHEETPAGEW, (LPARAM)&psp, 0))
 510                 return ERR_CPSUI_GETLASTERROR;
 511         }
 512     }
 513
 514     if (info && info->Reason == PROPSHEETUI_REASON_DESTROY)
 515     {
 516         if (info->UserData)
 517             free(((PSDRV_DLGINFO *)info->UserData)->dlgdm);
 518         free((void *)info->UserData);
 519     }
 520
 521     if (!info || (info->Reason == PROPSHEETUI_REASON_DESTROY && lparam))
 522     {
 523         /* If DM_UPDATE is set, should write settings to environment and initialization file */
 524         if (dph->fMode & DM_UPDATE)
 525             FIXME("Mode DM_UPDATE.  Just do the same as DM_COPY\n");
 526
 527         /* If DM_COPY is set, should write settings to pdmOut */
 528         if (dph->pdmOut && (dph->fMode & (DM_COPY | DM_UPDATE)))
 529             memcpy(dph->pdmOut, &pi->Devmode->dmPublic,
 530                     pi->Devmode->dmPublic.dmSize + pi->Devmode->dmPublic.dmDriverExtra);
 531     }
 532
 533     return CPSUI_OK;
 534 }
 535
 536 /******************************************************************************
 537  *           DrvDeviceCapabilities    (wineps.drv.@)
 538  */
 539 DWORD WINAPI DrvDeviceCapabilities(HANDLE printer, WCHAR *device_name, WORD capability,
 540                                    void *output, DEVMODEW *devmode)
 541 {
 542   PRINTERINFO *pi;
 543   DEVMODEW *lpdm;
 544   DWORD ret;
 545
 546   TRACE("%s %u, %p, %p\n", debugstr_w(device_name), capability, output, devmode);
 547
 548   if (!(pi = PSDRV_FindPrinterInfo(device_name))) {
 549       ERR("no printer info for %s, return 0!\n", debugstr_w(device_name));
 550       return 0;
 551   }
 552
 553   lpdm = &pi->Devmode->dmPublic;
 554   if (devmode) lpdm = devmode;
 555
 556   switch(capability) {
 557
 558   case DC_PAPERS:
 559     {
 560       PAGESIZE *ps;
 561       WORD *wp = output;
 562       int i = 0;
 563
 564       LIST_FOR_EACH_ENTRY(ps, &pi->ppd->PageSizes, PAGESIZE, entry)
 565       {
 566         TRACE("DC_PAPERS: %u\n", ps->WinPage);
 567         i++;
 568         if (output != NULL) *wp++ = ps->WinPage;
 569       }
 570       ret = i;
 571       break;
 572     }
 573
 574   case DC_PAPERSIZE:
 575     {
 576       PAGESIZE *ps;
 577       POINT *pt = output;
 578       int i = 0;
 579
 580       LIST_FOR_EACH_ENTRY(ps, &pi->ppd->PageSizes, PAGESIZE, entry)
 581       {
 582         TRACE("DC_PAPERSIZE: %f x %f\n", ps->PaperDimension->x, ps->PaperDimension->y);
 583         i++;
 584         if (output != NULL) {
 585           pt->x = paper_size_from_points( ps->PaperDimension->x );
 586           pt->y = paper_size_from_points( ps->PaperDimension->y );
 587           pt++;
 588         }
 589       }
 590       ret = i;
 591       break;
 592     }
 593
 594   case DC_PAPERNAMES:
 595     {
 596       PAGESIZE *ps;
 597       WCHAR *cp = output;
 598       int i = 0;
 599
 600       LIST_FOR_EACH_ENTRY(ps, &pi->ppd->PageSizes, PAGESIZE, entry)
 601       {
 602         TRACE("DC_PAPERNAMES: %s\n", debugstr_w(ps->FullName));
 603         i++;
 604         if (output != NULL) {
 605           lstrcpynW(cp, ps->FullName, 64);
 606           cp += 64;
 607         }
 608       }
 609       ret = i;
 610       break;
 611     }
 612
 613   case DC_ORIENTATION:
 614     ret = pi->ppd->LandscapeOrientation ? pi->ppd->LandscapeOrientation : 90;
 615     break;
 616
 617   case DC_BINS:
 618     {
 619       INPUTSLOT *slot;
 620       WORD *wp = output;
 621       int i = 0;
 622
 623       LIST_FOR_EACH_ENTRY( slot, &pi->ppd->InputSlots, INPUTSLOT, entry )
 624       {
 625           i++;
 626           if (output != NULL)
 627               *wp++ = slot->WinBin;
 628       }
 629       ret = i;
 630       break;
 631     }
 632
 633   case DC_BINNAMES:
 634     {
 635       INPUTSLOT *slot;
 636       WCHAR *cp = output;
 637       int i = 0;
 638
 639       LIST_FOR_EACH_ENTRY( slot, &pi->ppd->InputSlots, INPUTSLOT, entry )
 640       {
 641           i++;
 642           if (output != NULL)
 643           {
 644               MultiByteToWideChar(CP_ACP, 0, slot->FullName, -1, cp, 24);
 645               cp += 24;
 646           }
 647       }
 648       ret = i;
 649       break;
 650     }
 651
 652   case DC_BINADJUST:
 653     FIXME("DC_BINADJUST: stub.\n");
 654     ret = DCBA_FACEUPNONE;
 655     break;
 656
 657   case DC_ENUMRESOLUTIONS:
 658     {
 659         RESOLUTION *res;
 660         LONG *lp = output;
 661         int i = 0;
 662
 663         LIST_FOR_EACH_ENTRY(res, &pi->ppd->Resolutions, RESOLUTION, entry)
 664         {
 665             i++;
 666             if (output != NULL)
 667             {
 668                 lp[0] = res->resx;
 669                 lp[1] = res->resy;
 670                 lp += 2;
 671             }
 672         }
 673         ret = i;
 674         break;
 675     }
 676
 677   /* Windows returns 9999 too */
 678   case DC_COPIES:
 679     TRACE("DC_COPIES: returning 9999\n");
 680     ret = 9999;
 681     break;
 682
 683   case DC_DRIVER:
 684     ret = lpdm->dmDriverVersion;
 685     break;
 686
 687   case DC_DATATYPE_PRODUCED:
 688     FIXME("DATA_TYPE_PRODUCED: stub.\n");
 689     ret = -1; /* simulate that the driver supports 'RAW' */
 690     break;
 691
 692   case DC_DUPLEX:
 693     ret = 0;
 694     if(pi->ppd->DefaultDuplex && pi->ppd->DefaultDuplex->WinDuplex != 0)
 695       ret = 1;
 696     TRACE("DC_DUPLEX: returning %ld\n", ret);
 697     break;
 698
 699   case DC_EMF_COMPLIANT:
 700     FIXME("DC_EMF_COMPLIANT: stub.\n");
 701     ret = -1; /* simulate that the driver do not support EMF */
 702     break;
 703
 704   case DC_EXTRA:
 705     ret = lpdm->dmDriverExtra;
 706     break;
 707
 708   case DC_FIELDS:
 709     ret = lpdm->dmFields;
 710     break;
 711
 712   case DC_FILEDEPENDENCIES:
 713     FIXME("DC_FILEDEPENDENCIES: stub.\n");
 714     ret = 0;
 715     break;
 716
 717   case DC_MAXEXTENT:
 718     {
 719       PAGESIZE *ps;
 720       float x = 0, y = 0;
 721
 722       LIST_FOR_EACH_ENTRY(ps, &pi->ppd->PageSizes, PAGESIZE, entry)
 723       {
 724           if (ps->PaperDimension->x > x) x = ps->PaperDimension->x;
 725           if (ps->PaperDimension->y > y) y = ps->PaperDimension->y;
 726       }
 727       ret = MAKELONG( paper_size_from_points(x), paper_size_from_points(y) );
 728       break;
 729     }
 730
 731   case DC_MINEXTENT:
 732     {
 733       PAGESIZE *ps;
 734       float x = 1e6, y = 1e6;
 735
 736       LIST_FOR_EACH_ENTRY(ps, &pi->ppd->PageSizes, PAGESIZE, entry)
 737       {
 738           if (ps->PaperDimension->x < x) x = ps->PaperDimension->x;
 739           if (ps->PaperDimension->y < y) y = ps->PaperDimension->y;
 740       }
 741       ret = MAKELONG( paper_size_from_points(x), paper_size_from_points(y) );
 742       break;
 743     }
 744
 745   case DC_SIZE:
 746     ret = lpdm->dmSize;
 747     break;
 748
 749   case DC_TRUETYPE:
 750     FIXME("DC_TRUETYPE: stub\n");
 751     ret = DCTT_SUBDEV;
 752     break;
 753
 754   case DC_VERSION:
 755     ret = lpdm->dmSpecVersion;
 756     break;
 757
 758   /* We'll just return false here, very few printers can collate anyway */
 759   case DC_COLLATE:
 760     TRACE("DC_COLLATE: returning FALSE\n");
 761     ret = FALSE;
 762     break;
 763
 764   /* Printer supports colour printing - 1 if yes, 0 if no (Win2k/XP only) */
 765   case DC_COLORDEVICE:
 766     ret = pi->ppd->ColorDevice != CD_False;
 767     break;
 768
 769   /* Identification number of the printer manufacturer for use with ICM (Win9x only) */
 770   case DC_MANUFACTURER:
 771     FIXME("DC_MANUFACTURER: stub\n");
 772     ret = -1;
 773     break;
 774
 775   /* Identification number of the printer model for use with ICM (Win9x only) */
 776   case DC_MODEL:
 777     FIXME("DC_MODEL: stub\n");
 778     ret = -1;
 779     break;
 780
 781   /* Nonzero if the printer supports stapling, zero otherwise (Win2k/XP only) */
 782   case DC_STAPLE: /* WINVER >= 0x0500 */
 783     FIXME("DC_STAPLE: stub\n");
 784     ret = -1;
 785     break;
 786
 787   /* Returns an array of 64-character string buffers containing the names of the paper forms
 788    * available for use, unless pOutput is NULL.  The return value is the number of paper forms.
 789    * (Win2k/XP only)
 790    */
 791   case DC_MEDIAREADY: /* WINVER >= 0x0500 */
 792     FIXME("DC_MEDIAREADY: stub\n");
 793     ret = -1;
 794     break;
 795
 796   /* Returns an array of 64-character string buffers containing the names of the supported
 797    * media types, unless pOutput is NULL.  The return value is the number of supported.
 798    * media types (XP only)
 799    */
 800   case DC_MEDIATYPENAMES: /* WINVER >= 0x0501 */
 801     FIXME("DC_MEDIATYPENAMES: stub\n");
 802     ret = -1;
 803     break;
 804
 805   /* Returns an array of DWORD values which represent the supported media types, unless
 806    * pOutput is NULL.  The return value is the number of supported media types. (XP only)
 807    */
 808   case DC_MEDIATYPES: /* WINVER >= 0x0501 */
 809     FIXME("DC_MEDIATYPES: stub\n");
 810     ret = -1;
 811     break;
 812
 813   /* Returns an array of DWORD values, each representing a supported number of document
 814    * pages per printed page, unless pOutput is NULL.  The return value is the number of
 815    * array entries. (Win2k/XP only)
 816    */
 817   case DC_NUP:
 818     FIXME("DC_NUP: stub\n");
 819     ret = -1;
 820     break;
 821
 822   /* Returns an array of 32-character string buffers containing a list of printer description
 823    * languages supported by the printer, unless pOutput is NULL.  The return value is
 824    * number of array entries. (Win2k/XP only)
 825    */
 826   case DC_PERSONALITY: /* WINVER >= 0x0500 */
 827     FIXME("DC_PERSONALITY: stub\n");
 828     ret = -1;
 829     break;
 830
 831   /* Returns the amount of printer memory in kilobytes. (Win2k/XP only) */
 832   case DC_PRINTERMEM: /* WINVER >= 0x0500 */
 833     FIXME("DC_PRINTERMEM: stub\n");
 834     ret = -1;
 835     break;
 836
 837   /* Returns the printer's print rate in PRINTRATEUNIT units. (Win2k/XP only) */
 838   case DC_PRINTRATE: /* WINVER >= 0x0500 */
 839     FIXME("DC_PRINTRATE: stub\n");
 840     ret = -1;
 841     break;
 842
 843   /* Returns the printer's print rate in pages per minute. (Win2k/XP only) */
 844   case DC_PRINTRATEPPM: /* WINVER >= 0x0500 */
 845     FIXME("DC_PRINTRATEPPM: stub\n");
 846     ret = -1;
 847     break;
 848
 849   /* Returns the printer rate unit used for DC_PRINTRATE, which is one of
 850    * PRINTRATEUNIT_{CPS,IPM,LPM,PPM} (Win2k/XP only)
 851    */
 852   case DC_PRINTRATEUNIT: /* WINVER >= 0x0500 */
 853     FIXME("DC_PRINTRATEUNIT: stub\n");
 854     ret = -1;
 855     break;
 856
 857   default:
 858     FIXME("Unsupported capability %d\n", capability);
 859     ret = -1;
 860   }
 861
 862   return ret;
 863 }
 864
 865 #if 0
 866 typedef struct {
 867   DWORD nPages;
 868   DWORD Unknown;
 869   HPROPSHEETPAGE hPages[10];
 870 } EDMPS;
 871
 872 INT PSDRV_ExtDeviceModePropSheet(HWND hwnd, LPSTR lpszDevice, LPSTR lpszPort,
 873                                  LPVOID pPropSheet)
 874 {
 875     EDMPS *ps = pPropSheet;
 876     PROPSHEETPAGE psp;
 877
 878     psp->dwSize = sizeof(psp);
 879     psp->hInstance = 0x1234;
 880
 881     ps->nPages = 1;
 882
 883 }
 884
 885 #endif