• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

qt.cpp

Go to the documentation of this file.
00001 //
00002 //
00003 // This software is provided under the LGPL in March 2009 by the
00004 // Cluster Science Centre
00005 // QSAS team,
00006 // Imperial College, London
00007 //
00008 // Copyright (C) 2009  Imperial College, London
00009 // Copyright (C) 2009  Alan W. Irwin
00010 //
00011 // This is free software; you can redistribute it and/or modify
00012 // it under the terms of the GNU General Lesser Public License as published
00013 // by the Free Software Foundation; either version 2 of the License, or
00014 // (at your option) any later version.
00015 //
00016 // This software is distributed in the hope that it will be useful,
00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019 // GNU Lesser General Public License for more details.
00020 //
00021 // To received a copy of the GNU Library General Public License
00022 // write to the Free Software Foundation, Inc.,
00023 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00024 //
00025 // History:
00026 //
00027 //
00028 // March 2009:  v1.00
00029 // Initial release.
00030 //
00031 //
00032 
00033 
00034 #include "qt.h"
00035 #include <QMutexLocker>
00036 
00037 // global variables initialised in init(), used in tidy()
00038 // QApplication* app=NULL;
00039 static int  argc;           // argc and argv have to exist when tidy() is used, thus they are made global
00040 static char **argv;
00041 static int  appCounter = 0; // to be rigorous, all uses should be placed between mutexes
00042 
00043 // Drivers declaration
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 }  // extern "C"
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         // On X11 if DISPLAY is not set then cannot open GUI. This allows non-interactive devices to still work in this case.
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 // qt_family_check ()
00126 //
00127 // support function to help supress more than one page if family file
00128 // output not specified by the user  (e.g., with the -fam command-line option).
00129 // Adapted directly from svg.c
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 // Declaration of the driver-specific interface functions
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     // Stream setup
00258     pls->color        = 1;
00259     pls->plbuf_write  = 0;
00260     pls->dev_fill0    = 1;
00261     pls->dev_fill1    = 0;
00262     pls->dev_gradient = 1;      // driver renders gradient
00263     // Let the PLplot core handle dashed lines since
00264     // the driver results for this capability have a number of issues.
00265     // pls->dev_dash=1;
00266     pls->dev_dash  = 0;
00267     pls->dev_flush = 1;
00268     // Driver does not have a clear capability so use (good) PLplot core
00269     // fallback for that instead.
00270     pls->dev_clear         = 0;
00271     pls->termin            = 0;
00272     pls->page              = 0;
00273     pls->dev_text          = 1; // want to draw text
00274     pls->dev_unicode       = 1; // want unicode
00275     pls->has_string_length = 1; // Driver supports string length calculations
00276 
00277     // Needs to be true only because of multi-stream case
00278     bool isMaster = initQtApp( true );
00279 
00280     if ( pls->xdpi <= 0. )
00281         dpi = DEFAULT_DPI;
00282     else
00283         dpi = pls->xdpi;
00284 
00285     // Shamelessly copied on the Cairo stuff :)
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     // Initialize family file info
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     //     case PLESC_DASH:
00375     //       widget->setDashed(pls->nms, pls->mark, pls->space);
00376     //       widget->QtPLDriver::setColor(pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a);
00377     //       widget->drawPolyline(pls->dev_x, pls->dev_y, pls->dev_npts);
00378     //       widget->setSolid();
00379     //       break;
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         //  call the generic ProcessString function
00431         //  ProcessString( pls, (EscText *)ptr );
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     // Plot familying stuff. Not really understood, just copying gd.c
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     // Plot familying stuff. Not really understood, just copying gd.c
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     // Plot familying stuff. Not really understood, just copying gd.c
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     // Plot familying stuff. Not really understood, just copying gd.c
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     // Plot familying stuff. Not really understood, just copying gd.c
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     // Stream setup
00686     pls->color        = 1;
00687     pls->plbuf_write  = 0;
00688     pls->dev_fill0    = 1;
00689     pls->dev_fill1    = 0;
00690     pls->dev_gradient = 1;      // driver renders gradient
00691     // Let the PLplot core handle dashed lines since
00692     // the driver results for this capability have a number of issues.
00693     // pls->dev_dash=1;
00694     pls->dev_dash  = 0;
00695     pls->dev_flush = 1;
00696     // Driver does not have a clear capability so use (good) PLplot core
00697     // fallback for that instead.
00698     pls->dev_clear         = 0;
00699     pls->termin            = 0;
00700     pls->page              = 0;
00701     pls->dev_text          = 1; // want to draw text
00702     pls->dev_unicode       = 1; // want unicode
00703     pls->has_string_length = 1; // Driver supports string length calculations
00704 
00705     // Needs to be true only because of multi-stream case
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     // Initialize family file info
00733     plFamInit( pls );
00734 
00735     plOpenFile( pls );
00736 }
00737 
00738 void plD_bop_svgqt( PLStream *pls )
00739 {
00740     // Plot familying stuff. Not really understood, just copying gd.c
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     // Once saved, we have to create a new device with the same properties
00760     // to be able to plot another page.
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         // call the generic ProcessString function
00869         //  ProcessString( pls, (EscText *)ptr );
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     // Stream setup
00971     pls->color        = 1;
00972     pls->plbuf_write  = 0;
00973     pls->dev_fill0    = 1;
00974     pls->dev_fill1    = 0;
00975     pls->dev_gradient = 1;      // driver renders gradient
00976     pls->dev_arc      = 1;      // driver renders arcs
00977     // Let the PLplot core handle dashed lines since
00978     // the driver results for this capability have a number of issues.
00979     // pls->dev_dash=1;
00980     pls->dev_dash  = 0;
00981     pls->dev_flush = 1;
00982     // Driver does not have a clear capability so use (good) PLplot core
00983     // fallback for that instead.
00984     pls->dev_clear         = 0;
00985     pls->termin            = 0;
00986     pls->page              = 0;
00987     pls->dev_text          = 1; // want to draw text
00988     pls->dev_unicode       = 1; // want unicode
00989     pls->has_string_length = 1; // Driver supports string length calculations
00990 
00991     // QPrinter devices won't create if there is no QApplication declared...
00992     // Needs to be true only because of multi-stream case
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     // Initialize family file info
01020     plFamInit( pls );
01021 
01022     plOpenFile( pls );
01023 }
01024 
01025 void plD_bop_epspdfqt_helper( PLStream *pls, int ifeps )
01026 {
01027     // Plot familying stuff. Not really understood, just copying gd.c
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     // Once saved, we have to create a new device with the same properties
01052     // to be able to plot another page.
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         // call the generic ProcessString function
01161         //  ProcessString( pls, (EscText *)ptr );
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;      // Is a color device
01291     pls->plbuf_write  = 1;      // Store commands to device in core buffer
01292     pls->dev_fill0    = 1;      // Handle solid fills
01293     pls->dev_fill1    = 0;
01294     pls->dev_gradient = 1;      // driver renders gradient
01295     pls->dev_arc      = 1;      // driver renders arcs
01296     // Let the PLplot core handle dashed lines since
01297     // the driver results for this capability have a number of issues.
01298     // pls->dev_dash=1;
01299     pls->dev_dash  = 0;
01300     pls->dev_flush = 1;
01301     // Driver does not have a clear capability so use (good) PLplot core
01302     // fallback for that instead.
01303     pls->dev_clear         = 0;
01304     pls->termin            = 1;
01305     pls->dev_text          = 1; // want to draw text
01306     pls->dev_unicode       = 1; // want unicode
01307     pls->has_string_length = 1; // Driver supports string length calculations
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 /* || pls->xlength <= 0 || pls->ylength <= 0*/ )
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;      // Is a color device
01523     pls->plbuf_write  = 0;
01524     pls->dev_fill0    = 1;      // Handle solid fills
01525     pls->dev_fill1    = 0;
01526     pls->dev_gradient = 1;      // driver renders gradient
01527     pls->dev_arc      = 1;      // driver renders arcs
01528     // Let the PLplot core handle dashed lines since
01529     // the driver results for this capability have a number of issues.
01530     // pls->dev_dash=1;
01531     pls->dev_dash  = 0;
01532     pls->dev_flush = 1;
01533     // Driver does not have a clear capability so use (good) PLplot core
01534     // fallback for that instead.
01535     pls->dev_clear         = 0;
01536     pls->termin            = 0;
01537     pls->dev_text          = 1; // want to draw text
01538     pls->dev_unicode       = 1; // want unicode
01539     pls->has_string_length = 1; // Driver supports string length calculations
01540 }
01541 
01542 //
01543 // These functions are separated out (instead of using dynamic_cast)
01544 // for the benefit of the PyQt4 bindings. C++ QtExtWidgets created
01545 // by PyQt4 are not properly type resolved.
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         // call the generic ProcessString function
01628         //  ProcessString( pls, (EscText *)ptr );
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     // Stream setup
01723     pls->color        = 1;
01724     pls->plbuf_write  = 0;
01725     pls->dev_fill0    = 1;
01726     pls->dev_fill1    = 0;
01727     pls->dev_gradient = 1;      // driver renders gradient
01728     pls->dev_arc      = 1;      // driver renders arcs
01729     // Let the PLplot core handle dashed lines since
01730     // the driver results for this capability have a number of issues.
01731     // pls->dev_dash=1;
01732     pls->dev_dash  = 0;
01733     pls->dev_flush = 1;
01734     // Driver does not have a clear capability so use (good) PLplot core
01735     // fallback for that instead.
01736     pls->dev_clear         = 0;
01737     pls->termin            = 0;
01738     pls->page              = 0;
01739     pls->dev_text          = 1; // want to draw text
01740     pls->dev_unicode       = 1; // want unicode
01741     pls->has_string_length = 1; // Driver supports string length calculations
01742 
01743     // Needs to be true only because of multi-stream case
01744     bool isMaster = initQtApp( true );
01745 
01746     if ( pls->xdpi <= 0. )
01747         dpi = DEFAULT_DPI;
01748     else
01749         dpi = pls->xdpi;
01750 
01751     // Set the plot size to the memory buffer size, on the off chance
01752     // that they are different.
01753     pls->xlength = pls->phyxma;
01754     pls->ylength = pls->phyyma;
01755 
01756     // Save a pointer to the user supplied memory
01757     input_mem = (unsigned char *) pls->dev;
01758 
01759     // Create a appropriately sized raster device
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     // Copy the user supplied memory into the QImage.
01777 //       This device assumes that the format of the QImage
01778 //       is RGB32 (or ARGB).
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]; // R
01785         qt_mem[1] = input_mem[1]; // G
01786         qt_mem[0] = input_mem[2]; // B
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     // This is set so the we'll always make it past the qt_family_check().
01802     pls->family = true;
01803 }
01804 
01805 void plD_bop_memqt( PLStream *pls )
01806 {
01807     // Do nothing to preserve user data
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];           // R
01822         memory[1] = qt_mem[1];           // G
01823         memory[2] = qt_mem[0];           // B
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

Generated on Wed Oct 12 2011 20:42:23 for PLplot by  doxygen 1.7.1