source: trunk/Lucide/SOURCE/gui/printDlg.cpp @ 285

Last change on this file since 285 was 265, checked in by Eugene Romanenko, 12 years ago

small changes to make new openwatcom 1.8 happy

File size: 30.0 KB
Line 
1/* ***** BEGIN LICENSE BLOCK *****
2 * Version: CDDL 1.0/LGPL 2.1
3 *
4 * The contents of this file are subject to the COMMON DEVELOPMENT AND
5 * DISTRIBUTION LICENSE (CDDL) Version 1.0 (the "License"); you may not use
6 * this file except in compliance with the License. You may obtain a copy of
7 * the License at http://www.sun.com/cddl/
8 *
9 * Software distributed under the License is distributed on an "AS IS" basis,
10 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11 * for the specific language governing rights and limitations under the
12 * License.
13 *
14 * The Initial Developer of the Original Code is
15 * Eugene Romanenko, netlabs.org.
16 * Portions created by the Initial Developer are Copyright (C) 2006
17 * the Initial Developer. All Rights Reserved.
18 *
19 * Contributor(s):
20 *
21 * Alternatively, the contents of this file may be used under the terms of
22 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
23 * in which case the provisions of the LGPL are applicable instead of those
24 * above. If you wish to allow use of your version of this file only under the
25 * terms of the LGPL, and not to allow others to use your version of this file
26 * under the terms of the CDDL, indicate your decision by deleting the
27 * provisions above and replace them with the notice and other provisions
28 * required by the LGPL. If you do not delete the provisions above, a recipient
29 * may use your version of this file under the terms of any one of the CDDL
30 * or the LGPL.
31 *
32 * ***** END LICENSE BLOCK ***** */
33
34
35#define INCL_WIN
36#define INCL_DEV
37#define INCL_ERRORS
38#define INCL_SPL
39#define INCL_SPLDOSPRINT
40#include <os2.h>
41
42#include <string>
43
44#include <ludoc.xh>
45
46#include "globals.h"
47#include "printDlg.h"
48#include "Lucide_res.h"
49#include "luutils.h"
50#include "messages.h"
51
52
53char PrintDlg::defQueue[] = { 0 };
54
55
56PrintDlg::PrintDlg( HWND hWndFrame, LuDocument *_doc, const char *fname, long _currentpage )
57{
58    hFrame      = hWndFrame;
59    doc         = _doc;
60    scalable    = _doc->isScalable( ev );
61    fixed       = _doc->isFixedImage( ev );
62    filename    = newstrdup( fname );
63    currentpage = _currentpage;
64    pcurForm    = new HCINFO;
65    memset( pcurForm, 0, sizeof( HCINFO ) );
66    psetup      = new PrintSetup;
67    memset( psetup, 0, sizeof( PrintSetup ) );
68}
69
70PrintDlg::~PrintDlg()
71{
72    delete filename;
73    delete pcurForm;
74    delete psetup;
75}
76
77ULONG PrintDlg::showDialog()
78{
79    return WinDlgBox( HWND_DESKTOP, hFrame, printDlgProc,
80                      _hmod, IDD_PRINT, this );
81}
82
83void PrintDlg::getPrintSetup( PrintSetup *p ) {
84    memcpy( p, psetup, sizeof( PrintSetup ) );
85}
86
87void PrintDlg::setCurrentQInfo( HWND hwnd, PPRQINFO3 q )
88{
89    memcpy( &(psetup->QueueInfo), q, sizeof( PRQINFO3 ) );
90    WinSetDlgItemText( hwnd, IDC_PNAME, psetup->QueueInfo.pszComment );
91    WinSetDlgItemText( hwnd, IDC_PDESCRIPTION, psetup->QueueInfo.pszDriverName );
92    WinEnableControl( hwnd, IDC_JOBPROPERTIES, TRUE );
93    WinEnableControl( hwnd, DID_OK, TRUE );
94
95    // Set the print type
96    if ( doc->isPostScriptExportable( ev ) && isPostscriptDevice() ) {
97        WinEnableControl( hwnd, IDC_TYPE_POSTSCRIPT, TRUE );
98        WinCheckButton( hwnd, IDC_TYPE_POSTSCRIPT, TRUE );
99    }
100    else {
101        WinEnableControl( hwnd, IDC_TYPE_POSTSCRIPT, FALSE );
102        WinCheckButton( hwnd, IDC_TYPE_ASIMAGE, TRUE );
103    }
104
105    WinSendMsg( hwnd, WM_CONTROL,
106                MPFROM2SHORT( IDC_TYPE_POSTSCRIPT, BN_CLICKED ),
107                MPFROMHWND( WinWindowFromID( hwnd, IDC_TYPE_POSTSCRIPT ) ) );
108
109    WinCheckButton( hwnd, isPortraitOrientation() ? IDC_PORTRAIT : IDC_LANDSCAPE, TRUE );
110
111    // removed (copies to job props)
112    //WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_SETCURRENTVALUE,
113    //                   MPFROMLONG( queryCopies() ), MPVOID );
114
115    applyForm( hwnd );
116}
117
118void PrintDlg::enumQueues( HWND hwnd )
119{
120    HWND list = WinWindowFromID( hwnd, IDC_PNAME );
121    ULONG cReturned = 0, cTotal = 0, cbNeeded = 0;
122    SPLERR se = SplEnumQueue( NULL, 3, NULL, 0L, &cReturned,
123                              &cTotal, &cbNeeded, NULL );
124    if ( cTotal == 0L ) {
125        // TODO: 'no printers installed' message  (?)
126    }
127
128    pQueueInfo = (PPRQINFO3)malloc( cbNeeded );
129
130    se = SplEnumQueue( NULL, 3, pQueueInfo, cbNeeded, &cReturned,
131                       &cTotal, &cbNeeded, NULL );
132    if ( se != NO_ERROR ) {
133        // TODO: error message
134        free( pQueueInfo );
135        pQueueInfo = NULL;
136        return;
137    }
138
139    USHORT sEntry;
140    for ( ULONG i = 0; i < cReturned; i++ )
141    {
142        sEntry = (SHORT)WinInsertLboxItem( list, LIT_END, pQueueInfo[i].pszComment );
143        WinSendMsg( list, LM_SETITEMHANDLE,
144                    MPFROMSHORT(sEntry), MPFROMP( &(pQueueInfo[i]) ) );
145
146        if ( defQueue[0] == 0 ) {
147            if ( pQueueInfo[i].fsType & PRQ3_TYPE_APPDEFAULT ) {
148                setCurrentQInfo( hwnd, &( pQueueInfo[i] ) );
149            }
150        }
151        else {
152            if ( strcmp( pQueueInfo[i].pszName, defQueue ) == 0 ) {
153                setCurrentQInfo( hwnd, &( pQueueInfo[i] ) );
154            }
155        }
156    }
157}
158
159
160void PrintDlg::showJobProperties( HWND hwnd )
161{
162    if ( psetup->QueueInfo.pszName[0] == 0 ) {
163        return;
164    }
165
166    char achDriverName[ DRIVERNAME_LENGTH ];
167    char achDeviceName[ DEVICENAME_LENGTH ];
168
169    // The pszDriverName is of the form DRIVER.DEVICE (e.g.,
170    // LASERJET.HP LaserJet IID) so we need to separate it at the dot
171    int i = strcspn( psetup->QueueInfo.pszDriverName, "." );
172    if ( i > 0 ) {
173        strncpy( achDriverName, psetup->QueueInfo.pszDriverName, i );
174        achDriverName[ i ] = '\0';
175        strcpy( achDeviceName, &( psetup->QueueInfo.pszDriverName[ i + 1 ] ) );
176    }
177    else {
178        strcpy( achDriverName, psetup->QueueInfo.pszDriverName );
179        *achDeviceName = '\0';
180    }
181
182    // There may be more than one printer assigned to this print queue
183    // We will use the first in the comma separated list.  We would
184    // need an expanded dialog for the user to be more specific.
185    char *pszTemp = strchr( psetup->QueueInfo.pszPrinters, ',' );
186    if ( pszTemp != NULL ) {
187        // Strip off comma and trailing printer names
188        *pszTemp = '\0';
189    }
190
191    // Post the job properties dialog for the printer to allow the
192    // user to modify the options
193    DevPostDeviceModes( hab, psetup->QueueInfo.pDriverData, achDriverName,
194                        achDeviceName, psetup->QueueInfo.pszPrinters, DPDM_POSTJOBPROP );
195
196    WinCheckButton( hwnd, isPortraitOrientation() ? IDC_PORTRAIT : IDC_LANDSCAPE, TRUE );
197
198    // removed (copies to job props)
199    //WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_SETCURRENTVALUE,
200    //                   MPFROMLONG( queryCopies() ), MPVOID );
201
202    applyForm( hwnd );
203}
204
205HDC PrintDlg::getInfoDC()
206{
207    char *achDriverName = new char[ DRIVERNAME_LENGTH ];
208    // build a devopenstruct for the call to DevOpenDC
209    DEVOPENSTRUC *dos   = new DEVOPENSTRUC;
210    memset( dos, 0, sizeof( DEVOPENSTRUC ) );
211    dos->pszLogAddress = psetup->QueueInfo.pszName;              // 1
212    strcpy( achDriverName, psetup->QueueInfo.pszDriverName );
213    achDriverName[ strcspn( achDriverName, "." ) ] = '\0';
214    dos->pszDriverName = achDriverName;                          // 2
215    dos->pdriv = psetup->QueueInfo.pDriverData;                  // 3
216
217    HDC hdcPrinterInfo = DevOpenDC( hab, OD_INFO, "*", 3L, (PDEVOPENDATA)dos, NULLHANDLE );
218
219    delete achDriverName;
220    delete dos;
221
222    return hdcPrinterInfo;
223}
224
225bool PrintDlg::isPostscriptDevice()
226{
227    long lTech = 0;
228    HDC hdcPrinterInfo = getInfoDC();
229    if ( hdcPrinterInfo != DEV_ERROR ) {
230        DevQueryCaps( hdcPrinterInfo, CAPS_TECHNOLOGY, sizeof(long), &lTech );
231        DevCloseDC( hdcPrinterInfo );
232    }
233    return ( lTech == CAPS_TECH_POSTSCRIPT );
234}
235
236// **************************************************
237// OpenWatcom headers doesn't have these declarations
238// **************************************************
239#ifndef DJP_SJ_ORIENTATION
240typedef struct _djpItem
241{
242    ULONG       cb;
243    ULONG       ulProperty;
244    LONG        lType;
245    ULONG       ulNumReturned;
246    ULONG       ulValue;
247} DJP_ITEM, *PDJP_ITEM;
248
249#define DJP_ALL                 1L
250#define DJP_CURRENT             2L
251#define DJP_NONE                0L
252#define DJP_SJ_ORIENTATION      1L
253#define DJP_SJ_COPIES           16L
254
255#define DJP_ORI_PORTRAIT        1L
256#define DJP_ORI_LANDSCAPE       2L
257#define DJP_ORI_REV_PORTRAIT    3L
258#define DJP_ORI_REV_LANDSCAPE   4L
259#endif
260// **************************************************
261
262bool PrintDlg::isPortraitOrientation()
263{
264    bool rVal = true;
265
266    HDC hdcPrinterInfo = getInfoDC();
267    if ( hdcPrinterInfo != DEV_ERROR )
268    {
269        DJP_ITEM djp[ 2 ] = { { 0 } };
270
271        // Get Orientation from Job Properties
272        djp[0].cb = sizeof( DJP_ITEM );
273        djp[0].ulProperty = DJP_SJ_ORIENTATION;
274        djp[0].lType = DJP_CURRENT;
275        djp[0].ulNumReturned = 1;
276        djp[0].ulValue = 1;
277
278        djp[1].cb = sizeof( DJP_ITEM );
279        djp[1].ulProperty = 0;
280        djp[1].lType = DJP_NONE;
281        djp[1].ulNumReturned = 1;
282        djp[1].ulValue = 0;
283
284        LONG outSz = psetup->QueueInfo.pDriverData->cb;
285        LONG rc = DevEscape( hdcPrinterInfo, DEVESC_QUERYJOBPROPERTIES,
286                             sizeof( DJP_ITEM ) * 2, (PBYTE)djp,
287                             &outSz, (PBYTE)psetup->QueueInfo.pDriverData );
288
289        if ( ( rc == DEV_OK ) || ( rc == DEV_WARNING ) )
290        {
291            if ( ( djp[0].lType != DJP_NONE ) &&
292                 ( djp[0].ulProperty == DJP_SJ_ORIENTATION ) &&
293                 ( djp[0].lType > 0 ) )
294            {
295                if ( ( djp[0].ulValue == DJP_ORI_LANDSCAPE ) ||
296                     ( djp[0].ulValue == DJP_ORI_REV_LANDSCAPE ) ) {
297                    rVal = false;
298                }
299            }
300        }
301
302        DevCloseDC( hdcPrinterInfo );
303    }
304
305    return rVal;
306}
307
308void PrintDlg::setPortraitOrientation( bool portrait, HWND hwnd )
309{
310    HDC hdcPrinterInfo = getInfoDC();
311    if ( hdcPrinterInfo != DEV_ERROR )
312    {
313        DJP_ITEM djp[ 2 ] = { { 0 } };
314
315        // Set Orientation
316        djp[0].cb = sizeof( DJP_ITEM );
317        djp[0].ulProperty = DJP_SJ_ORIENTATION;
318        djp[0].lType = DJP_CURRENT;
319        djp[0].ulNumReturned = 1;
320        djp[0].ulValue = portrait ? DJP_ORI_PORTRAIT : DJP_ORI_LANDSCAPE;
321
322        djp[1].cb = sizeof( DJP_ITEM );
323        djp[1].ulProperty = 0;
324        djp[1].lType = DJP_NONE;
325        djp[1].ulNumReturned = 1;
326        djp[1].ulValue = 0;
327
328        LONG outSz = psetup->QueueInfo.pDriverData->cb;
329        DevEscape( hdcPrinterInfo, DEVESC_SETJOBPROPERTIES,
330                   sizeof( DJP_ITEM ) * 2, (PBYTE)djp,
331                   &outSz, (PBYTE)psetup->QueueInfo.pDriverData );
332
333        DevCloseDC( hdcPrinterInfo );
334
335        applyForm( hwnd );
336    }
337}
338
339int PrintDlg::queryCopies() // currently unused
340{
341    int rVal = 1;
342
343    HDC hdcPrinterInfo = getInfoDC();
344    if ( hdcPrinterInfo != DEV_ERROR )
345    {
346        DJP_ITEM djp[ 2 ] = { { 0 } };
347
348        // Get number of copies from Job Properties
349        djp[0].cb = sizeof( DJP_ITEM );
350        djp[0].ulProperty = DJP_SJ_COPIES;
351        djp[0].lType = DJP_CURRENT;
352        djp[0].ulNumReturned = 1;
353        djp[0].ulValue = 1;
354
355        djp[1].cb = sizeof( DJP_ITEM );
356        djp[1].ulProperty = 0;
357        djp[1].lType = DJP_NONE;
358        djp[1].ulNumReturned = 1;
359        djp[1].ulValue = 0;
360
361        LONG outSz = psetup->QueueInfo.pDriverData->cb;
362        LONG rc = DevEscape( hdcPrinterInfo, DEVESC_QUERYJOBPROPERTIES,
363                             sizeof( DJP_ITEM ) * 2, (PBYTE)djp,
364                             &outSz, (PBYTE)psetup->QueueInfo.pDriverData );
365
366        if ( ( rc == DEV_OK ) || ( rc == DEV_WARNING ) ) {
367            rVal = djp[0].ulValue;
368        }
369
370        DevCloseDC( hdcPrinterInfo );
371    }
372
373    return rVal;
374}
375
376void PrintDlg::setCopies( int copies )  // currently unused
377{
378    HDC hdcPrinterInfo = getInfoDC();
379    if ( hdcPrinterInfo != DEV_ERROR )
380    {
381        DJP_ITEM djp[ 2 ] = { { 0 } };
382
383        // Set number of copies
384        djp[0].cb = sizeof( DJP_ITEM );
385        djp[0].ulProperty = DJP_SJ_COPIES;
386        djp[0].lType = DJP_CURRENT;
387        djp[0].ulNumReturned = 1;
388        djp[0].ulValue = copies;
389
390        djp[1].cb = sizeof( DJP_ITEM );
391        djp[1].ulProperty = 0;
392        djp[1].lType = DJP_NONE;
393        djp[1].ulNumReturned = 1;
394        djp[1].ulValue = 0;
395
396        LONG outSz = psetup->QueueInfo.pDriverData->cb;
397        DevEscape( hdcPrinterInfo, DEVESC_SETJOBPROPERTIES,
398                   sizeof( DJP_ITEM ) * 2, (PBYTE)djp,
399                   &outSz, (PBYTE)psetup->QueueInfo.pDriverData );
400
401        DevCloseDC( hdcPrinterInfo );
402    }
403}
404
405bool PrintDlg::queryCurrentForm()
406{
407    HDC hdcPrinterInfo = getInfoDC();
408    if ( hdcPrinterInfo == DEV_ERROR ) {
409        return false;
410    }
411
412    LONG lForms = DevQueryHardcopyCaps( hdcPrinterInfo, 0, 0, NULL );
413    if ( lForms == DQHC_ERROR ) {
414        DevCloseDC( hdcPrinterInfo );
415        return false;
416    }
417
418    HCINFO *forms = new HCINFO[ lForms ];
419    memset( forms, 0, sizeof( HCINFO ) * lForms );
420    lForms = DevQueryHardcopyCaps( hdcPrinterInfo, 0, lForms, forms );
421    if ( lForms == DQHC_ERROR ) {
422        delete forms;
423        DevCloseDC( hdcPrinterInfo );
424        return false;
425    }
426
427    for ( LONG i = 0; i < lForms; i++ ) {
428        if ( forms[i].flAttributes & HCAPS_CURRENT ) {
429            memcpy( pcurForm, &( forms[i] ), sizeof( HCINFO ) );
430            break;
431        }
432    }
433
434    delete forms;
435    DevCloseDC( hdcPrinterInfo );
436    return true;
437}
438
439void PrintDlg::applyForm( HWND hwnd )
440{
441    if ( queryCurrentForm() )
442    {
443        WinSetDlgItemText( hwnd, IDC_SELECTED_FORM, pcurForm->szFormname );
444
445        long margin_top_min    = pcurForm->cy - pcurForm->yTopClip;
446        long margin_left_min   = pcurForm->xLeftClip;
447        long margin_bottom_min = pcurForm->yBottomClip;
448        long margin_right_min  = pcurForm->cx - pcurForm->xRightClip;
449
450        if ( WinQueryButtonCheckstate( hwnd, IDC_IGNMARGINS ) ) {
451            margin_top_min = margin_left_min = margin_bottom_min = margin_right_min = 0;
452        }
453
454        long margin_top_max    = pcurForm->cy - margin_bottom_min;
455        long margin_left_max   = pcurForm->cx - margin_right_min;
456        long margin_bottom_max = pcurForm->cy - margin_top_min;
457        long margin_right_max  = pcurForm->cx - margin_left_min;
458
459        WinSendDlgItemMsg( hwnd, IDC_MTOP, SPBM_SETLIMITS,
460                           MPFROMLONG( margin_top_max ), MPFROMLONG( margin_top_min ) );
461        WinSendDlgItemMsg( hwnd, IDC_MTOP, SPBM_SETCURRENTVALUE,
462                           MPFROMLONG( margin_top_min ), MPVOID );
463        WinSendDlgItemMsg( hwnd, IDC_MLEFT, SPBM_SETLIMITS,
464                           MPFROMLONG( margin_left_max ), MPFROMLONG( margin_left_min ) );
465        WinSendDlgItemMsg( hwnd, IDC_MLEFT, SPBM_SETCURRENTVALUE,
466                           MPFROMLONG( margin_left_min ), MPVOID );
467        WinSendDlgItemMsg( hwnd, IDC_MBOTTOM, SPBM_SETLIMITS,
468                           MPFROMLONG( margin_bottom_max ), MPFROMLONG( margin_bottom_min ) );
469        WinSendDlgItemMsg( hwnd, IDC_MBOTTOM, SPBM_SETCURRENTVALUE,
470                           MPFROMLONG( margin_bottom_min ), MPVOID );
471        WinSendDlgItemMsg( hwnd, IDC_MRIGHT, SPBM_SETLIMITS,
472                           MPFROMLONG( margin_right_max ), MPFROMLONG( margin_right_min ) );
473        WinSendDlgItemMsg( hwnd, IDC_MRIGHT, SPBM_SETCURRENTVALUE,
474                           MPFROMLONG( margin_right_min ), MPVOID );
475
476        //somPrintf( "cx %d, cy %d, xLeftClip %d, yBottomClip %d, xRightClip %d, yTopClip %d\n",
477        //           pcurForm->cx, pcurForm->cy, pcurForm->xLeftClip, pcurForm->yBottomClip,
478        //           pcurForm->xRightClip, pcurForm->yTopClip );
479
480    }
481    else {
482        WinSetDlgItemText( hwnd, IDC_SELECTED_FORM, "" );
483    }
484}
485
486
487// do not allow round-trip on spins
488static MRESULT EXPENTRY spinProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
489{
490    PFNWP oldSpinProc = (PFNWP)WinQueryWindowULong( hwnd, QWL_USER );
491
492    if ( msg == SPBM_SPINDOWN )
493    {
494        LONG upLimit = 0, lowLimit = 0, curVal = 0;
495        WinSendMsg( hwnd, SPBM_QUERYLIMITS, MPFROMP( &upLimit ), MPFROMP( &lowLimit ) );
496        WinSendMsg( hwnd, SPBM_QUERYVALUE, MPFROMP( &curVal ), MPFROM2SHORT( 0, SPBQ_DONOTUPDATE ) );
497        if ( curVal <= lowLimit ) {
498            return (MRESULT)TRUE;
499        }
500    }
501    else if ( msg == SPBM_SPINUP )
502    {
503        LONG upLimit = 0, lowLimit = 0, curVal = 0;
504        WinSendMsg( hwnd, SPBM_QUERYLIMITS, MPFROMP( &upLimit ), MPFROMP( &lowLimit ) );
505        WinSendMsg( hwnd, SPBM_QUERYVALUE, MPFROMP( &curVal ), MPFROM2SHORT( 0, SPBQ_DONOTUPDATE ) );
506        if ( curVal >= upLimit ) {
507            return (MRESULT)TRUE;
508        }
509    }
510
511    return oldSpinProc( hwnd, msg, mp1, mp2 );
512}
513
514MRESULT EXPENTRY PrintDlg::printDlgProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
515{
516    // This is a static method, so we don't know which instantiation we're
517    // dealing with. But we can get a pseudo-this from the parameter to
518    // WM_INITDLG, which we therafter store with the window and retrieve
519    // as follows:
520    PrintDlg *_this = (PrintDlg *)WinQueryWindowULong( hwnd, QWL_USER );
521
522    switch (msg)
523    {
524
525        // Dialog has just been created
526        case WM_INITDLG:
527        {
528            // Save the mp2 into our user data so that subsequent calls have
529            // access to the parent C++ object
530            WinSetWindowULong( hwnd, QWL_USER, (ULONG)mp2 );
531            _this = (PrintDlg *)mp2;
532            localizeDialog( hwnd );
533            centerWindow( _this->hFrame, hwnd );
534
535            // Print range
536            WinCheckButton( hwnd, IDC_RANGEALL, TRUE );
537
538            // Set the print range spins
539            long pages = _this->doc->getPageCount( ev );
540            WinSendDlgItemMsg( hwnd, IDC_PGFROM, SPBM_SETLIMITS,
541                               MPFROMLONG( pages ), MPFROMLONG( 1 ) );
542            WinSendDlgItemMsg( hwnd, IDC_PGFROM, SPBM_SETCURRENTVALUE,
543                               MPFROMLONG( 1 ), MPVOID );
544            WinSendDlgItemMsg( hwnd, IDC_PGTO, SPBM_SETLIMITS,
545                               MPFROMLONG( pages ), MPFROMLONG( 1 ) );
546            WinSendDlgItemMsg( hwnd, IDC_PGTO, SPBM_SETCURRENTVALUE,
547                               MPFROMLONG( pages ), MPVOID );
548
549            // Enum printer queues
550            _this->enumQueues( hwnd );
551
552            // Number of copies
553            WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_SETLIMITS,
554                               MPFROMLONG( 999 ), MPFROMLONG( 1 ) );
555            WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_SETCURRENTVALUE,
556                               MPFROMLONG( 1 ), MPVOID );
557
558            USHORT sEntry;
559            HWND reo = WinWindowFromID( hwnd, IDC_RANGE_EVEN_ODD );
560            WinSetWindowText( reo, getLocalizedString( PD_RANGE_EVEN_ODD ).c_str() );
561            sEntry = (SHORT)WinInsertLboxItem( reo, LIT_END, getLocalizedString( PD_RANGE_EVEN_ODD ).c_str() );
562            WinSendMsg( reo, LM_SETITEMHANDLE, MPFROMSHORT(sEntry), MPFROMLONG( OEOddEven ) );
563            sEntry = (SHORT)WinInsertLboxItem( reo, LIT_END, getLocalizedString( PD_RANGE_ODD ).c_str() );
564            WinSendMsg( reo, LM_SETITEMHANDLE, MPFROMSHORT(sEntry), MPFROMLONG( OEOdd ) );
565            sEntry = (SHORT)WinInsertLboxItem( reo, LIT_END, getLocalizedString( PD_RANGE_EVEN ).c_str() );
566            WinSendMsg( reo, LM_SETITEMHANDLE, MPFROMSHORT(sEntry), MPFROMLONG( OEEven ) );
567
568            HWND spin = WinWindowFromID( hwnd, IDC_MLEFT );
569            PFNWP proc = WinSubclassWindow( spin, spinProc );
570            WinSetWindowULong( spin, QWL_USER, (ULONG)proc );
571            spin = WinWindowFromID( hwnd, IDC_MRIGHT );
572            proc = WinSubclassWindow( spin, spinProc );
573            WinSetWindowULong( spin, QWL_USER, (ULONG)proc );
574            spin = WinWindowFromID( hwnd, IDC_MTOP );
575            proc = WinSubclassWindow( spin, spinProc );
576            WinSetWindowULong( spin, QWL_USER, (ULONG)proc );
577            spin = WinWindowFromID( hwnd, IDC_MBOTTOM );
578            proc = WinSubclassWindow( spin, spinProc );
579            WinSetWindowULong( spin, QWL_USER, (ULONG)proc );
580
581            return (MRESULT)FALSE;
582        }
583
584        case WM_CONTROL:
585        {
586            switch ( SHORT1FROMMP(mp1) )
587            {
588                case IDC_PNAME:
589                {
590                    if ( SHORT2FROMMP(mp1) == CBN_LBSELECT )
591                    {
592                        SHORT rc = (SHORT)WinSendDlgItemMsg( hwnd, IDC_PNAME, LM_QUERYSELECTION,
593                                                             MPFROMSHORT( LIT_CURSOR ), MPVOID );
594                        if ( rc != LIT_NONE ) {
595                            MRESULT r = WinSendDlgItemMsg( hwnd, IDC_PNAME, LM_QUERYITEMHANDLE,
596                                                           MPFROMSHORT( rc ), MPVOID );
597                            _this->setCurrentQInfo( hwnd, (PPRQINFO3)r );
598                        }
599                    }
600                }
601                break;
602
603                case IDC_RANGEALL:
604                case IDC_RANGECURRENT:
605                case IDC_RANGEPAGES:
606                {
607                    BOOL en = WinQueryButtonCheckstate( hwnd, IDC_RANGEPAGES );
608                    WinEnableControl( hwnd, IDC_LABELFROM, en );
609                    WinEnableControl( hwnd, IDC_PGFROM, en );
610                    WinEnableControl( hwnd, IDC_LABELTO, en );
611                    WinEnableControl( hwnd, IDC_PGTO, en );
612                }
613                break;
614
615                case IDC_TYPE_POSTSCRIPT:
616                case IDC_TYPE_ASIMAGE:
617                {
618                    BOOL aspsc = WinQueryButtonCheckstate( hwnd, IDC_TYPE_POSTSCRIPT );
619                    BOOL asimg = WinQueryButtonCheckstate( hwnd, IDC_TYPE_ASIMAGE );
620                    WinEnableControl( hwnd, IDC_PRINT_TO_FILE, aspsc );
621                    WinEnableControl( hwnd, IDC_HIGHER_IMAGE_QUALITY,
622                                      asimg && _this->scalable && !_this->fixed );
623                    WinEnableControl( hwnd, IDC_RANGE_EVEN_ODD_LABEL, asimg );
624                    WinEnableControl( hwnd, IDC_RANGE_EVEN_ODD, asimg );
625                }
626                break;
627
628                case IDC_PORTRAIT:
629                case IDC_LANDSCAPE:
630                {
631                    bool portrait = WinQueryButtonCheckstate( hwnd, IDC_PORTRAIT );
632                    _this->setPortraitOrientation( portrait, hwnd );
633                }
634                break;
635
636                case IDC_IGNMARGINS:
637                {
638                    if ( ( SHORT2FROMMP(mp1) == BN_CLICKED ) ||
639                         ( SHORT2FROMMP(mp1) == BN_DBLCLICKED ) )
640                    {
641                        _this->applyForm( hwnd );
642                    }
643                }
644                break;
645
646                // removed (copies to job props)
647                //case IDC_COPIES:
648                //{
649                //    if ( SHORT2FROMMP(mp1) == SPBN_CHANGE )
650                //    {
651                //        LONG cp = 0;
652                //        WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_QUERYVALUE,
653                //                           MPFROMP( &cp ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
654                //        _this->setCopies( cp );
655                //    }
656                //}
657                //break;
658            }
659        }
660        break;
661
662        case WM_COMMAND:
663            switch (SHORT1FROMMP(mp1))
664            {
665                case IDC_JOBPROPERTIES:
666                    _this->showJobProperties( hwnd );
667                    return (MRESULT)FALSE;
668
669                case DID_OK:
670                    {
671                        long ml = 0, mr = 0, mt = 0, mb = 0;
672                        WinSendDlgItemMsg( hwnd, IDC_MLEFT, SPBM_QUERYVALUE, MPFROMP( &ml ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
673                        WinSendDlgItemMsg( hwnd, IDC_MRIGHT, SPBM_QUERYVALUE, MPFROMP( &mr ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
674                        WinSendDlgItemMsg( hwnd, IDC_MTOP, SPBM_QUERYVALUE, MPFROMP( &mt ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
675                        WinSendDlgItemMsg( hwnd, IDC_MBOTTOM, SPBM_QUERYVALUE, MPFROMP( &mb ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
676
677                        if ( ( _this->pcurForm->cx < ( ml + mr ) ) ||
678                             ( _this->pcurForm->cy < ( mt + mb ) ) )
679                        {
680                            char *wrongmargins = newstrdupL( PD_WRONG_MARGINS );
681                            WinMessageBox( HWND_DESKTOP, _this->hFrame, wrongmargins, NULL,
682                                           1, MB_OK | MB_ERROR | MB_MOVEABLE );
683                            delete wrongmargins;
684                            return (MRESULT)FALSE;  // Return, don't leave dialog
685                        }
686
687                        _this->psetup->margin_left   = ml;
688                        _this->psetup->margin_right  = mr;
689                        _this->psetup->margin_top    = mt;
690                        _this->psetup->margin_bottom = mb;
691
692                        LONG cp = 0;
693                        WinSendDlgItemMsg( hwnd, IDC_COPIES, SPBM_QUERYVALUE, MPFROMP( &cp ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
694                        _this->psetup->copies = cp;
695
696                        _this->psetup->range = RangeAll;
697                        _this->psetup->pgfrom = 1;
698                        _this->psetup->pgto = _this->doc->getPageCount( ev );
699
700                        if ( WinQueryButtonCheckstate( hwnd, IDC_RANGECURRENT ) ) {
701                            _this->psetup->range = RangeCurrent;
702                            _this->psetup->pgfrom = _this->currentpage;
703                            _this->psetup->pgto = _this->currentpage;
704                        }
705
706                        if ( WinQueryButtonCheckstate( hwnd, IDC_RANGEPAGES ) )
707                        {
708                            _this->psetup->range = RangePages;
709                            LONG tmpVal = 0;
710                            BOOL rc = (BOOL)WinSendDlgItemMsg( hwnd, IDC_PGFROM, SPBM_QUERYVALUE, MPFROMP( &tmpVal ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
711                            if ( rc && ( tmpVal > 0 ) ) {
712                                _this->psetup->pgfrom = tmpVal;
713                            }
714                            rc = (BOOL)WinSendDlgItemMsg( hwnd, IDC_PGTO, SPBM_QUERYVALUE, MPFROMP( &tmpVal ), MPFROM2SHORT( 0, SPBQ_UPDATEIFVALID ) );
715                            if ( rc && ( tmpVal > 0 ) ) {
716                                _this->psetup->pgto = tmpVal;
717                            }
718                        }
719
720                        _this->psetup->ptype = TypePostScript;
721                        if ( WinQueryButtonCheckstate( hwnd, IDC_TYPE_ASIMAGE ) ) {
722                            _this->psetup->ptype = TypeAsImage;
723                        }
724                        _this->psetup->higherQuality = WinQueryButtonCheckstate( hwnd, IDC_HIGHER_IMAGE_QUALITY );
725
726                        _this->psetup->oddeven = OEOddEven;
727                        if ( _this->psetup->ptype == TypeAsImage )
728                        {
729                            SHORT rc = (SHORT)WinSendDlgItemMsg( hwnd, IDC_RANGE_EVEN_ODD, LM_QUERYSELECTION,
730                                                             MPFROMSHORT( LIT_CURSOR ), MPVOID );
731                            if ( rc != LIT_NONE ) {
732                                MRESULT r = WinSendDlgItemMsg( hwnd, IDC_RANGE_EVEN_ODD, LM_QUERYITEMHANDLE,
733                                                           MPFROMSHORT( rc ), MPVOID );
734                                _this->psetup->oddeven = (PrintOddEven)(int)r;
735                            }
736                        }
737
738                        _this->psetup->psToFile = WinQueryButtonCheckstate( hwnd, IDC_PRINT_TO_FILE );
739
740                        if ( ( _this->psetup->ptype == TypePostScript ) &&
741                             _this->psetup->psToFile )
742                        {
743                            strcpy( _this->psetup->psFile, _this->filename );
744                            char *pointpos = strrchr( _this->psetup->psFile, '.' );
745                            if ( pointpos != NULL ) {
746                                *pointpos = 0;
747                            }
748                            strcat( _this->psetup->psFile, ".ps" );
749
750                            PFILEDLG fd = new FILEDLG;
751                            memset( fd, 0, sizeof( FILEDLG ) );
752                            fd->cbSize = sizeof( FILEDLG );
753                            fd->fl = FDS_CENTER | FDS_SAVEAS_DIALOG;
754                            strcpy( fd->szFullFile, _this->psetup->psFile );
755                            WinFileDlg( HWND_DESKTOP, hwnd, fd );
756                            if ( fd->lReturn == DID_OK ) {
757                                strcpy( _this->psetup->psFile, fd->szFullFile );
758                                delete fd;
759                            }
760                            else {
761                                delete fd;
762                                WinDismissDlg( hwnd, DID_CANCEL );
763                                return (MRESULT)FALSE;
764                            }
765                        }
766
767                        // save name of selected queue to make it default for session
768                        strcpy( defQueue, _this->psetup->QueueInfo.pszName );
769
770                        WinDismissDlg( hwnd, DID_OK );
771                    }
772                    return (MRESULT)FALSE;
773
774                case DID_CANCEL:
775                    WinDismissDlg( hwnd, DID_CANCEL );
776                    return (MRESULT)FALSE;
777            };
778            return (MRESULT)FALSE;
779    }
780    return WinDefDlgProc( hwnd, msg, mp1, mp2 );
781}
782
783
Note: See TracBrowser for help on using the repository browser.