Changeset 21630 for trunk/src


Ignore:
Timestamp:
Apr 26, 2011, 9:00:45 PM (14 years ago)
Author:
dmik
Message:

comdlg32: Made PrintDlg() use the native PM print dialog instead of the Win32 clone. This looks much more native and gives access to all printer settings. Note that PageSetupDlg() is a no-op now (always returns FALSE) but it's not really necessary since thew native dialog gives access to page settings as well.

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comdlg32/comdlg32.cpp

    r6437 r21630  
    4444  a->hwndOwner = Win32ToOS2Handle(a->hwndOwner);
    4545
     46// from gdi32/devcontext.cpp
     47BOOL WIN32API GetPMQueueName(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue);
     48
     49// USING_OPEN32 seems to be not necessary since the WGSS GlobalAlloc API appears
     50// to be in line with the Odin32 GlobalAlloc API (and the current version of
     51// WGSS doesn't export this API anyway)
     52
    4653#ifdef USING_OPEN32
    4754
    … …  
    4956#define FLAG_FROM_OPEN32     1
    5057
    51 //******************************************************************************
    52 //******************************************************************************
    53 HGLOBAL GlobalCopy(HGLOBAL hDest, HGLOBAL hSource, BOOL fToOpen32)
     58static HGLOBAL GlobalCopy(HGLOBAL hDest, HGLOBAL hSource, BOOL fToOpen32)
    5459{
    55  LPVOID src;
    56  LPVOID dest;
    57  ULONG  size;
    58 
    59       if(fToOpen32 == FLAG_TO_OPEN32) {
    60           src = GlobalLock(hSource);
    61           if(src) {
    62               size = GlobalSize(hSource);
    63               if(hDest == NULL) {
    64                   hDest = O32_GlobalAlloc(GHND, size);
    65               }
    66               dest  = O32_GlobalLock(hDest);
    67               memcpy(dest, src, size);
    68               O32_GlobalUnlock(hDest);
    69           }
    70           GlobalUnlock(hSource);
    71       }
    72       else {
    73           src = O32_GlobalLock(hSource);
    74           if(src) {
    75               size = O32_GlobalSize(hSource);
    76               if(hDest == NULL) {
    77                   hDest = GlobalAlloc(GHND, size);
    78               }
    79               dest  = GlobalLock(hDest);
    80               memcpy(dest, src, size);
    81               GlobalUnlock(hDest);
    82           }
    83           O32_GlobalUnlock(hSource);
    84       }
    85       return hDest;
     60    LPVOID src;
     61    LPVOID dest;
     62    ULONG  size;
     63
     64    if (fToOpen32 == FLAG_TO_OPEN32)
     65    {
     66        src = GlobalLock(hSource);
     67        if (src)
     68        {
     69            size = GlobalSize(hSource);
     70            if(hDest == NULL)
     71            {
     72                hDest = O32_GlobalAlloc(GHND, size);
     73            }
     74            dest = O32_GlobalLock(hDest);
     75            memcpy(dest, src, size);
     76            O32_GlobalUnlock(hDest);
     77        }
     78        GlobalUnlock(hSource);
     79    }
     80    else
     81    {
     82        src = O32_GlobalLock(hSource);
     83        if (src)
     84        {
     85            size = O32_GlobalSize(hSource);
     86            if(hDest == NULL)
     87            {
     88                hDest = GlobalAlloc(GHND, size);
     89            }
     90            dest  = GlobalLock(hDest);
     91            memcpy(dest, src, size);
     92            GlobalUnlock(hDest);
     93        }
     94        O32_GlobalUnlock(hSource);
     95    }
     96    return hDest;
    8697}
     98
     99#define MyGlobalAlloc   O32_GlobalAlloc
     100#define MyGlobalLock    O32_GlobalLock
     101#define MyGlobalUnlock  O32_GlobalUnlock
     102#define MyGlobalFree    O32_GlobalFree
     103#define MyGlobalSize    O32_GlobalSize
     104
     105#else
     106
     107#define MyGlobalAlloc   GlobalAlloc
     108#define MyGlobalLock    GlobalLock
     109#define MyGlobalUnlock  GlobalUnlock
     110#define MyGlobalFree    GlobalFree
     111#define MyGlobalSize    GlobalSize
     112
    87113#endif
    88 #if 1
     114
    89115/*****************************************************************************
    90116 * Name      :
    … …  
    102128              LPPRINTDLGA, lppd)
    103129{
    104   BOOL      ret;
     130    BOOL      ret;
    105131#ifdef USING_OPEN32
    106   HGLOBAL   hDevmode = 0, hDevNames = 0;
    107   HGLOBAL   hOrgDevmode = 0, hOrgDevNames = 0;
    108   DEVMODEA *devmode, *devmodeorg;
    109   DEVNAMES *devnames, *devnamesorg;
    110   ULONG     size;
     132    HGLOBAL   hOrgDevMode = 0, hOrgDevNames = 0;
    111133#endif
    112 
    113   COMDLG32_CHECKHOOK2(lppd, PD_ENABLEPRINTHOOK, LPPRINTHOOKPROC,lpfnPrintHook)
    114   COMDLG32_CHECKHOOK2(lppd, PD_ENABLESETUPHOOK, LPSETUPHOOKPROC,lpfnSetupHook)
     134    LPSTR     origDevice = NULL;
     135
     136    COMDLG32_CHECKHOOK2(lppd, PD_ENABLEPRINTHOOK, LPPRINTHOOKPROC,lpfnPrintHook)
     137    COMDLG32_CHECKHOOK2(lppd, PD_ENABLESETUPHOOK, LPSETUPHOOKPROC,lpfnSetupHook)
    115138
    116139#ifdef USING_OPEN32
    117   if(lppd->hDevMode) {
    118       hOrgDevmode = lppd->hDevMode;
    119       lppd->hDevMode = GlobalCopy(NULL, hOrgDevmode, FLAG_TO_OPEN32);
    120   }
    121   if(lppd->hDevNames) {
    122       hOrgDevNames = lppd->hDevNames;
    123       lppd->hDevNames = GlobalCopy(NULL, hOrgDevNames, FLAG_TO_OPEN32);
    124   }
     140    if (lppd->hDevMode)
     141    {
     142        hOrgDevMode = lppd->hDevMode;
     143        lppd->hDevMode = GlobalCopy(NULL, hOrgDevMode, FLAG_TO_OPEN32);
     144    }
     145    if (lppd->hDevNames)
     146    {
     147        hOrgDevNames = lppd->hDevNames;
     148        lppd->hDevNames = GlobalCopy(NULL, hOrgDevNames, FLAG_TO_OPEN32);
     149    }
    125150#endif
    126   HWND hwndOwner = lppd->hwndOwner;
    127   if(lppd->hwndOwner) {
    128       lppd->hwndOwner = Win32ToOS2Handle(lppd->hwndOwner);
    129   }
    130   ret = O32_PrintDlg(lppd);
    131   lppd->hwndOwner = hwndOwner;
     151
     152    if (lppd->hDevNames)
     153    {
     154        LPDEVNAMES devNames = (LPDEVNAMES)MyGlobalLock(lppd->hDevNames);
     155
     156        LPSTR driver = (LPSTR)devNames + devNames->wDriverOffset;
     157        LPSTR device = (LPSTR)devNames + devNames->wDeviceOffset;
     158        LPSTR output = (LPSTR)devNames + devNames->wOutputOffset;
     159        int driverLen = lstrlenA(driver) + 1;
     160        int deviceLen = lstrlenA(device) + 1;
     161        int outputLen = lstrlenA(output) + 1;
     162
     163        // get the PM queue name for the device (which is usually the full
     164        // PM printer's WPS object name): WGSS expects it and will correctly
     165        // pre-select the printer specified in hDevNames. Note that we don't
     166        // perform the opposite conversion from the PM queue to the device name
     167        // after calling O32_PrintDlg() since this seems to work as it is:
     168        // the dialog returns the correct DC when OK is pressed despite the name
     169        // mismatch
     170
     171        CHAR queue[256];
     172        if (GetPMQueueName(device, queue, sizeof(queue)))
     173        {
     174            dprintf(("PrintDlgA: renamed device {%s} to PM queue {%s}",
     175                     device, queue));
     176            device = queue;
     177            deviceLen = lstrlenA(device) + 1;
     178
     179            HGLOBAL hDevNames2 =
     180                MyGlobalAlloc(GHND, MyGlobalSize(lppd->hDevNames) +
     181                              lstrlenA(queue) - (deviceLen - 1));
     182
     183            LPDEVNAMES devNames2 = (LPDEVNAMES)MyGlobalLock(hDevNames2);
     184
     185            devNames2->wDriverOffset = sizeof(DEVNAMES);
     186            memcpy((LPSTR)devNames2 + devNames2->wDriverOffset, driver, driverLen);
     187            devNames2->wDeviceOffset = devNames2->wDriverOffset + driverLen;
     188            memcpy((LPSTR)devNames2 + devNames2->wDeviceOffset, device, deviceLen);
     189            devNames2->wOutputOffset = devNames2->wDeviceOffset + deviceLen;
     190            memcpy((LPSTR)devNames2 + devNames2->wOutputOffset, output, outputLen);
     191            devNames2->wDefault = devNames->wDefault;
     192
     193            MyGlobalUnlock(hDevNames2);
     194
     195            MyGlobalUnlock(lppd->hDevNames);
     196            MyGlobalFree(lppd->hDevNames);
     197            lppd->hDevNames = hDevNames2;
     198        }
     199        else
     200            MyGlobalUnlock(lppd->hDevNames);
     201    }
     202
     203    HWND hwndOwner = lppd->hwndOwner;
     204    if (lppd->hwndOwner)
     205    {
     206        lppd->hwndOwner = Win32ToOS2Handle(lppd->hwndOwner);
     207    }
     208
     209    ret = O32_PrintDlg(lppd);
     210
     211    lppd->hwndOwner = hwndOwner;
     212
    132213#ifdef USING_OPEN32
    133   if(ret == TRUE) {
    134       if(lppd->hDevMode) {
    135           hDevmode = lppd->hDevMode;
    136           lppd->hDevMode = GlobalCopy(hOrgDevmode, lppd->hDevMode, FLAG_FROM_OPEN32);
    137           O32_GlobalFree(hDevmode);
    138       }
    139       if(lppd->hDevNames) {
    140           hDevNames = lppd->hDevNames;
    141           lppd->hDevNames = GlobalCopy(hOrgDevNames, lppd->hDevNames, FLAG_FROM_OPEN32);
    142           O32_GlobalFree(hDevNames);
    143       }
    144   }
     214    if (ret == TRUE)
     215    {
     216        if (lppd->hDevMode)
     217        {
     218            HGLOBAL hDevMode = lppd->hDevMode;
     219            lppd->hDevMode = GlobalCopy(hOrgDevMode, lppd->hDevMode,
     220                                        FLAG_FROM_OPEN32);
     221            O32_GlobalFree(hDevMode);
     222        }
     223        if (lppd->hDevNames)
     224        {
     225            HGLOBAL hDevNames = lppd->hDevNames;
     226            lppd->hDevNames = GlobalCopy(hOrgDevNames, lppd->hDevNames,
     227                                         FLAG_FROM_OPEN32);
     228            O32_GlobalFree(hDevNames);
     229        }
     230    }
     231    else
     232    {
     233        if (lppd->hDevMode)
     234        {
     235            O32_GlobalFree(lppd->hDevMode);
     236            lppd->hDevMode = hOrgDevMode;
     237        }
     238        if (lppd->hDevNames)
     239        {
     240            O32_GlobalFree(lppd->hDevNames);
     241            lppd->hDevNames = hOrgDevNames;
     242        }
     243    }
    145244#endif
    146   if(lppd->hDC) {
    147       OSLibGpiSetCp(lppd->hDC, GetDisplayCodepage());
    148   }
    149   return ret;
     245
     246    if(lppd->hDC)
     247    {
     248        OSLibGpiSetCp(lppd->hDC, GetDisplayCodepage());
     249    }
     250
     251    return ret;
    150252}
    151253
    … …  
    166268              LPPRINTDLGW, lppd)
    167269{
    168 
    169   PRINTDLGA pd;
    170   BOOL      bResult;
    171 
    172   //SvL: TODO: hDevMode & hDevNames
    173   dprintf(("PrintDlgW: ERROR NOT COMPLETE (UNICODE TRANSLATION)!!"));
    174 
    175   memcpy(&pd,          // make binary copy first to save all the fields
    176          lppd,
    177          sizeof(pd));
    178 
    179   // convert to ASCII string
    180   if ((lppd->Flags & PD_ENABLEPRINTTEMPLATE) &&
    181       (lppd->lpPrintTemplateName != NULL))
    182     pd.lpPrintTemplateName = UnicodeToAsciiString((WCHAR*)lppd->lpPrintTemplateName);
    183   else
    184     pd.lpPrintTemplateName = NULL;
    185 
    186   if ((lppd->Flags & PD_ENABLESETUPTEMPLATE) &&
    187       (lppd->lpSetupTemplateName != NULL))
    188     pd.lpSetupTemplateName = UnicodeToAsciiString((WCHAR*)lppd->lpSetupTemplateName);
    189   else
    190     pd.lpSetupTemplateName = NULL;
    191 
    192   COMDLG32_CHECKHOOK2((&pd), PD_ENABLEPRINTHOOK, LPPRINTHOOKPROC,lpfnPrintHook)
    193   COMDLG32_CHECKHOOK2((&pd), PD_ENABLESETUPHOOK, LPSETUPHOOKPROC,lpfnSetupHook)
    194 
    195   bResult = O32_PrintDlg(&pd); // call ASCII API
    196 
    197   if (pd.lpPrintTemplateName != NULL) FreeAsciiString((char*)pd.lpPrintTemplateName);
    198   if (pd.lpSetupTemplateName != NULL) FreeAsciiString((char*)pd.lpSetupTemplateName);
    199 
    200   // copy back result
    201   lppd->Flags     = pd.Flags;
    202   lppd->nFromPage = pd.nFromPage;
    203   lppd->nToPage   = pd.nToPage;
    204   lppd->nMinPage  = pd.nMinPage;
    205   lppd->nMaxPage  = pd.nMaxPage;
    206   lppd->nCopies   = pd.nCopies;
    207   //@@@PH: all pass-back fields ?
    208 
    209   return bResult;
     270    PRINTDLGA pd;
     271    BOOL      bResult;
     272
     273    memcpy(&pd,          // make binary copy first to save all the fields
     274           lppd,
     275           sizeof(pd));
     276
     277    if (lppd->hwndOwner)
     278    {
     279        pd.hwndOwner = Win32ToOS2Handle(lppd->hwndOwner);
     280    }
     281
     282    if (lppd->hDevMode)
     283    {
     284        LPDEVMODEW devMode = (LPDEVMODEW)GlobalLock(lppd->hDevMode);
     285
     286        dprintf(("PrintDlgW: in devMode{%.*ls,%.*ls}",
     287                 CCHDEVICENAME, devMode->dmDeviceName,
     288                 CCHFORMNAME, devMode->dmFormName));
     289
     290        pd.hDevMode = MyGlobalAlloc(GHND, sizeof(DEVMODEA));
     291
     292        LPDEVMODEA devModeA = (LPDEVMODEA)MyGlobalLock(pd.hDevMode);
     293
     294        // convert to ASCII string
     295        UnicodeToAsciiN((LPWSTR)devMode->dmDeviceName, (LPSTR)devModeA->dmDeviceName,
     296                        CCHDEVICENAME);
     297        UnicodeToAsciiN((LPWSTR)devMode->dmFormName, (LPSTR)devModeA->dmFormName,
     298                        CCHFORMNAME);
     299
     300        MyGlobalLock(pd.hDevMode);
     301        GlobalLock(lppd->hDevMode);
     302    }
     303
     304    if (lppd->hDevNames)
     305    {
     306        LPDEVNAMES devNames = (LPDEVNAMES)GlobalLock(lppd->hDevNames);
     307
     308        dprintf(("PrintDlgW: in devNames{%ls,%ls,%ls}",
     309                 (LPCWSTR)devNames + devNames->wDriverOffset,
     310                 (LPCWSTR)devNames + devNames->wDeviceOffset,
     311                 (LPCWSTR)devNames + devNames->wOutputOffset));
     312
     313        // convert to ASCII string
     314        LPSTR driver = UnicodeToAsciiString((LPCWSTR)devNames + devNames->wDriverOffset);
     315        LPSTR device = UnicodeToAsciiString((LPCWSTR)devNames + devNames->wDeviceOffset);
     316        LPSTR output = UnicodeToAsciiString((LPCWSTR)devNames + devNames->wOutputOffset);
     317        int driverLen = lstrlenA(driver) + 1;
     318        int deviceLen = lstrlenA(device) + 1;
     319        int outputLen = lstrlenA(output) + 1;
     320
     321        // get the PM queue name for the device (which is usually the full
     322        // PM printer's WPS object name): WGSS expects it and will correctly
     323        // pre-select the printer specified in hDevNames. Note that we don't
     324        // perform the opposite conversion from the PM queue to the device name
     325        // after calling O32_PrintDlg() since this seems to work as it is:
     326        // the dialog returns the correct DC when OK is pressed despite the name
     327        // mismatch
     328
     329        CHAR queue[256];
     330        if (GetPMQueueName(device, queue, sizeof(queue)))
     331        {
     332            dprintf(("PrintDlgW: renamed device {%s} to PM queue {%s}",
     333                     device, queue));
     334            device = queue;
     335            deviceLen = lstrlenA(device) + 1;
     336        }
     337
     338        pd.hDevNames = MyGlobalAlloc(GHND, sizeof(DEVNAMES) +
     339                                     driverLen + deviceLen + outputLen);
     340
     341        LPDEVNAMES devNamesA = (LPDEVNAMES)MyGlobalLock(pd.hDevNames);
     342
     343        devNamesA->wDriverOffset = sizeof(DEVNAMES);
     344        memcpy((LPSTR)devNamesA + devNamesA->wDriverOffset, driver, driverLen);
     345        devNamesA->wDeviceOffset = devNamesA->wDriverOffset + driverLen;
     346        memcpy((LPSTR)devNamesA + devNamesA->wDeviceOffset, device, deviceLen);
     347        devNamesA->wOutputOffset = devNamesA->wDeviceOffset + deviceLen;
     348        memcpy((LPSTR)devNamesA + devNamesA->wOutputOffset, output, outputLen);
     349        devNamesA->wDefault = devNames->wDefault;
     350
     351        FreeAsciiString(output);
     352        if (device != queue)
     353            FreeAsciiString(device);
     354        FreeAsciiString(driver);
     355
     356        MyGlobalUnlock(pd.hDevNames);
     357        GlobalUnlock(lppd->hDevNames);
     358    }
     359
     360    // convert to ASCII string
     361    if ((lppd->Flags & PD_ENABLEPRINTTEMPLATE) &&
     362        (lppd->lpPrintTemplateName != NULL))
     363        pd.lpPrintTemplateName = UnicodeToAsciiString((WCHAR*)lppd->lpPrintTemplateName);
     364    else
     365        pd.lpPrintTemplateName = NULL;
     366
     367    if ((lppd->Flags & PD_ENABLESETUPTEMPLATE) &&
     368        (lppd->lpSetupTemplateName != NULL))
     369        pd.lpSetupTemplateName = UnicodeToAsciiString((WCHAR*)lppd->lpSetupTemplateName);
     370    else
     371        pd.lpSetupTemplateName = NULL;
     372
     373    COMDLG32_CHECKHOOK2((&pd), PD_ENABLEPRINTHOOK, LPPRINTHOOKPROC, lpfnPrintHook)
     374    COMDLG32_CHECKHOOK2((&pd), PD_ENABLESETUPHOOK, LPSETUPHOOKPROC, lpfnSetupHook)
     375
     376    bResult = O32_PrintDlg(&pd); // call ASCII API
     377
     378    if (pd.lpPrintTemplateName != NULL)
     379        FreeAsciiString((char*)pd.lpPrintTemplateName);
     380    if (pd.lpSetupTemplateName != NULL)
     381        FreeAsciiString((char*)pd.lpSetupTemplateName);
     382
     383    if (pd.hDevNames)
     384    {
     385        LPDEVNAMES devNames = (LPDEVNAMES)MyGlobalLock(pd.hDevNames);
     386
     387        dprintf(("PrintDlgW: out devNames{%s,%s,%s}",
     388                 (LPCSTR)devNames + devNames->wDriverOffset,
     389                 (LPCSTR)devNames + devNames->wDeviceOffset,
     390                 (LPCSTR)devNames + devNames->wOutputOffset));
     391
     392        LPSTR realDevice = (LPSTR)devNames + devNames->wDeviceOffset;
     393
     394        // convert from ASCII string
     395        LPWSTR driver = AsciiToUnicodeString((LPCSTR)devNames + devNames->wDriverOffset);
     396        LPWSTR device = AsciiToUnicodeString(realDevice);
     397        LPWSTR output = AsciiToUnicodeString((LPCSTR)devNames + devNames->wOutputOffset);
     398        int driverLen = (lstrlenW(driver) + 1) * sizeof(WCHAR);
     399        int deviceLen = (lstrlenW(device) + 1) * sizeof(WCHAR);
     400        int outputLen = (lstrlenW(output) + 1) * sizeof(WCHAR);
     401
     402        if (lppd->hDevNames)
     403            lppd->hDevNames = GlobalReAlloc(lppd->hDevNames,
     404                                            sizeof(DEVNAMES) +
     405                                            driverLen + deviceLen + outputLen,
     406                                            GHND);
     407        else
     408            lppd->hDevNames = GlobalAlloc(GHND, sizeof(DEVNAMES) +
     409                                          driverLen + deviceLen + outputLen);
     410
     411        LPDEVNAMES devNamesW = (LPDEVNAMES)GlobalLock(lppd->hDevNames);
     412
     413        devNamesW->wDriverOffset = sizeof(DEVNAMES) / sizeof(WCHAR);
     414        memcpy((LPWSTR)devNamesW + devNamesW->wDriverOffset, driver, driverLen);
     415        devNamesW->wDeviceOffset = devNamesW->wDriverOffset + (driverLen / sizeof(WCHAR));
     416        memcpy((LPWSTR)devNamesW + devNamesW->wDeviceOffset, device, deviceLen);
     417        devNamesW->wOutputOffset = devNamesW->wDeviceOffset + (deviceLen / sizeof(WCHAR));
     418        memcpy((LPWSTR)devNamesW + devNamesW->wOutputOffset, output, outputLen);
     419        devNamesW->wDefault = devNames->wDefault;
     420
     421        FreeAsciiString(output);
     422        FreeAsciiString(device);
     423        FreeAsciiString(driver);
     424
     425        GlobalUnlock(lppd->hDevNames);
     426        MyGlobalUnlock(pd.hDevNames);
     427
     428        MyGlobalFree(pd.hDevNames);
     429    }
     430    else
     431    {
     432         if (lppd->hDevNames)
     433            MyGlobalFree(lppd->hDevNames);
     434         lppd->hDevNames = NULL;
     435    }
     436
     437    if (pd.hDevMode)
     438    {
     439        LPDEVMODEA devMode = (LPDEVMODEA)MyGlobalLock(pd.hDevMode);
     440
     441        dprintf(("PrintDlgW: out devMode{%.*s,%.*s}",
     442                 CCHDEVICENAME, devMode->dmDeviceName,
     443                 CCHFORMNAME, devMode->dmFormName));
     444
     445        if (!lppd->hDevMode)
     446            lppd->hDevMode = GlobalAlloc(GHND, sizeof(DEVMODEW));
     447
     448        LPDEVMODEW devModeW = (LPDEVMODEW)GlobalLock(lppd->hDevMode);
     449
     450        // convert from ASCII string
     451        AsciiToUnicodeN((LPSTR)devMode->dmDeviceName, (LPWSTR)devModeW->dmDeviceName,
     452                        CCHDEVICENAME);
     453        AsciiToUnicodeN((LPSTR)devMode->dmFormName, (LPWSTR)devModeW->dmFormName,
     454                        CCHFORMNAME);
     455
     456        memcpy(&devModeW->dmSpecVersion, &devMode->dmSpecVersion,
     457               offsetof(DEVMODEW, dmFormName) - offsetof(DEVMODEW, dmSpecVersion));
     458        memcpy(&devModeW->dmLogPixels, &devMode->dmLogPixels,
     459               sizeof(DEVMODEW) - offsetof(DEVMODEW, dmLogPixels));
     460
     461        GlobalUnlock(lppd->hDevMode);
     462        MyGlobalUnlock(pd.hDevMode);
     463
     464        MyGlobalFree(pd.hDevMode);
     465    }
     466    else
     467    {
     468         if (lppd->hDevNames)
     469            MyGlobalFree(lppd->hDevNames);
     470         lppd->hDevNames = NULL;
     471    }
     472
     473    // copy back the rest
     474    lppd->hDC       = pd.hDC;
     475    lppd->Flags     = pd.Flags;
     476    lppd->nFromPage = pd.nFromPage;
     477    lppd->nToPage   = pd.nToPage;
     478    lppd->nMinPage  = pd.nMinPage;
     479    lppd->nMaxPage  = pd.nMaxPage;
     480    lppd->nCopies   = pd.nCopies;
     481
     482    if (lppd->hDC)
     483    {
     484        OSLibGpiSetCp(lppd->hDC, GetDisplayCodepage());
     485    }
     486
     487    return bResult;
    210488}
    211489
    … …  
    258536}
    259537
    260 #endif

  • trunk/src/comdlg32/makefile

    r21342 r21630  
    3636$(OBJDIR)\filedlg.obj \
    3737$(OBJDIR)\filedlg95.obj \
    38 ##$(OBJDIR)\comdlg32.obj \
     38$(OBJDIR)\comdlg32.obj \
    3939$(OBJDIR)\filedlgbrowser.obj \
    40 $(OBJDIR)\printdlg.obj \
     40##$(OBJDIR)\printdlg.obj \
    4141$(OBJDIR)\rsrc.obj
    4242

  • trunk/src/gdi32/devcontext.cpp

    r21304 r21630  
    5454//
    5555//******************************************************************************
    56 static BOOL GetPMQueueName(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue)
     56BOOL WIN32API GetPMQueueName(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue)
    5757{
    5858    static HINSTANCE                hInstance = 0;
    … …  
    8686    else
    8787    { //Check if it's a printer device
    88         if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE) 
     88        if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
    8989        {
    9090            dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
    … …  
    149149      devmode.dmPaperSize     = arg4->dmPaperSize;
    150150      devmode.dmPaperLength   = arg4->dmPaperLength;
    151       devmode.dmPaperWidth    = arg4->dmPaperWidth;
    152 #else
    153       devmode.s1.dmOrientation   = arg4->s1.dmOrientation;
    154       devmode.s1.dmPaperSize     = arg4->s1.dmPaperSize;
    155       devmode.s1.dmPaperLength   = arg4->s1.dmPaperLength;
    156       devmode.s1.dmPaperWidth    = arg4->s1.dmPaperWidth;
    157 #endif
    158       devmode.dmScale            = arg4->dmScale;
    159       devmode.dmCopies           = arg4->dmCopies;
    160       devmode.dmDefaultSource    = arg4->dmDefaultSource;
    161       devmode.dmPrintQuality     = arg4->dmPrintQuality;
    162       devmode.dmColor            = arg4->dmColor;
    163       devmode.dmDuplex           = arg4->dmDuplex;
    164       devmode.dmYResolution      = arg4->dmYResolution;
    165       devmode.dmTTOption         = arg4->dmTTOption;
    166       devmode.dmCollate          = arg4->dmCollate;
    167       devmode.dmLogPixels        = arg4->dmLogPixels;
    168       devmode.dmBitsPerPel       = arg4->dmBitsPerPel;
    169       devmode.dmPelsWidth        = arg4->dmPelsWidth;
    170       devmode.dmPelsHeight       = arg4->dmPelsHeight;
    171       devmode.dmDisplayFlags     = arg4->dmDisplayFlags;
    172       devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
    173       devmode.dmICMMethod        = arg4->dmICMMethod;
    174       devmode.dmICMIntent        = arg4->dmICMIntent;
    175       devmode.dmMediaType        = arg4->dmMediaType;
    176       devmode.dmDitherType       = arg4->dmDitherType;
    177       devmode.dmReserved1        = arg4->dmReserved1;
    178       devmode.dmReserved2        = arg4->dmReserved2;
    179       rc = CreateDCA(astring1,astring2,astring3,&devmode);
    180     }
    181     else
    182       rc = CreateDCA(astring1,astring2,astring3, NULL);
    183 
    184     FreeAsciiString(astring1);
    185     FreeAsciiString(astring2);
    186     FreeAsciiString(astring3);
    187 
    188     if(arg4)
    189     {
    190       FreeAsciiString(astring4);
    191       FreeAsciiString(astring5);
    192     }
    193 
    194     return rc;
    195 }
    196 //******************************************************************************
    197 //******************************************************************************
    198 HDC WIN32API CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput,
    199                        const DEVMODEA *lpdvmInit)
    200 {
    201     HDC  hdc;
    202     char szDevice[256];
    203 
    204     //SvL: Open32 tests for "DISPLAY"
    205     if(lpszDriver && !stricmp(lpszDriver, szDisplay)) {
    206         lpszDriver = szDisplay;
    207     }
    208     else
    209     { //Check if it's a printer device
    210         if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
    211         {
    212             dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
    213             lpszDevice = szDevice;
    214             //Must ignore port name here or else the wrong queue might be used
    215             //(unless we are told to print to file)
    216             if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
    217                 lpszOutput = NULL;
    218         }
    219     }
    220  
    221     //SvL: Open32 tests lpszDriver for NULL even though it's ignored
    222     if(lpszDriver == NULL) {
    223         lpszDriver = lpszDevice;
    224     }
    225     hdc = O32_CreateIC(lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
    226 
    227     dprintf(("GDI32: CreateICA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpdvmInit, hdc));
    228 
    229     if(hdc) STATS_CreateICA(hdc, lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
    230     return hdc;
    231 }
    232 //******************************************************************************
    233 //******************************************************************************
    234 HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
    235 {
    236     char *astring4, *astring5;
    237 
    238     char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
    239     char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
    240     char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
    241     if(arg4)
    242     {
    243       astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
    244       astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
    245     }
    246 
    247     HDC   rc;
    248     DEVMODEA devmode;
    249 
    250     if(arg4)
    251     {
    252       strcpy((char*)devmode.dmDeviceName, astring4);
    253       strcpy((char*)devmode.dmFormName, astring5);
    254 
    255       devmode.dmSpecVersion      = arg4->dmSpecVersion;
    256       devmode.dmDriverVersion    = arg4->dmDriverVersion;
    257       devmode.dmSize             = arg4->dmSize;
    258       devmode.dmDriverExtra      = arg4->dmDriverExtra;
    259       devmode.dmFields           = arg4->dmFields;
    260 #if (__IBMCPP__ == 360)
    261       devmode.dmOrientation      = arg4->dmOrientation;
    262       devmode.dmPaperSize        = arg4->dmPaperSize;
    263       devmode.dmPaperLength      = arg4->dmPaperLength;
    264       devmode.dmPaperWidth       = arg4->dmPaperWidth;
     151      devmode.dmPaperWidth    = arg4->dmPaperWidth;
    265152#else
    266153      devmode.s1.dmOrientation   = arg4->s1.dmOrientation;
    … …  
    290177      devmode.dmReserved1        = arg4->dmReserved1;
    291178      devmode.dmReserved2        = arg4->dmReserved2;
     179      rc = CreateDCA(astring1,astring2,astring3,&devmode);
     180    }
     181    else
     182      rc = CreateDCA(astring1,astring2,astring3, NULL);
     183
     184    FreeAsciiString(astring1);
     185    FreeAsciiString(astring2);
     186    FreeAsciiString(astring3);
     187
     188    if(arg4)
     189    {
     190      FreeAsciiString(astring4);
     191      FreeAsciiString(astring5);
     192    }
     193
     194    return rc;
     195}
     196//******************************************************************************
     197//******************************************************************************
     198HDC WIN32API CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput,
     199                       const DEVMODEA *lpdvmInit)
     200{
     201    HDC  hdc;
     202    char szDevice[256];
     203
     204    //SvL: Open32 tests for "DISPLAY"
     205    if(lpszDriver && !stricmp(lpszDriver, szDisplay)) {
     206        lpszDriver = szDisplay;
     207    }
     208    else
     209    { //Check if it's a printer device
     210        if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
     211        {
     212            dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
     213            lpszDevice = szDevice;
     214            //Must ignore port name here or else the wrong queue might be used
     215            //(unless we are told to print to file)
     216            if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
     217                lpszOutput = NULL;
     218        }
     219    }
     220
     221    //SvL: Open32 tests lpszDriver for NULL even though it's ignored
     222    if(lpszDriver == NULL) {
     223        lpszDriver = lpszDevice;
     224    }
     225    hdc = O32_CreateIC(lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
     226
     227    dprintf(("GDI32: CreateICA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpdvmInit, hdc));
     228
     229    if(hdc) STATS_CreateICA(hdc, lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
     230    return hdc;
     231}
     232//******************************************************************************
     233//******************************************************************************
     234HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
     235{
     236    char *astring4, *astring5;
     237
     238    char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
     239    char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
     240    char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
     241    if(arg4)
     242    {
     243      astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
     244      astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
     245    }
     246
     247    HDC   rc;
     248    DEVMODEA devmode;
     249
     250    if(arg4)
     251    {
     252      strcpy((char*)devmode.dmDeviceName, astring4);
     253      strcpy((char*)devmode.dmFormName, astring5);
     254
     255      devmode.dmSpecVersion      = arg4->dmSpecVersion;
     256      devmode.dmDriverVersion    = arg4->dmDriverVersion;
     257      devmode.dmSize             = arg4->dmSize;
     258      devmode.dmDriverExtra      = arg4->dmDriverExtra;
     259      devmode.dmFields           = arg4->dmFields;
     260#if (__IBMCPP__ == 360)
     261      devmode.dmOrientation      = arg4->dmOrientation;
     262      devmode.dmPaperSize        = arg4->dmPaperSize;
     263      devmode.dmPaperLength      = arg4->dmPaperLength;
     264      devmode.dmPaperWidth       = arg4->dmPaperWidth;
     265#else
     266      devmode.s1.dmOrientation   = arg4->s1.dmOrientation;
     267      devmode.s1.dmPaperSize     = arg4->s1.dmPaperSize;
     268      devmode.s1.dmPaperLength   = arg4->s1.dmPaperLength;
     269      devmode.s1.dmPaperWidth    = arg4->s1.dmPaperWidth;
     270#endif
     271      devmode.dmScale            = arg4->dmScale;
     272      devmode.dmCopies           = arg4->dmCopies;
     273      devmode.dmDefaultSource    = arg4->dmDefaultSource;
     274      devmode.dmPrintQuality     = arg4->dmPrintQuality;
     275      devmode.dmColor            = arg4->dmColor;
     276      devmode.dmDuplex           = arg4->dmDuplex;
     277      devmode.dmYResolution      = arg4->dmYResolution;
     278      devmode.dmTTOption         = arg4->dmTTOption;
     279      devmode.dmCollate          = arg4->dmCollate;
     280      devmode.dmLogPixels        = arg4->dmLogPixels;
     281      devmode.dmBitsPerPel       = arg4->dmBitsPerPel;
     282      devmode.dmPelsWidth        = arg4->dmPelsWidth;
     283      devmode.dmPelsHeight       = arg4->dmPelsHeight;
     284      devmode.dmDisplayFlags     = arg4->dmDisplayFlags;
     285      devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
     286      devmode.dmICMMethod        = arg4->dmICMMethod;
     287      devmode.dmICMIntent        = arg4->dmICMIntent;
     288      devmode.dmMediaType        = arg4->dmMediaType;
     289      devmode.dmDitherType       = arg4->dmDitherType;
     290      devmode.dmReserved1        = arg4->dmReserved1;
     291      devmode.dmReserved2        = arg4->dmReserved2;
    292292
    293293      rc = CreateICA(astring1,astring2,astring3,&devmode);
    … …  
    370370    if(pHps->hrgnWin32Clip) {
    371371        // Make a copy of our current clip region
    372         // (the visible region remains untouched!)     
     372        // (the visible region remains untouched!)
    373373        hClipRgn = GdiCopyClipRgn(pHps);
    374374    }
    … …  
    420420HDC WIN32API ResetDCA(HDC hdc, const DEVMODEA *lpInitData)
    421421{
    422     if(lpInitData) 
     422    if(lpInitData)
    423423    {
    424424        dprintfDEVMODE((DEVMODEA *)lpInitData);

  • trunk/src/gdi32/gdi32.DEF

    r21335 r21630  
    389389    _GdiCombineVisRgnClipRgn@12                                 @1220 NONAME
    390390
     391    _GetPMQueueName@12                                          @1221 NONAME

  • trunk/src/gdi32/gdi32dbg.def

    r21335 r21630  
    389389    _GdiSetVisRgn@8                                             @1219 NONAME
    390390    _GdiCombineVisRgnClipRgn@12                                 @1220 NONAME
     391
     392    _GetPMQueueName@12                                          @1221 NONAME
Note: See TracChangeset for help on using the changeset viewer.