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

Last change on this file since 192 was 192, checked in by Eugene Romanenko, 14 years ago

printing: set number of copies into job properties

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