source: trunk/Lucide/gui/printDlg.cpp @ 393

Last change on this file since 393 was 370, checked in by dmik, 12 years ago

Additional fix for r364.

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