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

Last change on this file since 367 was 367, checked in by dmik, 11 years ago

Merged bramches/kmk (r294:365) to trunk.

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