00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034 #include "qt.h"
00035 #include <QMutexLocker>
00036
00037
00038
00039 static int argc;
00040 static char **argv;
00041 static int appCounter = 0;
00042
00043
00044 extern "C" {
00045 PLDLLIMPEXP_DRIVER_DATA( const char* ) plD_DEVICE_INFO_qt =
00046 #if defined ( PLD_bmpqt )
00047 "bmpqt:Qt Windows bitmap driver:0:qt:66:bmpqt\n"
00048 #endif
00049 #if defined ( PLD_jpgqt )
00050 "jpgqt:Qt jpg driver:0:qt:67:jpgqt\n"
00051 #endif
00052 #if defined ( PLD_pngqt )
00053 "pngqt:Qt png driver:0:qt:68:pngqt\n"
00054 #endif
00055 #if defined ( PLD_ppmqt )
00056 "ppmqt:Qt ppm driver:0:qt:69:ppmqt\n"
00057 #endif
00058 #if defined ( PLD_tiffqt )
00059 "tiffqt:Qt tiff driver:0:qt:70:tiffqt\n"
00060 #endif
00061 #if defined ( PLD_svgqt ) && QT_VERSION >= 0x040300
00062 "svgqt:Qt SVG driver:0:qt:71:svgqt\n"
00063 #endif
00064 #if defined ( PLD_qtwidget )
00065 "qtwidget:Qt Widget:1:qt:72:qtwidget\n"
00066 #endif
00067 #if defined ( PLD_epsqt )
00068 "epsqt:Qt EPS driver:0:qt:73:epsqt\n"
00069 #endif
00070 #if defined ( PLD_pdfqt )
00071 "pdfqt:Qt PDF driver:0:qt:74:pdfqt\n"
00072 #endif
00073 #if defined ( PLD_extqt )
00074 "extqt:External Qt driver:0:qt:75:extqt\n"
00075 #endif
00076 #if defined ( PLD_memqt )
00077 "memqt:Memory Qt driver:0:qt:76:memqt\n"
00078 #endif
00079 ;
00080 }
00081
00082 static DrvOpt qt_options[] = { { "text_vectorize", DRV_INT, &vectorize, "Vectorize fonts on output (0|1)" },
00083 { "lines_antialiasing", DRV_INT, &lines_aa, "Toggles antialiasing on lines (0|1)" },
00084 { NULL, DRV_INT, NULL, NULL } };
00085
00086 bool initQtApp( bool isGUI )
00087 {
00088 QMutexLocker locker( &QtPLDriver::mutex );
00089 bool res = false;
00090 ++appCounter;
00091 if ( qApp == NULL && appCounter == 1 )
00092 {
00093 argc = 1;
00094 argv = new char*[2];
00095 argv[0] = new char[10];
00096 argv[1] = new char[1];
00097 snprintf( argv[0], 10, "qt_driver" );
00098 argv[1][0] = '\0';
00099 #ifdef Q_WS_X11
00100
00101 if ( getenv( "DISPLAY" ) == NULL )
00102 isGUI = false;
00103 #endif
00104 new QApplication( argc, argv, isGUI );
00105 res = true;
00106 }
00107 return res;
00108 }
00109
00110 void closeQtApp()
00111 {
00112 QMutexLocker locker( &QtPLDriver::mutex );
00113 --appCounter;
00114 if ( qApp != NULL && appCounter == 0 )
00115 {
00116 delete qApp;
00117 delete[] argv[0];
00118 delete[] argv[1];
00119 delete[] argv;
00120 argv = NULL;
00121 }
00122 }
00123
00124
00125
00126
00127
00128
00129
00130
00131 static int already_warned = 0;
00132 static int qt_family_check( PLStream *pls )
00133 {
00134 if ( pls->family || pls->page == 1 )
00135 {
00136 return 0;
00137 }
00138 else
00139 {
00140 if ( !already_warned )
00141 {
00142 already_warned = 1;
00143 plwarn( "All pages after the first skipped because family file output not specified.\n" );
00144 }
00145 return 1;
00146 }
00147 }
00148
00149
00150 #if defined ( PLD_bmpqt ) || defined ( PLD_jpgqt ) || defined ( PLD_pngqt ) || defined ( PLD_ppmqt ) || defined ( PLD_tiffqt ) || defined ( PLD_memqt )
00151 void plD_init_rasterqt( PLStream * );
00152 void plD_eop_rasterqt( PLStream * );
00153 void plD_line_rasterqt( PLStream *, short, short, short, short );
00154 void plD_polyline_rasterqt( PLStream *, short*, short*, PLINT );
00155 void plD_tidy_rasterqt( PLStream * );
00156 void plD_state_rasterqt( PLStream *, PLINT );
00157 void plD_esc_rasterqt( PLStream *, PLINT, void* );
00158 #endif
00159
00160 #if defined ( PLD_bmpqt )
00161 void plD_dispatch_init_bmpqt( PLDispatchTable *pdt );
00162 void plD_bop_bmpqt( PLStream * );
00163 #endif
00164
00165 #if defined ( PLD_jpgqt )
00166 void plD_dispatch_init_jpgqt( PLDispatchTable *pdt );
00167 void plD_bop_jpgqt( PLStream * );
00168 #endif
00169
00170 #if defined ( PLD_pngqt )
00171 void plD_dispatch_init_pngqt( PLDispatchTable *pdt );
00172 void plD_bop_pngqt( PLStream * );
00173 #endif
00174
00175 #if defined ( PLD_ppmqt )
00176 void plD_dispatch_init_ppmqt( PLDispatchTable *pdt );
00177 void plD_bop_ppmqt( PLStream * );
00178 #endif
00179
00180 #if defined ( PLD_tiffqt )
00181 void plD_dispatch_init_tiffqt( PLDispatchTable *pdt );
00182 void plD_bop_tiffqt( PLStream * );
00183 #endif
00184
00185 #if defined ( PLD_svgqt ) && QT_VERSION >= 0x040300
00186 void plD_dispatch_init_svgqt( PLDispatchTable *pdt );
00187 void plD_init_svgqt( PLStream * );
00188 void plD_bop_svgqt( PLStream * );
00189 void plD_eop_svgqt( PLStream * );
00190 void plD_line_svgqt( PLStream *, short, short, short, short );
00191 void plD_polyline_svgqt( PLStream *, short*, short*, PLINT );
00192 void plD_tidy_svgqt( PLStream * );
00193 void plD_state_svgqt( PLStream *, PLINT );
00194 void plD_esc_svgqt( PLStream *, PLINT, void* );
00195 #endif
00196
00197 #if defined ( PLD_epsqt ) || defined ( PLD_pdfqt )
00198 void plD_init_epspdfqt( PLStream * );
00199 void plD_bop_epspdfqt_helper( PLStream *, int ifeps );
00200 void plD_eop_epspdfqt( PLStream * );
00201 void plD_line_epspdfqt( PLStream *, short, short, short, short );
00202 void plD_polyline_epspdfqt( PLStream *, short*, short*, PLINT );
00203 void plD_tidy_epspdfqt( PLStream * );
00204 void plD_state_epspdfqt( PLStream *, PLINT );
00205 void plD_esc_epspdfqt( PLStream *, PLINT, void* );
00206 #endif
00207 #if defined ( PLD_epsqt )
00208 void plD_dispatch_init_epsqt( PLDispatchTable *pdt );
00209 void plD_bop_epsqt( PLStream * );
00210 #endif
00211 #if defined ( PLD_pdfqt )
00212 void plD_dispatch_init_pdfqt( PLDispatchTable *pdt );
00213 void plD_bop_pdfqt( PLStream * );
00214 #endif
00215
00216 #if defined ( PLD_qtwidget )
00217 void plD_dispatch_init_qtwidget( PLDispatchTable *pdt );
00218 void plD_init_qtwidget( PLStream * );
00219 void plD_eop_qtwidget( PLStream * );
00220 void plD_line_qtwidget( PLStream *, short, short, short, short );
00221 void plD_polyline_qtwidget( PLStream *, short*, short*, PLINT );
00222 void plD_tidy_qtwidget( PLStream * );
00223 void plD_state_qtwidget( PLStream *, PLINT );
00224 void plD_esc_qtwidget( PLStream *, PLINT, void* );
00225 void plD_bop_qtwidget( PLStream * );
00226 #endif
00227
00228 #if defined ( PLD_extqt )
00229 void plD_dispatch_init_extqt( PLDispatchTable *pdt );
00230 void plD_init_extqt( PLStream * );
00231 void plD_eop_extqt( PLStream * );
00232 void plD_line_extqt( PLStream *, short, short, short, short );
00233 void plD_polyline_extqt( PLStream *, short*, short*, PLINT );
00234 void plD_tidy_extqt( PLStream * );
00235 void plD_state_extqt( PLStream *, PLINT );
00236 void plD_esc_extqt( PLStream *, PLINT, void* );
00237 void plD_bop_extqt( PLStream * );
00238 #endif
00239
00240 #if defined ( PLD_memqt )
00241 void plD_dispatch_init_memqt( PLDispatchTable *pdt );
00242 void plD_init_memqt( PLStream * );
00243 void plD_bop_memqt( PLStream * );
00244 void plD_eop_memqt( PLStream * );
00245 #endif
00246
00248 #if defined ( PLD_bmpqt ) || defined ( PLD_jpgqt ) || defined ( PLD_pngqt ) || defined ( PLD_ppmqt ) || defined ( PLD_tiffqt ) || defined ( PLD_memqt )
00249 void plD_init_rasterqt( PLStream * pls )
00250 {
00251 double dpi;
00252
00253 vectorize = 0;
00254 lines_aa = 1;
00255 plParseDrvOpts( qt_options );
00256
00257
00258 pls->color = 1;
00259 pls->plbuf_write = 0;
00260 pls->dev_fill0 = 1;
00261 pls->dev_fill1 = 0;
00262 pls->dev_gradient = 1;
00263
00264
00265
00266 pls->dev_dash = 0;
00267 pls->dev_flush = 1;
00268
00269
00270 pls->dev_clear = 0;
00271 pls->termin = 0;
00272 pls->page = 0;
00273 pls->dev_text = 1;
00274 pls->dev_unicode = 1;
00275 pls->has_string_length = 1;
00276
00277
00278 bool isMaster = initQtApp( true );
00279
00280 if ( pls->xdpi <= 0. )
00281 dpi = DEFAULT_DPI;
00282 else
00283 dpi = pls->xdpi;
00284
00285
00286 if ( pls->xlength <= 0 || pls->ylength <= 0 )
00287 {
00288 pls->dev = new QtRasterDevice;
00289 pls->xlength = (PLINT) ( ( (QtRasterDevice *) ( pls->dev ) )->m_dWidth );
00290 pls->ylength = (PLINT) ( ( (QtRasterDevice *) ( pls->dev ) )->m_dHeight );
00291 }
00292 else
00293 {
00294 pls->dev = new QtRasterDevice( pls->xlength, pls->ylength );
00295 }
00296 ( (QtRasterDevice *) pls->dev )->setPLStream( pls );
00297
00298 if ( isMaster )
00299 handler.setMasterDevice( (QtRasterDevice *) ( pls->dev ) );
00300
00301 if ( pls->xlength > pls->ylength )
00302 ( (QtRasterDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->xlength / (PLFLT) ( PIXELS_X - 1 );
00303 else
00304 ( (QtRasterDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->ylength / (PLFLT) PIXELS_Y;
00305
00306 plP_setphy( (PLINT) 0, (PLINT) ( pls->xlength / ( (QtRasterDevice *) ( pls->dev ) )->downscale ), (PLINT) 0, (PLINT) ( pls->ylength / ( (QtRasterDevice *) ( pls->dev ) )->downscale ) );
00307
00308 plP_setpxl( dpi / 25.4 / ( (QtRasterDevice *) ( pls->dev ) )->downscale, dpi / 25.4 / ( (QtRasterDevice *) ( pls->dev ) )->downscale );
00309
00310 ( (QtRasterDevice *) ( pls->dev ) )->setResolution( dpi );
00311
00312
00313 plFamInit( pls );
00314
00315 plOpenFile( pls );
00316 }
00317
00318 void plD_eop_rasterqt( PLStream *pls )
00319 {
00320 if ( qt_family_check( pls ) )
00321 {
00322 return;
00323 }
00324 ( (QtRasterDevice *) pls->dev )->savePlot();
00325 handler.DeviceChangedPage( (QtRasterDevice *) pls->dev );
00326 }
00327
00328 void plD_line_rasterqt( PLStream * pls, short x1a, short y1a, short x2a, short y2a )
00329 {
00330 QtRasterDevice* widget = (QtRasterDevice *) pls->dev;
00331
00332 if ( widget != NULL && qt_family_check( pls ) )
00333 {
00334 return;
00335 }
00336 if ( widget == NULL )
00337 return;
00338
00339 widget->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00340 widget->drawLine( x1a, y1a, x2a, y2a );
00341 }
00342
00343 void plD_polyline_rasterqt( PLStream *pls, short *xa, short *ya, PLINT npts )
00344 {
00345 QtRasterDevice * widget = (QtRasterDevice *) pls->dev;
00346
00347 if ( widget != NULL && qt_family_check( pls ) )
00348 {
00349 return;
00350 }
00351 if ( widget == NULL )
00352 return;
00353
00354 widget->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00355 widget->drawPolyline( xa, ya, npts );
00356 }
00357
00358 void plD_esc_rasterqt( PLStream * pls, PLINT op, void* ptr )
00359 {
00360 short *xa, *ya;
00361 unsigned char *r, *g, *b;
00362 PLFLT *alpha;
00363 PLINT i;
00364 QtRasterDevice * widget = (QtRasterDevice *) pls->dev;
00365 if ( widget != NULL && qt_family_check( pls ) )
00366 {
00367 return;
00368 }
00369 if ( widget == NULL )
00370 return;
00371
00372 switch ( op )
00373 {
00374
00375
00376
00377
00378
00379
00380
00381 case PLESC_FILL:
00382 xa = new short[pls->dev_npts];
00383 ya = new short[pls->dev_npts];
00384
00385 for ( i = 0; i < pls->dev_npts; i++ )
00386 {
00387 xa[i] = pls->dev_x[i];
00388 ya[i] = pls->dev_y[i];
00389 }
00390 widget->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00391 widget->drawPolygon( xa, ya, pls->dev_npts );
00392
00393 delete[] xa;
00394 delete[] ya;
00395 break;
00396
00397 case PLESC_GRADIENT:
00398 xa = new short[pls->dev_npts];
00399 ya = new short[pls->dev_npts];
00400 r = new unsigned char[pls->ncol1];
00401 g = new unsigned char[pls->ncol1];
00402 b = new unsigned char[pls->ncol1];
00403 alpha = new PLFLT[pls->ncol1];
00404
00405 for ( i = 0; i < pls->ncol1; i++ )
00406 {
00407 r[i] = pls->cmap1[i].r;
00408 g[i] = pls->cmap1[i].g;
00409 b[i] = pls->cmap1[i].b;
00410 alpha[i] = pls->cmap1[i].a;
00411 }
00412 widget->setGradient( pls->xgradient[0], pls->xgradient[1], pls->ygradient[0], pls->ygradient[1], r, g, b, alpha, pls->ncol1 );
00413
00414 for ( i = 0; i < pls->dev_npts; i++ )
00415 {
00416 xa[i] = pls->dev_x[i];
00417 ya[i] = pls->dev_y[i];
00418 }
00419 widget->drawPolygon( xa, ya, pls->dev_npts );
00420
00421 delete[] xa;
00422 delete[] ya;
00423 delete[] r;
00424 delete[] g;
00425 delete[] b;
00426 delete[] alpha;
00427 break;
00428
00429 case PLESC_HAS_TEXT:
00430
00431
00432 widget->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00433 widget->drawText( (EscText *) ptr );
00434 break;
00435
00436 default: break;
00437 }
00438 }
00439
00440 void plD_state_rasterqt( PLStream * pls, PLINT op )
00441 {
00442 QtRasterDevice * widget = (QtRasterDevice *) pls->dev;
00443 if ( widget != NULL && qt_family_check( pls ) )
00444 {
00445 return;
00446 }
00447 if ( widget == NULL )
00448 return;
00449
00450 switch ( op )
00451 {
00452 case PLSTATE_WIDTH:
00453 widget->setWidth( pls->width );
00454 break;
00455
00456 case PLSTATE_COLOR0:
00457 ( (QtPLDriver *) widget )->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00458 break;
00459
00460 case PLSTATE_COLOR1:
00461 ( (QtPLDriver *) widget )->QtPLDriver::setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00462 break;
00463
00464
00465 default: break;
00466 }
00467 }
00468
00469 void plD_tidy_rasterqt( PLStream * pls )
00470 {
00471 QtRasterDevice * widget = (QtRasterDevice *) pls->dev;
00472
00473 if ( widget != NULL )
00474 {
00475 handler.DeviceClosed( widget );
00476 delete widget;
00477 pls->dev = NULL;
00478 }
00479 plCloseFile( pls );
00480
00481 closeQtApp();
00482 }
00483 #endif
00484
00485 #if defined ( PLD_bmpqt )
00486 void plD_dispatch_init_bmpqt( PLDispatchTable *pdt )
00487 {
00488 #ifndef ENABLE_DYNDRIVERS
00489 pdt->pl_MenuStr = "Qt Windows bitmap Driver";
00490 pdt->pl_DevName = "bmpqt";
00491 #endif
00492 pdt->pl_type = plDevType_FileOriented;
00493 pdt->pl_seq = 66;
00494 pdt->pl_init = (plD_init_fp) plD_init_rasterqt;
00495 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
00496 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
00497 pdt->pl_eop = (plD_eop_fp) plD_eop_rasterqt;
00498 pdt->pl_bop = (plD_bop_fp) plD_bop_bmpqt;
00499 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
00500 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
00501 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
00502 }
00503
00504 void plD_bop_bmpqt( PLStream *pls )
00505 {
00506
00507 plGetFam( pls );
00508
00509 pls->famadv = 1;
00510 pls->page++;
00511 if ( qt_family_check( pls ) )
00512 {
00513 return;
00514 }
00515 ( (QtRasterDevice *) pls->dev )->definePlotName( pls->FileName, "BMP" );
00516 ( (QtRasterDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00517 }
00518 #endif
00519
00520 #if defined ( PLD_jpgqt )
00521 void plD_dispatch_init_jpgqt( PLDispatchTable *pdt )
00522 {
00523 #ifndef ENABLE_DYNDRIVERS
00524 pdt->pl_MenuStr = "Qt jpg Driver";
00525 pdt->pl_DevName = "jpgqt";
00526 #endif
00527 pdt->pl_type = plDevType_FileOriented;
00528 pdt->pl_seq = 67;
00529 pdt->pl_init = (plD_init_fp) plD_init_rasterqt;
00530 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
00531 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
00532 pdt->pl_eop = (plD_eop_fp) plD_eop_rasterqt;
00533 pdt->pl_bop = (plD_bop_fp) plD_bop_jpgqt;
00534 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
00535 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
00536 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
00537 }
00538
00539 void plD_bop_jpgqt( PLStream *pls )
00540 {
00541
00542 plGetFam( pls );
00543
00544 pls->famadv = 1;
00545 pls->page++;
00546 if ( qt_family_check( pls ) )
00547 {
00548 return;
00549 }
00550 ( (QtRasterDevice *) pls->dev )->definePlotName( pls->FileName, "JPG" );
00551 ( (QtRasterDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00552 }
00553 #endif
00554
00555 #if defined ( PLD_pngqt )
00556 void plD_dispatch_init_pngqt( PLDispatchTable *pdt )
00557 {
00558 #ifndef ENABLE_DYNDRIVERS
00559 pdt->pl_MenuStr = "Qt png Driver";
00560 pdt->pl_DevName = "pngqt";
00561 #endif
00562 pdt->pl_type = plDevType_FileOriented;
00563 pdt->pl_seq = 68;
00564 pdt->pl_init = (plD_init_fp) plD_init_rasterqt;
00565 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
00566 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
00567 pdt->pl_eop = (plD_eop_fp) plD_eop_rasterqt;
00568 pdt->pl_bop = (plD_bop_fp) plD_bop_pngqt;
00569 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
00570 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
00571 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
00572 }
00573
00574 void plD_bop_pngqt( PLStream *pls )
00575 {
00576
00577 plGetFam( pls );
00578
00579 pls->famadv = 1;
00580 pls->page++;
00581 if ( qt_family_check( pls ) )
00582 {
00583 return;
00584 }
00585 ( (QtRasterDevice *) pls->dev )->definePlotName( pls->FileName, "PNG" );
00586 ( (QtRasterDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00587 }
00588 #endif
00589
00590 #if defined ( PLD_ppmqt )
00591 void plD_dispatch_init_ppmqt( PLDispatchTable *pdt )
00592 {
00593 #ifndef ENABLE_DYNDRIVERS
00594 pdt->pl_MenuStr = "Qt ppm Driver";
00595 pdt->pl_DevName = "ppmqt";
00596 #endif
00597 pdt->pl_type = plDevType_FileOriented;
00598 pdt->pl_seq = 69;
00599 pdt->pl_init = (plD_init_fp) plD_init_rasterqt;
00600 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
00601 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
00602 pdt->pl_eop = (plD_eop_fp) plD_eop_rasterqt;
00603 pdt->pl_bop = (plD_bop_fp) plD_bop_ppmqt;
00604 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
00605 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
00606 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
00607 }
00608
00609 void plD_bop_ppmqt( PLStream *pls )
00610 {
00611
00612 plGetFam( pls );
00613
00614 pls->famadv = 1;
00615 pls->page++;
00616 if ( qt_family_check( pls ) )
00617 {
00618 return;
00619 }
00620 ( (QtRasterDevice *) pls->dev )->definePlotName( pls->FileName, "PPM" );
00621 ( (QtRasterDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00622 }
00623 #endif
00624
00625 #if defined ( PLD_tiffqt )
00626 void plD_dispatch_init_tiffqt( PLDispatchTable *pdt )
00627 {
00628 #ifndef ENABLE_DYNDRIVERS
00629 pdt->pl_MenuStr = "Qt tiff Driver";
00630 pdt->pl_DevName = "tiffqt";
00631 #endif
00632 pdt->pl_type = plDevType_FileOriented;
00633 pdt->pl_seq = 70;
00634 pdt->pl_init = (plD_init_fp) plD_init_rasterqt;
00635 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
00636 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
00637 pdt->pl_eop = (plD_eop_fp) plD_eop_rasterqt;
00638 pdt->pl_bop = (plD_bop_fp) plD_bop_tiffqt;
00639 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
00640 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
00641 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
00642 }
00643
00644 void plD_bop_tiffqt( PLStream *pls )
00645 {
00646
00647 plGetFam( pls );
00648
00649 pls->famadv = 1;
00650 pls->page++;
00651 if ( qt_family_check( pls ) )
00652 {
00653 return;
00654 }
00655 ( (QtRasterDevice *) pls->dev )->definePlotName( pls->FileName, "TIFF" );
00656 ( (QtRasterDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00657 }
00658 #endif
00659
00660 #if defined ( PLD_svgqt ) && QT_VERSION >= 0x040300
00661 void plD_dispatch_init_svgqt( PLDispatchTable *pdt )
00662 {
00663 #ifndef ENABLE_DYNDRIVERS
00664 pdt->pl_MenuStr = "Qt SVG Driver";
00665 pdt->pl_DevName = "svgqt";
00666 #endif
00667 pdt->pl_type = plDevType_FileOriented;
00668 pdt->pl_seq = 71;
00669 pdt->pl_init = (plD_init_fp) plD_init_svgqt;
00670 pdt->pl_line = (plD_line_fp) plD_line_svgqt;
00671 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_svgqt;
00672 pdt->pl_eop = (plD_eop_fp) plD_eop_svgqt;
00673 pdt->pl_bop = (plD_bop_fp) plD_bop_svgqt;
00674 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_svgqt;
00675 pdt->pl_state = (plD_state_fp) plD_state_svgqt;
00676 pdt->pl_esc = (plD_esc_fp) plD_esc_svgqt;
00677 }
00678
00679 void plD_init_svgqt( PLStream * pls )
00680 {
00681 vectorize = 1;
00682 lines_aa = 1;
00683 plParseDrvOpts( qt_options );
00684
00685
00686 pls->color = 1;
00687 pls->plbuf_write = 0;
00688 pls->dev_fill0 = 1;
00689 pls->dev_fill1 = 0;
00690 pls->dev_gradient = 1;
00691
00692
00693
00694 pls->dev_dash = 0;
00695 pls->dev_flush = 1;
00696
00697
00698 pls->dev_clear = 0;
00699 pls->termin = 0;
00700 pls->page = 0;
00701 pls->dev_text = 1;
00702 pls->dev_unicode = 1;
00703 pls->has_string_length = 1;
00704
00705
00706 bool isMaster = initQtApp( true );
00707
00708 if ( pls->xlength <= 0 || pls->ylength <= 0 )
00709 {
00710 pls->dev = new QtSVGDevice;
00711 pls->xlength = (int) ( ( (QtSVGDevice *) ( pls->dev ) )->m_dWidth );
00712 pls->ylength = (int) ( ( (QtSVGDevice *) ( pls->dev ) )->m_dHeight );
00713 }
00714 else
00715 {
00716 pls->dev = new QtSVGDevice( pls->xlength, pls->ylength );
00717 }
00718 ( (QtSVGDevice *) pls->dev )->setPLStream( pls );
00719
00720 if ( isMaster )
00721 handler.setMasterDevice( (QtSVGDevice *) ( pls->dev ) );
00722
00723 if ( pls->xlength > pls->ylength )
00724 ( (QtSVGDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->xlength / (PLFLT) ( PIXELS_X - 1 );
00725 else
00726 ( (QtSVGDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->ylength / (PLFLT) PIXELS_Y;
00727
00728 plP_setphy( (PLINT) 0, (PLINT) ( pls->xlength / ( (QtSVGDevice *) ( pls->dev ) )->downscale ), (PLINT) 0, (PLINT) ( pls->ylength / ( (QtSVGDevice *) ( pls->dev ) )->downscale ) );
00729
00730 plP_setpxl( POINTS_PER_INCH / 25.4 / ( (QtSVGDevice *) ( pls->dev ) )->downscale, POINTS_PER_INCH / 25.4 / ( (QtSVGDevice *) ( pls->dev ) )->downscale );
00731
00732
00733 plFamInit( pls );
00734
00735 plOpenFile( pls );
00736 }
00737
00738 void plD_bop_svgqt( PLStream *pls )
00739 {
00740
00741 plGetFam( pls );
00742
00743 pls->famadv = 1;
00744 pls->page++;
00745 if ( qt_family_check( pls ) )
00746 {
00747 return;
00748 }
00749 ( (QtSVGDevice *) pls->dev )->definePlotName( pls->FileName );
00750 ( (QtSVGDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
00751 }
00752
00753 void plD_eop_svgqt( PLStream *pls )
00754 {
00755 double downscale;
00756 QSize s;
00757
00758 ( (QtSVGDevice *) pls->dev )->savePlot();
00759
00760
00761 downscale = ( (QtSVGDevice *) pls->dev )->downscale;
00762 s = ( (QtSVGDevice *) pls->dev )->size();
00763 bool isMaster = ( handler.isMasterDevice( (QtSVGDevice *) pls->dev ) );
00764 delete ( (QtSVGDevice *) pls->dev );
00765
00766 pls->dev = new QtSVGDevice( s.width(), s.height() );
00767 ( (QtSVGDevice *) pls->dev )->downscale = downscale;
00768 ( (QtSVGDevice *) pls->dev )->setPLStream( pls );
00769
00770 if ( isMaster )
00771 handler.setMasterDevice( (QtSVGDevice *) pls->dev );
00772 handler.DeviceChangedPage( (QtSVGDevice *) pls->dev );
00773 }
00774
00775 void plD_line_svgqt( PLStream * pls, short x1a, short y1a, short x2a, short y2a )
00776 {
00777 QtSVGDevice* widget = (QtSVGDevice *) pls->dev;
00778 if ( widget != NULL && qt_family_check( pls ) )
00779 {
00780 return;
00781 }
00782 if ( widget == NULL )
00783 return;
00784
00785 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00786 widget->drawLine( x1a, y1a, x2a, y2a );
00787 }
00788
00789 void plD_polyline_svgqt( PLStream *pls, short *xa, short *ya, PLINT npts )
00790 {
00791 QtSVGDevice * widget = (QtSVGDevice *) pls->dev;
00792 if ( widget != NULL && qt_family_check( pls ) )
00793 {
00794 return;
00795 }
00796 if ( widget == NULL )
00797 return;
00798
00799 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00800 widget->drawPolyline( xa, ya, npts );
00801 }
00802
00803 void plD_esc_svgqt( PLStream * pls, PLINT op, void* ptr )
00804 {
00805 short *xa, *ya;
00806 unsigned char *r, *g, *b;
00807 PLFLT *alpha;
00808 PLINT i;
00809 QtSVGDevice * widget = (QtSVGDevice *) pls->dev;
00810 if ( widget != NULL && qt_family_check( pls ) )
00811 {
00812 return;
00813 }
00814 if ( widget == NULL )
00815 return;
00816
00817 switch ( op )
00818 {
00819 case PLESC_FILL:
00820 xa = new short[pls->dev_npts];
00821 ya = new short[pls->dev_npts];
00822
00823 for ( i = 0; i < pls->dev_npts; i++ )
00824 {
00825 xa[i] = pls->dev_x[i];
00826 ya[i] = pls->dev_y[i];
00827 }
00828 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00829 widget->drawPolygon( xa, ya, pls->dev_npts );
00830
00831 delete[] xa;
00832 delete[] ya;
00833 break;
00834
00835 case PLESC_GRADIENT:
00836 xa = new short[pls->dev_npts];
00837 ya = new short[pls->dev_npts];
00838 r = new unsigned char[pls->ncol1];
00839 g = new unsigned char[pls->ncol1];
00840 b = new unsigned char[pls->ncol1];
00841 alpha = new PLFLT[pls->ncol1];
00842
00843 for ( i = 0; i < pls->ncol1; i++ )
00844 {
00845 r[i] = pls->cmap1[i].r;
00846 g[i] = pls->cmap1[i].g;
00847 b[i] = pls->cmap1[i].b;
00848 alpha[i] = pls->cmap1[i].a;
00849 }
00850 widget->setGradient( pls->xgradient[0], pls->xgradient[1], pls->ygradient[0], pls->ygradient[1], r, g, b, alpha, pls->ncol1 );
00851
00852 for ( i = 0; i < pls->dev_npts; i++ )
00853 {
00854 xa[i] = pls->dev_x[i];
00855 ya[i] = pls->dev_y[i];
00856 }
00857 widget->drawPolygon( xa, ya, pls->dev_npts );
00858
00859 delete[] xa;
00860 delete[] ya;
00861 delete[] r;
00862 delete[] g;
00863 delete[] b;
00864 delete[] alpha;
00865 break;
00866
00867 case PLESC_HAS_TEXT:
00868
00869
00870 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00871 widget->drawText( (EscText *) ptr );
00872 break;
00873
00874 default:
00875 break;
00876 }
00877 }
00878
00879 void plD_state_svgqt( PLStream * pls, PLINT op )
00880 {
00881 QtSVGDevice * widget = (QtSVGDevice *) pls->dev;
00882 if ( widget != NULL && qt_family_check( pls ) )
00883 {
00884 return;
00885 }
00886 if ( widget == NULL )
00887 return;
00888
00889 switch ( op )
00890 {
00891 case PLSTATE_WIDTH:
00892 widget->setWidth( pls->width );
00893 break;
00894
00895 case PLSTATE_COLOR0:
00896 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00897 break;
00898
00899 case PLSTATE_COLOR1:
00900 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
00901 break;
00902
00903 default: break;
00904 }
00905 }
00906
00907 void plD_tidy_svgqt( PLStream * pls )
00908 {
00909 QtSVGDevice * widget = (QtSVGDevice *) pls->dev;
00910
00911 if ( widget != NULL )
00912 {
00913 handler.DeviceClosed( widget );
00914 delete widget;
00915 pls->dev = NULL;
00916 }
00917 plCloseFile( pls );
00918
00919 closeQtApp();
00920 }
00921 #endif
00922
00923 #if defined ( PLD_epsqt )
00924 void plD_dispatch_init_epsqt( PLDispatchTable *pdt )
00925 {
00926 #ifndef ENABLE_DYNDRIVERS
00927 pdt->pl_MenuStr = "Qt EPS Driver";
00928 pdt->pl_DevName = "epsqt";
00929 #endif
00930 pdt->pl_type = plDevType_FileOriented;
00931 pdt->pl_seq = 73;
00932 pdt->pl_init = (plD_init_fp) plD_init_epspdfqt;
00933 pdt->pl_line = (plD_line_fp) plD_line_epspdfqt;
00934 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_epspdfqt;
00935 pdt->pl_eop = (plD_eop_fp) plD_eop_epspdfqt;
00936 pdt->pl_bop = (plD_bop_fp) plD_bop_epsqt;
00937 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_epspdfqt;
00938 pdt->pl_state = (plD_state_fp) plD_state_epspdfqt;
00939 pdt->pl_esc = (plD_esc_fp) plD_esc_epspdfqt;
00940 }
00941 #endif
00942
00943 #if defined ( PLD_pdfqt )
00944 void plD_dispatch_init_pdfqt( PLDispatchTable *pdt )
00945 {
00946 #ifndef ENABLE_DYNDRIVERS
00947 pdt->pl_MenuStr = "Qt PDF Driver";
00948 pdt->pl_DevName = "pdfqt";
00949 #endif
00950 pdt->pl_type = plDevType_FileOriented;
00951 pdt->pl_seq = 74;
00952 pdt->pl_init = (plD_init_fp) plD_init_epspdfqt;
00953 pdt->pl_line = (plD_line_fp) plD_line_epspdfqt;
00954 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_epspdfqt;
00955 pdt->pl_eop = (plD_eop_fp) plD_eop_epspdfqt;
00956 pdt->pl_bop = (plD_bop_fp) plD_bop_pdfqt;
00957 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_epspdfqt;
00958 pdt->pl_state = (plD_state_fp) plD_state_epspdfqt;
00959 pdt->pl_esc = (plD_esc_fp) plD_esc_epspdfqt;
00960 }
00961 #endif
00962
00963 #if defined ( PLD_epsqt ) || defined ( PLD_pdfqt )
00964 void plD_init_epspdfqt( PLStream * pls )
00965 {
00966 vectorize = 0;
00967 lines_aa = 1;
00968 plParseDrvOpts( qt_options );
00969
00970
00971 pls->color = 1;
00972 pls->plbuf_write = 0;
00973 pls->dev_fill0 = 1;
00974 pls->dev_fill1 = 0;
00975 pls->dev_gradient = 1;
00976 pls->dev_arc = 1;
00977
00978
00979
00980 pls->dev_dash = 0;
00981 pls->dev_flush = 1;
00982
00983
00984 pls->dev_clear = 0;
00985 pls->termin = 0;
00986 pls->page = 0;
00987 pls->dev_text = 1;
00988 pls->dev_unicode = 1;
00989 pls->has_string_length = 1;
00990
00991
00992
00993 bool isMaster = initQtApp( true );
00994
00995 if ( pls->xlength <= 0 || pls->ylength <= 0 )
00996 {
00997 pls->dev = new QtEPSDevice;
00998 pls->xlength = (int) ( ( (QtEPSDevice *) ( pls->dev ) )->m_dWidth );
00999 pls->ylength = (int) ( ( (QtEPSDevice *) ( pls->dev ) )->m_dHeight );
01000 }
01001 else
01002 {
01003 pls->dev = new QtEPSDevice( pls->xlength, pls->ylength );
01004 }
01005 ( (QtEPSDevice *) pls->dev )->setPLStream( pls );
01006
01007 if ( isMaster )
01008 handler.setMasterDevice( (QtEPSDevice *) ( pls->dev ) );
01009
01010 if ( pls->xlength > pls->ylength )
01011 ( (QtEPSDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->xlength / (PLFLT) ( PIXELS_X - 1 );
01012 else
01013 ( (QtEPSDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->ylength / (PLFLT) PIXELS_Y;
01014
01015 plP_setphy( (PLINT) 0, (PLINT) ( pls->xlength / ( (QtEPSDevice *) ( pls->dev ) )->downscale ), (PLINT) 0, (PLINT) ( pls->ylength / ( (QtEPSDevice *) ( pls->dev ) )->downscale ) );
01016
01017 plP_setpxl( POINTS_PER_INCH / 25.4 / ( (QtEPSDevice *) ( pls->dev ) )->downscale, POINTS_PER_INCH / 25.4 / ( (QtEPSDevice *) ( pls->dev ) )->downscale );
01018
01019
01020 plFamInit( pls );
01021
01022 plOpenFile( pls );
01023 }
01024
01025 void plD_bop_epspdfqt_helper( PLStream *pls, int ifeps )
01026 {
01027
01028 plGetFam( pls );
01029
01030 pls->famadv = 1;
01031 pls->page++;
01032 if ( qt_family_check( pls ) )
01033 {
01034 return;
01035 }
01036 ( (QtEPSDevice *) pls->dev )->definePlotName( pls->FileName, ifeps );
01037 ( (QtEPSDevice *) pls->dev )->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
01038 }
01039
01040 void plD_eop_epspdfqt( PLStream *pls )
01041 {
01042 double downscale;
01043
01044 int argc = 0;
01045 char argv[] = { '\0' };
01046 if ( qt_family_check( pls ) )
01047 {
01048 return;
01049 }
01050 ( (QtEPSDevice *) pls->dev )->savePlot();
01051
01052
01053 downscale = ( (QtEPSDevice *) pls->dev )->downscale;
01054 bool isMaster = handler.isMasterDevice( (QtEPSDevice *) pls->dev );
01055 delete ( (QtEPSDevice *) pls->dev );
01056
01057 pls->dev = new QtEPSDevice;
01058 ( (QtEPSDevice *) pls->dev )->downscale = downscale;
01059
01060 if ( isMaster )
01061 handler.setMasterDevice( (QtEPSDevice *) pls->dev );
01062 handler.DeviceChangedPage( (QtEPSDevice *) pls->dev );
01063 }
01064
01065 void plD_line_epspdfqt( PLStream * pls, short x1a, short y1a, short x2a, short y2a )
01066 {
01067 QtEPSDevice* widget = (QtEPSDevice *) pls->dev;
01068 if ( widget != NULL && qt_family_check( pls ) )
01069 {
01070 return;
01071 }
01072 if ( widget == NULL )
01073 return;
01074
01075 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01076 widget->drawLine( x1a, y1a, x2a, y2a );
01077 }
01078
01079 void plD_polyline_epspdfqt( PLStream *pls, short *xa, short *ya, PLINT npts )
01080 {
01081 QtEPSDevice * widget = (QtEPSDevice *) pls->dev;
01082 if ( widget != NULL && qt_family_check( pls ) )
01083 {
01084 return;
01085 }
01086 if ( widget == NULL )
01087 return;
01088
01089 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01090 widget->drawPolyline( xa, ya, npts );
01091 }
01092
01093 void plD_esc_epspdfqt( PLStream * pls, PLINT op, void* ptr )
01094 {
01095 short *xa, *ya;
01096 unsigned char *r, *g, *b;
01097 PLFLT *alpha;
01098 PLINT i;
01099 QtEPSDevice * widget = (QtEPSDevice *) pls->dev;
01100 arc_struct *arc_info = (arc_struct *) ptr;
01101
01102 if ( widget != NULL && qt_family_check( pls ) )
01103 {
01104 return;
01105 }
01106 if ( widget == NULL )
01107 return;
01108
01109 switch ( op )
01110 {
01111 case PLESC_FILL:
01112 xa = new short[pls->dev_npts];
01113 ya = new short[pls->dev_npts];
01114
01115 for ( i = 0; i < pls->dev_npts; i++ )
01116 {
01117 xa[i] = pls->dev_x[i];
01118 ya[i] = pls->dev_y[i];
01119 }
01120 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01121 widget->drawPolygon( xa, ya, pls->dev_npts );
01122
01123 delete[] xa;
01124 delete[] ya;
01125 break;
01126
01127 case PLESC_GRADIENT:
01128 xa = new short[pls->dev_npts];
01129 ya = new short[pls->dev_npts];
01130 r = new unsigned char[pls->ncol1];
01131 g = new unsigned char[pls->ncol1];
01132 b = new unsigned char[pls->ncol1];
01133 alpha = new PLFLT[pls->ncol1];
01134
01135 for ( i = 0; i < pls->ncol1; i++ )
01136 {
01137 r[i] = pls->cmap1[i].r;
01138 g[i] = pls->cmap1[i].g;
01139 b[i] = pls->cmap1[i].b;
01140 alpha[i] = pls->cmap1[i].a;
01141 }
01142 widget->setGradient( pls->xgradient[0], pls->xgradient[1], pls->ygradient[0], pls->ygradient[1], r, g, b, alpha, pls->ncol1 );
01143
01144 for ( i = 0; i < pls->dev_npts; i++ )
01145 {
01146 xa[i] = pls->dev_x[i];
01147 ya[i] = pls->dev_y[i];
01148 }
01149 widget->drawPolygon( xa, ya, pls->dev_npts );
01150
01151 delete[] xa;
01152 delete[] ya;
01153 delete[] r;
01154 delete[] g;
01155 delete[] b;
01156 delete[] alpha;
01157 break;
01158
01159 case PLESC_HAS_TEXT:
01160
01161
01162 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01163 widget->drawText( (EscText *) ptr );
01164 break;
01165
01166 case PLESC_ARC:
01167 widget->drawArc( arc_info->x, arc_info->y, arc_info->a, arc_info->b, arc_info->angle1, arc_info->angle2, arc_info->rotate, arc_info->fill );
01168 break;
01169
01170 default: break;
01171 }
01172 }
01173
01174 void plD_state_epspdfqt( PLStream * pls, PLINT op )
01175 {
01176 QtEPSDevice * widget = (QtEPSDevice *) pls->dev;
01177 if ( widget != NULL && qt_family_check( pls ) )
01178 {
01179 return;
01180 }
01181 if ( widget == NULL )
01182 return;
01183
01184 switch ( op )
01185 {
01186 case PLSTATE_WIDTH:
01187 widget->setWidth( pls->width );
01188 break;
01189
01190 case PLSTATE_COLOR0:
01191 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01192 break;
01193
01194 case PLSTATE_COLOR1:
01195 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01196 break;
01197
01198
01199 default: break;
01200 }
01201 }
01202
01203 void plD_tidy_epspdfqt( PLStream * pls )
01204 {
01205 QtEPSDevice * widget = (QtEPSDevice *) pls->dev;
01206
01207 if ( widget != NULL )
01208 {
01209 handler.DeviceClosed( widget );
01210 delete widget;
01211 pls->dev = NULL;
01212 }
01213 plCloseFile( pls );
01214
01215 closeQtApp();
01216 }
01217 #endif
01218
01219 #if defined ( PLD_epsqt )
01220 void plD_bop_epsqt( PLStream *pls )
01221 {
01222 plD_bop_epspdfqt_helper( pls, 1 );
01223 }
01224 #endif
01225
01226 #if defined ( PLD_pdfqt )
01227 void plD_bop_pdfqt( PLStream *pls )
01228 {
01229 plD_bop_epspdfqt_helper( pls, 0 );
01230 }
01231 #endif
01232
01233 #if defined ( PLD_qtwidget )
01234 void plD_dispatch_init_qtwidget( PLDispatchTable *pdt )
01235 {
01236 #ifndef ENABLE_DYNDRIVERS
01237 pdt->pl_MenuStr = "Qt Widget";
01238 pdt->pl_DevName = "qtwidget";
01239 #endif
01240 pdt->pl_type = plDevType_Interactive;
01241 pdt->pl_seq = 72;
01242 pdt->pl_init = (plD_init_fp) plD_init_qtwidget;
01243 pdt->pl_line = (plD_line_fp) plD_line_qtwidget;
01244 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_qtwidget;
01245 pdt->pl_eop = (plD_eop_fp) plD_eop_qtwidget;
01246 pdt->pl_bop = (plD_bop_fp) plD_bop_qtwidget;
01247 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_qtwidget;
01248 pdt->pl_state = (plD_state_fp) plD_state_qtwidget;
01249 pdt->pl_esc = (plD_esc_fp) plD_esc_qtwidget;
01250 }
01251
01252 void plD_init_qtwidget( PLStream * pls )
01253 {
01254 vectorize = 0;
01255 lines_aa = 1;
01256 plParseDrvOpts( qt_options );
01257
01258 bool isMaster = initQtApp( true );
01259 QtPLWidget* widget;
01260
01261 if ( pls->xlength <= 0 || pls->ylength <= 0 )
01262 {
01263 widget = new QtPLWidget;
01264 pls->dev = (void *) widget;
01265 pls->xlength = (int) widget->m_dWidth;
01266 pls->ylength = (int) widget->m_dHeight;
01267 }
01268 else
01269 {
01270 widget = new QtPLWidget( pls->xlength, pls->ylength );
01271 pls->dev = (void *) widget;
01272 }
01273 widget->setPLStream( pls );
01274
01275 if ( isMaster )
01276 handler.setMasterDevice( widget );
01277
01278 if ( plsc->xlength > plsc->ylength )
01279 widget->downscale = (PLFLT) plsc->xlength / (PLFLT) ( PIXELS_X - 1 );
01280 else
01281 widget->downscale = (PLFLT) plsc->ylength / (PLFLT) PIXELS_Y;
01282
01283 plP_setphy( (PLINT) 0, (PLINT) ( plsc->xlength / widget->downscale ), (PLINT) 0, (PLINT) ( plsc->ylength / widget->downscale ) );
01284
01285 QPicture temp;
01286 QPainter tempPainter( &temp );
01287
01288 plP_setpxl( temp.logicalDpiX() / 25.4 / widget->downscale, temp.logicalDpiY() / 25.4 / widget->downscale );
01289
01290 pls->color = 1;
01291 pls->plbuf_write = 1;
01292 pls->dev_fill0 = 1;
01293 pls->dev_fill1 = 0;
01294 pls->dev_gradient = 1;
01295 pls->dev_arc = 1;
01296
01297
01298
01299 pls->dev_dash = 0;
01300 pls->dev_flush = 1;
01301
01302
01303 pls->dev_clear = 0;
01304 pls->termin = 1;
01305 pls->dev_text = 1;
01306 pls->dev_unicode = 1;
01307 pls->has_string_length = 1;
01308
01309 widget->setVisible( true );
01310 widget->resize( plsc->xlength, plsc->ylength );
01311 widget->move( plsc->xoffset, plsc->yoffset );
01312
01313 widget->setWindowTitle( pls->plwindow );
01314
01315 qApp->connect( &handler, SIGNAL( MasterChangedPage() ), widget, SLOT( nextPage() ) );
01316 qApp->connect( &handler, SIGNAL( MasterClosed() ), widget, SLOT( close() ) );
01317 }
01318
01319 void plD_eop_qtwidget( PLStream *pls )
01320 {
01321 QtPLWidget* widget = ( (QtPLWidget *) pls->dev );
01322 int currentPage = widget->pageNumber;
01323 widget->flush();
01324 widget->raise();
01325 while ( currentPage == widget->pageNumber && handler.isMasterDevice( widget ) && !pls->nopause )
01326 {
01327 qApp->processEvents( QEventLoop::WaitForMoreEvents );
01328 }
01329 }
01330
01331 void plD_bop_qtwidget( PLStream *pls )
01332 {
01333 QtPLWidget* widget = ( (QtPLWidget *) pls->dev );
01334 widget->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
01335 }
01336
01337 void plD_line_qtwidget( PLStream * pls, short x1a, short y1a, short x2a, short y2a )
01338 {
01339 QtPLWidget* widget = (QtPLWidget *) pls->dev;
01340 if ( widget == NULL )
01341 return;
01342
01343 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01344 widget->drawLine( x1a, y1a, x2a, y2a );
01345 }
01346
01347 void plD_polyline_qtwidget( PLStream *pls, short *xa, short *ya, PLINT npts )
01348 {
01349 QtPLWidget * widget = (QtPLWidget *) pls->dev;
01350 if ( widget == NULL )
01351 return;
01352
01353 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01354 widget->drawPolyline( xa, ya, npts );
01355 }
01356
01357 void plD_esc_qtwidget( PLStream * pls, PLINT op, void* ptr )
01358 {
01359 short *xa, *ya;
01360 PLINT i;
01361 unsigned char *r, *g, *b;
01362 PLFLT *alpha;
01363 QtPLWidget * widget = (QtPLWidget *) pls->dev;
01364 arc_struct *arc_info = (arc_struct *) ptr;
01365 if ( widget == NULL )
01366 return;
01367
01368 switch ( op )
01369 {
01370 case PLESC_FILL:
01371 xa = new short[pls->dev_npts];
01372 ya = new short[pls->dev_npts];
01373
01374 for ( i = 0; i < pls->dev_npts; i++ )
01375 {
01376 xa[i] = pls->dev_x[i];
01377 ya[i] = pls->dev_y[i];
01378 }
01379
01380 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01381 widget->drawPolygon( xa, ya, pls->dev_npts );
01382
01383 delete[] xa;
01384 delete[] ya;
01385 break;
01386
01387 case PLESC_GRADIENT:
01388 xa = new short[pls->dev_npts];
01389 ya = new short[pls->dev_npts];
01390 r = new unsigned char[pls->ncol1];
01391 g = new unsigned char[pls->ncol1];
01392 b = new unsigned char[pls->ncol1];
01393 alpha = new PLFLT[pls->ncol1];
01394
01395 for ( i = 0; i < pls->ncol1; i++ )
01396 {
01397 r[i] = pls->cmap1[i].r;
01398 g[i] = pls->cmap1[i].g;
01399 b[i] = pls->cmap1[i].b;
01400 alpha[i] = pls->cmap1[i].a;
01401 }
01402 widget->setGradient( pls->xgradient[0], pls->xgradient[1], pls->ygradient[0], pls->ygradient[1], r, g, b, alpha, pls->ncol1 );
01403
01404 for ( i = 0; i < pls->dev_npts; i++ )
01405 {
01406 xa[i] = pls->dev_x[i];
01407 ya[i] = pls->dev_y[i];
01408 }
01409 widget->drawPolygon( xa, ya, pls->dev_npts );
01410
01411 delete[] xa;
01412 delete[] ya;
01413 delete[] r;
01414 delete[] g;
01415 delete[] b;
01416 delete[] alpha;
01417 break;
01418
01419 case PLESC_HAS_TEXT:
01420 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01421 widget->drawText( (EscText *) ptr );
01422 break;
01423
01424 case PLESC_ARC:
01425 widget->drawArc( arc_info->x, arc_info->y, arc_info->a, arc_info->b, arc_info->angle1, arc_info->angle2, arc_info->rotate, arc_info->fill );
01426 break;
01427
01428 case PLESC_FLUSH:
01429 widget->flush();
01430 break;
01431 case PLESC_GETC:
01432 widget->getCursorCmd( (PLGraphicsIn *) ptr );
01433 break;
01434 default: break;
01435 }
01436 }
01437
01438 void plD_state_qtwidget( PLStream * pls, PLINT op )
01439 {
01440 QtPLWidget * widget = (QtPLWidget *) pls->dev;
01441 if ( widget == NULL )
01442 return;
01443
01444 switch ( op )
01445 {
01446 case PLSTATE_WIDTH:
01447 widget->setWidth( pls->width );
01448 break;
01449
01450 case PLSTATE_COLOR0:
01451 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01452 break;
01453
01454 case PLSTATE_COLOR1:
01455 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01456 break;
01457
01458
01459 default: break;
01460 }
01461 }
01462
01463 void plD_tidy_qtwidget( PLStream * pls )
01464 {
01465 QtPLWidget * widget = (QtPLWidget *) pls->dev;
01466
01467 if ( widget != NULL )
01468 {
01469 handler.DeviceClosed( widget );
01470 delete widget;
01471 pls->dev = NULL;
01472 }
01473
01474 closeQtApp();
01475 }
01476 #endif
01477
01478 #if defined ( PLD_extqt )
01479 void plD_dispatch_init_extqt( PLDispatchTable *pdt )
01480 {
01481 #ifndef ENABLE_DYNDRIVERS
01482 pdt->pl_MenuStr = "External Qt Widget";
01483 pdt->pl_DevName = "extqt";
01484 #endif
01485 pdt->pl_type = plDevType_Interactive;
01486 pdt->pl_seq = 75;
01487 pdt->pl_init = (plD_init_fp) plD_init_extqt;
01488 pdt->pl_line = (plD_line_fp) plD_line_extqt;
01489 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_extqt;
01490 pdt->pl_eop = (plD_eop_fp) plD_eop_extqt;
01491 pdt->pl_bop = (plD_bop_fp) plD_bop_extqt;
01492 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_extqt;
01493 pdt->pl_state = (plD_state_fp) plD_state_extqt;
01494 pdt->pl_esc = (plD_esc_fp) plD_esc_extqt;
01495 }
01496
01497 void plD_init_extqt( PLStream * pls )
01498 {
01499 vectorize = 0;
01500 lines_aa = 1;
01501
01502 if ( pls->dev == NULL )
01503 {
01504 printf( "Error: use plsetqtdev to set up the Qt device before calling plinit()\n" );
01505 return;
01506 }
01507
01508 QtExtWidget* widget = (QtExtWidget *) ( pls->dev );
01509
01510 if ( widget->m_dWidth > widget->m_dHeight )
01511 widget->downscale = (PLFLT) widget->m_dWidth / (PLFLT) ( PIXELS_X - 1 );
01512 else
01513 widget->downscale = (PLFLT) widget->m_dHeight / (PLFLT) PIXELS_Y;
01514
01515 plP_setphy( (PLINT) 0, (PLINT) ( widget->m_dWidth / widget->downscale ), (PLINT) 0, (PLINT) ( widget->m_dHeight / widget->downscale ) );
01516
01517 QPicture temp;
01518 QPainter tempPainter( &temp );
01519
01520 plP_setpxl( temp.logicalDpiX() / 25.4 / widget->downscale, temp.logicalDpiY() / 25.4 / widget->downscale );
01521
01522 pls->color = 1;
01523 pls->plbuf_write = 0;
01524 pls->dev_fill0 = 1;
01525 pls->dev_fill1 = 0;
01526 pls->dev_gradient = 1;
01527 pls->dev_arc = 1;
01528
01529
01530
01531 pls->dev_dash = 0;
01532 pls->dev_flush = 1;
01533
01534
01535 pls->dev_clear = 0;
01536 pls->termin = 0;
01537 pls->dev_text = 1;
01538 pls->dev_unicode = 1;
01539 pls->has_string_length = 1;
01540 }
01541
01542
01543
01544
01545
01546
01547
01548 void plD_line_extqt( PLStream * pls, short x1a, short y1a, short x2a, short y2a )
01549 {
01550 QtExtWidget * widget = NULL;
01551
01552 widget = (QtExtWidget *) pls->dev;
01553 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01554 widget->drawLine( x1a, y1a, x2a, y2a );
01555 }
01556
01557 void plD_polyline_extqt( PLStream *pls, short *xa, short *ya, PLINT npts )
01558 {
01559 QtExtWidget * widget = NULL;
01560
01561 widget = (QtExtWidget *) pls->dev;
01562 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01563 widget->drawPolyline( xa, ya, npts );
01564 }
01565
01566 void plD_esc_extqt( PLStream * pls, PLINT op, void* ptr )
01567 {
01568 short *xa, *ya;
01569 PLINT i;
01570 unsigned char *r, *g, *b;
01571 PLFLT *alpha;
01572 QtExtWidget * widget = NULL;
01573 arc_struct *arc_info = (arc_struct *) ptr;
01574
01575 widget = (QtExtWidget *) pls->dev;
01576 switch ( op )
01577 {
01578 case PLESC_FILL:
01579 xa = new short[pls->dev_npts];
01580 ya = new short[pls->dev_npts];
01581
01582 for ( i = 0; i < pls->dev_npts; i++ )
01583 {
01584 xa[i] = pls->dev_x[i];
01585 ya[i] = pls->dev_y[i];
01586 }
01587 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01588 widget->drawPolygon( xa, ya, pls->dev_npts );
01589
01590 delete[] xa;
01591 delete[] ya;
01592 break;
01593
01594 case PLESC_GRADIENT:
01595 xa = new short[pls->dev_npts];
01596 ya = new short[pls->dev_npts];
01597 r = new unsigned char[pls->ncol1];
01598 g = new unsigned char[pls->ncol1];
01599 b = new unsigned char[pls->ncol1];
01600 alpha = new PLFLT[pls->ncol1];
01601
01602 for ( i = 0; i < pls->ncol1; i++ )
01603 {
01604 r[i] = pls->cmap1[i].r;
01605 g[i] = pls->cmap1[i].g;
01606 b[i] = pls->cmap1[i].b;
01607 alpha[i] = pls->cmap1[i].a;
01608 }
01609 widget->setGradient( pls->xgradient[0], pls->xgradient[1], pls->ygradient[0], pls->ygradient[1], r, g, b, alpha, pls->ncol1 );
01610
01611 for ( i = 0; i < pls->dev_npts; i++ )
01612 {
01613 xa[i] = pls->dev_x[i];
01614 ya[i] = pls->dev_y[i];
01615 }
01616 widget->drawPolygon( xa, ya, pls->dev_npts );
01617
01618 delete[] xa;
01619 delete[] ya;
01620 delete[] r;
01621 delete[] g;
01622 delete[] b;
01623 delete[] alpha;
01624 break;
01625
01626 case PLESC_HAS_TEXT:
01627
01628
01629 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01630 widget->drawText( (EscText *) ptr );
01631 break;
01632
01633 case PLESC_ARC:
01634 widget->drawArc( arc_info->x, arc_info->y, arc_info->a, arc_info->b, arc_info->angle1, arc_info->angle2, arc_info->rotate, arc_info->fill );
01635 break;
01636
01637 default: break;
01638 }
01639 }
01640
01641 void plD_state_extqt( PLStream * pls, PLINT op )
01642 {
01643 QtExtWidget * widget = NULL;
01644
01645 widget = (QtExtWidget *) pls->dev;
01646 switch ( op )
01647 {
01648 case PLSTATE_WIDTH:
01649 widget->setWidth( pls->width );
01650 break;
01651
01652 case PLSTATE_COLOR0:
01653 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01654 break;
01655
01656 case PLSTATE_COLOR1:
01657 widget->setColor( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a );
01658 break;
01659
01660
01661 default: break;
01662 }
01663 }
01664
01665 void plD_tidy_extqt( PLStream * pls )
01666 {
01667 QtExtWidget * widget = NULL;
01668
01669 widget = (QtExtWidget *) pls->dev;
01670 if ( widget != NULL )
01671 {
01672 handler.DeviceClosed( widget );
01673 delete widget;
01674 pls->dev = NULL;
01675 }
01676
01677 closeQtApp();
01678 }
01679
01680 void plD_eop_extqt( PLStream *pls )
01681 {
01682 }
01683
01684 void plD_bop_extqt( PLStream *pls )
01685 {
01686 QtExtWidget * widget = NULL;
01687 widget = (QtExtWidget *) pls->dev;
01688 widget->setBackgroundColor( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b, pls->cmap0[0].a );
01689 }
01690 #endif
01691
01692 #if defined ( PLD_memqt )
01693 void plD_dispatch_init_memqt( PLDispatchTable *pdt )
01694 {
01695 #ifndef ENABLE_DYNDRIVERS
01696 pdt->pl_MenuStr = "Qt Memory Driver";
01697 pdt->pl_DevName = "memqt";
01698 #endif
01699 pdt->pl_type = plDevType_FileOriented;
01700 pdt->pl_seq = 76;
01701 pdt->pl_init = (plD_init_fp) plD_init_memqt;
01702 pdt->pl_line = (plD_line_fp) plD_line_rasterqt;
01703 pdt->pl_polyline = (plD_polyline_fp) plD_polyline_rasterqt;
01704 pdt->pl_eop = (plD_eop_fp) plD_eop_memqt;
01705 pdt->pl_bop = (plD_bop_fp) plD_bop_memqt;
01706 pdt->pl_tidy = (plD_tidy_fp) plD_tidy_rasterqt;
01707 pdt->pl_state = (plD_state_fp) plD_state_rasterqt;
01708 pdt->pl_esc = (plD_esc_fp) plD_esc_rasterqt;
01709 }
01710
01711 void plD_init_memqt( PLStream * pls )
01712 {
01713 int i;
01714 double dpi;
01715 unsigned char *qt_mem;
01716 unsigned char *input_mem;
01717
01718 vectorize = 0;
01719 lines_aa = 1;
01720 plParseDrvOpts( qt_options );
01721
01722
01723 pls->color = 1;
01724 pls->plbuf_write = 0;
01725 pls->dev_fill0 = 1;
01726 pls->dev_fill1 = 0;
01727 pls->dev_gradient = 1;
01728 pls->dev_arc = 1;
01729
01730
01731
01732 pls->dev_dash = 0;
01733 pls->dev_flush = 1;
01734
01735
01736 pls->dev_clear = 0;
01737 pls->termin = 0;
01738 pls->page = 0;
01739 pls->dev_text = 1;
01740 pls->dev_unicode = 1;
01741 pls->has_string_length = 1;
01742
01743
01744 bool isMaster = initQtApp( true );
01745
01746 if ( pls->xdpi <= 0. )
01747 dpi = DEFAULT_DPI;
01748 else
01749 dpi = pls->xdpi;
01750
01751
01752
01753 pls->xlength = pls->phyxma;
01754 pls->ylength = pls->phyyma;
01755
01756
01757 input_mem = (unsigned char *) pls->dev;
01758
01759
01760 pls->dev = new QtRasterDevice( pls->xlength, pls->ylength );
01761 ( (QtRasterDevice *) pls->dev )->setPLStream( pls );
01762 ( (QtRasterDevice *) pls->dev )->memory = input_mem;
01763
01764 if ( isMaster )
01765 handler.setMasterDevice( (QtRasterDevice *) ( pls->dev ) );
01766
01767 if ( pls->xlength > pls->ylength )
01768 ( (QtRasterDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->xlength / (PLFLT) ( PIXELS_X - 1 );
01769 else
01770 ( (QtRasterDevice *) ( pls->dev ) )->downscale = (PLFLT) pls->ylength / (PLFLT) PIXELS_Y;
01771
01772 plP_setphy( (PLINT) 0, (PLINT) ( pls->xlength / ( (QtRasterDevice *) ( pls->dev ) )->downscale ), (PLINT) 0, (PLINT) ( pls->ylength / ( (QtRasterDevice *) ( pls->dev ) )->downscale ) );
01773
01774 plP_setpxl( dpi / 25.4 / ( (QtRasterDevice *) ( pls->dev ) )->downscale, dpi / 25.4 / ( (QtRasterDevice *) ( pls->dev ) )->downscale );
01775
01776
01777
01778
01779
01780 qt_mem = ( (QtRasterDevice *) pls->dev )->scanLine( 0 );
01781
01782 for ( i = 0; i < ( pls->xlength * pls->ylength ); i++ )
01783 {
01784 qt_mem[2] = input_mem[0];
01785 qt_mem[1] = input_mem[1];
01786 qt_mem[0] = input_mem[2];
01787 if ( pls->dev_mem_alpha == 1 )
01788 {
01789 qt_mem[3] = input_mem[3];
01790 input_mem += 4;
01791 }
01792 else
01793 {
01794 input_mem += 3;
01795 }
01796 qt_mem += 4;
01797 }
01798
01799 ( (QtRasterDevice *) ( pls->dev ) )->setResolution( dpi );
01800
01801
01802 pls->family = true;
01803 }
01804
01805 void plD_bop_memqt( PLStream *pls )
01806 {
01807
01808 }
01809
01810 void plD_eop_memqt( PLStream *pls )
01811 {
01812 int i;
01813 unsigned char *memory;
01814 unsigned char *qt_mem;
01815
01816 memory = ( (QtRasterDevice *) pls->dev )->memory;
01817 qt_mem = ( (QtRasterDevice *) pls->dev )->scanLine( 0 );
01818
01819 for ( i = 0; i < ( pls->xlength * pls->ylength ); i++ )
01820 {
01821 memory[0] = qt_mem[2];
01822 memory[1] = qt_mem[1];
01823 memory[2] = qt_mem[0];
01824 if ( pls->dev_mem_alpha == 1 )
01825 {
01826 memory[3] = qt_mem[3];
01827 memory += 4;
01828 }
01829 else
01830 {
01831 memory += 3;
01832 }
01833 qt_mem += 4;
01834 }
01835 }
01836
01837 #endif