/tags/v5_9_2/drivers/wxwidgets.cpp

/* $Id: wxwidgets.cpp 9320 2009-01-16 08:56:02Z smekal $

   Copyright (C) 2005  Werner Smekal, Sjaak Verdoold
   Copyright (C) 2005  Germain Carrera Corraleche
   Copyright (C) 1999  Frank Huebner

   This file is part of PLplot.

   PLplot is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Library Public License as published
   by the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   PLplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with PLplot; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

/* TODO: 
 * - NA
 */

#include "plDevs.h"

/* plplot headers */
#include "plplotP.h"
#include "drivers.h"

/* C/C++ headers */
#include <cstdio>

/* wxwidgets headers */
#include <wx/wx.h>
#include <wx/wfstream.h>
#include <wx/except.h>

#include "wxwidgets.h"

#ifdef __WXMAC__
	#include <Carbon/Carbon.h>
  extern "C" { void CPSEnableForegroundOperation(ProcessSerialNumber* psn); }
#endif

DECLARE_PLAPP( wxPLplotApp )

/*--------------------------------------------------------------------------
 *  void Log_Verbose( const char *fmt, ... )
 *
 *  Print verbose debug message to stderr (printf style).
 *--------------------------------------------------------------------------*/
void Log_Verbose( const char *fmt, ... )
{
#ifdef _DEBUG_VERBOSE
  va_list args;
  va_start( args, fmt );
  fprintf( stderr, "Verbose: " );
  vfprintf( stderr, fmt, args );
  fprintf( stderr, "\n" );
  va_end( args );
  fflush( stderr );
#endif
}


/*--------------------------------------------------------------------------
 *  void Log_Debug( const char *fmt, ... )
 *
 *  Print debug message to stderr (printf style).
 *--------------------------------------------------------------------------*/
void Log_Debug( const char *fmt, ... )
{
#ifdef _DEBUG
  va_list args;
  va_start( args, fmt );
  fprintf( stderr, "Debug: " );
  vfprintf( stderr, fmt, args );
  fprintf( stderr, "\n" );
  va_end( args );
  fflush( stderr );
#endif
}


/*----------------------------------------------------------------------
 *  In the following you'll find the driver functions which are
 *  are needed by the plplot core.
 *----------------------------------------------------------------------*/

/* Device info */
#ifdef __cplusplus
extern "C" {
#endif

PLDLLIMPEXP_DRIVER const char* plD_DEVICE_INFO_wxwidgets =
#ifdef PLD_wxwidgets
  "wxwidgets:wxWidgets Driver:1:wxwidgets:51:wxwidgets\n"
#endif  
#ifdef PLD_wxpng
  "wxpng:wxWidgets PNG Driver:0:wxwidgets:52:wxpng\n"
#endif  
;

#ifdef __cplusplus
}
#endif


/*--------------------------------------------------------------------------
 *  wxPLDevBase::wxPLDevBase( void )
 *
 *  Contructor of base class of wxPLDev classes.
 *--------------------------------------------------------------------------*/
wxPLDevBase::wxPLDevBase( void )
{
  // Log_Verbose( "wxPLDevBase::wxPLDevBase()" );

  ready = false;
  ownGUI = false;
  waiting = false;
  resizing = false;
  exit=false;

  comcount = 0;

  m_frame=NULL;
  // width, height are set in plD_init_wxwidgets
  // bm_width, bm_height are set in install_buffer
  
  // xmin, xmax, ymin, ymax are set in plD_init_wxwidgets
  // scalex, scaley are set in plD_init_wxwidgets

  plstate_width = false;
  plstate_color0 = false;
  plstate_color1 = false;

  locate_mode=0;
  draw_xhair=false;
  
	newclipregion=true;
	clipminx=1024;
	clipmaxx=0;
	clipminy=800;
	clipmaxy=0;

	freetype=0;
	smooth_text=0;

  devName = (const char **)malloc( NDEV * sizeof(char**) );
  memset( devName, '\0', NDEV * sizeof(char**) );
  devDesc = (const char **)malloc( NDEV * sizeof(char**) );
  memset( devDesc, '\0', NDEV * sizeof(char**) );
	ndev=NDEV;
}


wxPLDevBase::~wxPLDevBase( void )
{
  if( devDesc )
    free( devDesc );
  if( devName )
    free( devName );
}


void wxPLDevBase::AddtoClipRegion( int x1, int y1, int x2, int y2 )
{
	newclipregion=false;
	if( x1<x2 ) {
		if( x1<clipminx ) clipminx=x1;
		if( x2>clipmaxx ) clipmaxx=x2;
	} else {
		if( x2<clipminx ) clipminx=x2;
		if( x1>clipmaxx ) clipmaxx=x1;
	}
	if( y1<y2 ) {
		if( y1<clipminy ) clipminy=y1;
		if( y2>clipmaxy ) clipmaxy=y2;
	} else {
		if( y2<clipminy ) clipminy=y2;
		if( y1>clipmaxy ) clipmaxy=y1;
	}
}


void wxPLDevBase::PSDrawText( PLUNICODE* ucs4, int ucs4Len, bool drawText )
{
  int i = 0;

  char utf8_string[max_string_length];
  char utf8[5];
  memset( utf8_string, '\0', max_string_length );

  /* Get PLplot escape character */
  char plplotEsc;
  plgesc( &plplotEsc );

  /* Get the curent font */
  fontScale = 1.0;
  yOffset = 0.0;
  PLUNICODE fci;
  plgfci( &fci );
  PSSetFont( fci );
  textWidth=0;
  textHeight=0;

  while( i < ucs4Len ) {
    if( ucs4[i] < PL_FCI_MARK ) {	/* not a font change */
      if( ucs4[i] != (PLUNICODE)plplotEsc ) {  /* a character to display */
        ucs4_to_utf8( ucs4[i], utf8 );
        strcat( utf8_string, utf8 );
      	i++;
      	continue;
      }
      i++;
      if( ucs4[i] == (PLUNICODE)plplotEsc ) {   /* a escape character to display */
        ucs4_to_utf8( ucs4[i], utf8 );
        strcat( utf8_string, utf8 );
        i++;
        continue;
      } else {
      	if( ucs4[i] == (PLUNICODE)'u' ) {	/* Superscript */
          // draw string so far
          PSDrawTextToDC( utf8_string, drawText );
          
          // change font scale
      		if( yOffset<0.0 )
            fontScale *= 1.25;  /* Subscript scaling parameter */
      		else
            fontScale *= 0.8;  /* Subscript scaling parameter */
          PSSetFont( fci );

      		yOffset += scaley * fontSize * fontScale / 2.;
      	}
      	if( ucs4[i] == (PLUNICODE)'d' ) {	/* Subscript */
          // draw string so far
          PSDrawTextToDC( utf8_string, drawText );

          // change font scale
          double old_fontScale=fontScale;
      		if( yOffset>0.0 )
            fontScale *= 1.25;  /* Subscript scaling parameter */
      		else
            fontScale *= 0.8;  /* Subscript scaling parameter */
          PSSetFont( fci );

      		yOffset -= scaley * fontSize * old_fontScale / 2.;
      	}
      	if( ucs4[i] == (PLUNICODE)'-' ) {	/* underline */
          // draw string so far
          PSDrawTextToDC( utf8_string, drawText );

          underlined = !underlined; 
          PSSetFont( fci );
      	}
      	if( ucs4[i] == (PLUNICODE)'+' ) {	/* overline */
          /* not implemented yet */
        }
        i++;
      }
    } else { /* a font change */
      // draw string so far
      PSDrawTextToDC( utf8_string, drawText );

      // get new font
      fci = ucs4[i];
      PSSetFont( fci );
      i++;
    }
  }

  PSDrawTextToDC( utf8_string, drawText );
}


/*--------------------------------------------------------------------------
 *  void common_init(  PLStream *pls )
 *
 *  Basic initialization for all devices.
 *--------------------------------------------------------------------------*/
wxPLDevBase* common_init(  PLStream *pls )
{
  // Log_Verbose( "common_init()" );
  
  wxPLDevBase* dev;

  /* default options */
  static PLINT freetype=0;
  static PLINT smooth_text=1;
  static PLINT text=1;
  static PLINT hrshsym = 0;
  
  /* default backend uses wxGraphicsContext, if not available
     the agg library will be used, if not available the basic
     backend will be used. */
  static PLINT backend=wxBACKEND_DC;
	#if wxUSE_GRAPHICS_CONTEXT
		backend=wxBACKEND_GC;
	#else
		#ifdef HAVE_AGG 
			backend=wxBACKEND_AGG;
		#endif
	#endif

  
DrvOpt wx_options[] = {
#ifdef HAVE_FREETYPE
  {"freetype", DRV_INT, &freetype, "Use FreeType library"},
  {"smooth", DRV_INT, &smooth_text, "Turn text smoothing on (1) or off (0)"},
#endif
  {"hrshsym", DRV_INT, &hrshsym, "Use Hershey symbol set (hrshsym=0|1)"},
  {"backend", DRV_INT, &backend, "Choose backend: (0) standard, (1) using AGG library, (2) using wxGraphicsContext"},
  {"text", DRV_INT, &text, "Use own text routines (text=0|1)"},
  {NULL, DRV_INT, NULL, NULL}};

  /* Check for and set up driver options */
  plParseDrvOpts( wx_options );

  /* allocate memory for the device storage */
  switch( backend )
  {
  case wxBACKEND_GC:
  /* in case wxGraphicsContext isn't available, the next backend (agg
     if available) in this list will be used */
#if wxUSE_GRAPHICS_CONTEXT    
    dev = new wxPLDevGC;
    freetype = 0; /* this backend is vector oriented and doesn't know pixels */
    break;
#endif
  case wxBACKEND_AGG:
  /* in case the agg library isn't available, the standard backend
     will be used */
#ifdef HAVE_AGG
    dev = new wxPLDevAGG;
    text = 0; /* text processing doesn't work yet for the AGG backend */
    break;
#endif
  default:
    dev = new wxPLDevDC;
    break;
  }
	if( dev == NULL) {
    fprintf( stderr, "Insufficient memory\n" );
    exit( 0 );
  }
  pls->dev = (void*)dev;
 
/* be verbose and write out debug messages */
#ifdef _DEBUG
  pls->verbose = 1;
  pls->debug = 1;
#else
  pls->verbose = 0;
  pls->debug = 0;
#endif

  pls->color = 1;		    /* Is a color device */
  pls->dev_fill0 = 1;		/* Can handle solid fills */
  pls->dev_fill1 = 0;		/* Can't handle pattern fills */
  pls->dev_dash = 0;
  pls->dev_clear = 1;   /* driver supports clear */
 
  if( text ) {
    pls->dev_text = 1; /* want to draw text */
    pls->dev_unicode = 1; /* want unicode */
    if( hrshsym )
      pls->dev_hrshsym = 1;    
  }
  
#ifdef HAVE_FREETYPE
  if( !text) {
    dev->smooth_text=smooth_text;
    dev->freetype=freetype;
  }

  if( dev->freetype ) {
    pls->dev_text = 1; /* want to draw text */
    pls->dev_unicode = 1; /* want unicode */
    if( hrshsym )
      pls->dev_hrshsym = 1;    

    init_freetype_lv1( pls );
    FT_Data* FT=(FT_Data *)pls->FT;
    FT->want_smooth_text=smooth_text;
  }
#endif

  /* initialize device storage */
  if( pls->xlength <= 0 || pls->ylength <=0 )
    plspage( 0.0, 0.0, (PLINT)(CANVAS_WIDTH*DEVICE_PIXELS_PER_IN), 
                       (PLINT)(CANVAS_HEIGHT*DEVICE_PIXELS_PER_IN), 0, 0 );

  dev->width=pls->xlength;
  dev->height=pls->ylength;
  dev->clipminx=pls->xlength;
  dev->clipminy=pls->ylength;
  
  /* If portrait mode, apply a rotation and set freeaspect */
  if( pls->portrait ) {
    plsdiori( (PLFLT)(4 - ORIENTATION) );
    pls->freeaspect = 1;
  }

  /* Set the number of pixels per mm */
  plP_setpxl( (PLFLT)VIRTUAL_PIXELS_PER_MM, (PLFLT)VIRTUAL_PIXELS_PER_MM );

  /* Set up physical limits of plotting device (in drawing units) */
  plP_setphy( (PLINT)0, (PLINT)(CANVAS_WIDTH*VIRTUAL_PIXELS_PER_IN),
	            (PLINT)0, (PLINT)(CANVAS_HEIGHT*VIRTUAL_PIXELS_PER_IN) );

  /* get physical device limits coordinates */
  plP_gphy( &dev->xmin, &dev->xmax, &dev->ymin, &dev->ymax );

  /* setting scale factors */
  dev->scalex=(PLFLT)(dev->xmax-dev->xmin)/(dev->width);
  dev->scaley=(PLFLT)(dev->ymax-dev->ymin)/(dev->height);  

  /* set dpi */    
  plspage(VIRTUAL_PIXELS_PER_IN/dev->scalex, VIRTUAL_PIXELS_PER_IN/dev->scaley, 0, 0, 0, 0);

#ifdef HAVE_FREETYPE
  if( dev->freetype )
    init_freetype_lv2( pls );
#endif

  /* find out what file drivers are available */
  plgFileDevs( &dev->devDesc, &dev->devName, &dev->ndev );
  
  return dev;
}


#ifdef PLD_wxwidgets

/*--------------------------------------------------------------------------
 *  void plD_dispatch_init_wxwidgets( PLDispatchTable *pdt )
 *
 *  Make wxwidgets driver functions known to plplot.
 *--------------------------------------------------------------------------*/
void plD_dispatch_init_wxwidgets( PLDispatchTable *pdt )
{
#ifndef ENABLE_DYNDRIVERS
    pdt->pl_MenuStr  = "wxWidgets DC";
    pdt->pl_DevName  = "wxwidgets";
#endif
    pdt->pl_type     = plDevType_Interactive;
    pdt->pl_seq      = 51;
    pdt->pl_init     = (plD_init_fp)     plD_init_wxwidgets;
    pdt->pl_line     = (plD_line_fp)     plD_line_wxwidgets;
    pdt->pl_polyline = (plD_polyline_fp) plD_polyline_wxwidgets;
    pdt->pl_eop      = (plD_eop_fp)      plD_eop_wxwidgets;
    pdt->pl_bop      = (plD_bop_fp)      plD_bop_wxwidgets;
    pdt->pl_tidy     = (plD_tidy_fp)     plD_tidy_wxwidgets;
    pdt->pl_state    = (plD_state_fp)    plD_state_wxwidgets;
    pdt->pl_esc      = (plD_esc_fp)      plD_esc_wxwidgets;
}

/*--------------------------------------------------------------------------
 *  plD_init_wxwidgets( PLStream* pls )
 *
 *  Initialize wxWidgets device.
 *--------------------------------------------------------------------------*/
void plD_init_wxwidgets( PLStream* pls )
{
  // Log_Verbose( "plD_init_wxwidgets()" );

  wxPLDevBase* dev;
  dev = common_init( pls );

  pls->plbuf_write = 1;    /* use the plot buffer! */
  pls->termin = 1;             /* interactive device */
  pls->graphx = GRAPHICS_MODE; /*  No text mode for this driver (at least for now, might add a console window if I ever figure it out and have the inclination) */
 
  dev->showGUI = true;  
  dev->bitmapType = (wxBitmapType)0;
}

#endif  /* PLD_wxwidgets */


#ifdef PLD_wxpng

/*--------------------------------------------------------------------------
 *  void plD_dispatch_init_wxpng( PLDispatchTable *pdt )
 *
 *  Make wxpng driver functions known to plplot.
 *--------------------------------------------------------------------------*/
void plD_dispatch_init_wxpng( PLDispatchTable *pdt )
{
#ifndef ENABLE_DYNDRIVERS
    pdt->pl_MenuStr  = "wxWidgets PNG driver";
    pdt->pl_DevName  = "wxpng";
#endif
    pdt->pl_type     = plDevType_FileOriented;
    pdt->pl_seq      = 52;
    pdt->pl_init     = (plD_init_fp)     plD_init_wxpng;
    pdt->pl_line     = (plD_line_fp)     plD_line_wxwidgets;
    pdt->pl_polyline = (plD_polyline_fp) plD_polyline_wxwidgets;
    pdt->pl_eop      = (plD_eop_fp)      plD_eop_wxwidgets;
    pdt->pl_bop      = (plD_bop_fp)      plD_bop_wxwidgets;
    pdt->pl_tidy     = (plD_tidy_fp)     plD_tidy_wxwidgets;
    pdt->pl_state    = (plD_state_fp)    plD_state_wxwidgets;
    pdt->pl_esc      = (plD_esc_fp)      plD_esc_wxwidgets;
}

/*--------------------------------------------------------------------------
 *  void plD_init_wxpng( PLStream *pls )
 *
 *  Initialize wxpng device.
 *--------------------------------------------------------------------------*/
void plD_init_wxpng( PLStream *pls )
{
  // Log_Verbose( "plD_init_wxwidgets()" );

  wxPLDevBase* dev;
  dev = common_init( pls );
  
  /* Initialize family file info */
  plFamInit( pls );

  /* Prompt for a file name if not already set. */
  plOpenFile( pls );  

  pls->plbuf_write = 1;        /* use the plot buffer! */
  pls->termin = 0;             /* interactive device */
  pls->graphx = GRAPHICS_MODE; /*  No text mode for this driver (at least for now, might add a console window if I ever figure it out and have the inclination) */

  dev->showGUI = false;  
  dev->bitmapType = wxBITMAP_TYPE_PNG;
}

#endif  /* PLD_wxpng */


/*--------------------------------------------------------------------------
 *  void plD_line_wxwidgets( PLStream *pls, short x1a, short y1a,
 *													 short x2a, short y2a )
 *
 *  Draws a line from (x1a, y1a) to (x2a, y2a).
 *--------------------------------------------------------------------------*/
void plD_line_wxwidgets( PLStream *pls, short x1a, short y1a, short x2a, short y2a )
{
  // Log_Verbose( "plD_line_wxwidgets(x1a=%d, y1a=%d, x2a=%d, y2a=%d)", x1a, y1a, x2a, y2a );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;
  
  if( !(dev->ready) )
    install_buffer( pls );
  
  dev->DrawLine( x1a, y1a, x2a, y2a );
    
  if( !(dev->resizing) && dev->ownGUI ) {
		dev->comcount+=10;
		if( dev->comcount>MAX_COMCOUNT ) {
			wxRunApp( pls, true );
			dev->comcount=0;
		}
	}
}


/*--------------------------------------------------------------------------
 *  void plD_polyline_wxwidgets( PLStream *pls, short *xa, short *ya,
 *															 PLINT npts )
 *
 *  Draw a poly line - points are in xa and ya arrays.
 *--------------------------------------------------------------------------*/
void plD_polyline_wxwidgets( PLStream *pls, short *xa, short *ya, PLINT npts )
{
  // Log_Verbose( "plD_polyline_wxwidgets()" );

  /* should be changed to use the wxDC::DrawLines function? */
  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  if( !(dev->ready) )
    install_buffer( pls );

  dev->DrawPolyline( xa, ya, npts );

  if( !(dev->resizing) && dev->ownGUI ) {
    dev->comcount+=10;
		if( dev->comcount>MAX_COMCOUNT ) {
			wxRunApp( pls, true );
			dev->comcount=0;
		}
	}
}


/*--------------------------------------------------------------------------
 *  void plD_eop_wxwidgets( PLStream *pls )
 *
 *  End of Page. This function is called if a "end of page" is send by the
 *  user. This command is ignored if we have the plot embedded in a 
 *  wxWidgets application, otherwise the application created by the device
 *  takes over.
 *--------------------------------------------------------------------------*/
void plD_eop_wxwidgets( PLStream *pls )
{
  // Log_Verbose( "plD_eop_wxwidgets()" );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  if( dev->bitmapType ) {
		wxMemoryDC memDC;
		wxBitmap bitmap( dev->width, dev->height, -1 );
		memDC.SelectObject( bitmap );
    
    dev->BlitRectangle( &memDC, 0, 0, dev->width, dev->height );
    wxImage buffer=bitmap.ConvertToImage();
    wxFFileOutputStream fstream( pls->OutFile );
    if(!(buffer.SaveFile( fstream, dev->bitmapType )))
      puts("Troubles saving file!");
    memDC.SelectObject( wxNullBitmap );
  }
  
  if( dev->ownGUI )
    if ( pls->nopause || !dev->showGUI )
      wxRunApp( pls, true );
    else
      wxRunApp( pls );
}


/*--------------------------------------------------------------------------
 *  void plD_bop_wxwidgets( PLStream *pls )
 *
 *  Begin of page. Before any plot command, this function is called, If we
 *  have already a dc the background is cleared in background color and some
 *  state calls are resent - this is because at the first call of this
 *  function, a dc does most likely not exist, but state calls are recorded
 *  and when a new dc is created this function is called again.
 *--------------------------------------------------------------------------*/
void plD_bop_wxwidgets( PLStream *pls )
{
  // Log_Verbose( "plD_bop_wxwidgets()" );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  if( dev->ready ) {
    /* clear background */
		PLINT bgr, bgg, bgb;  /* red, green, blue */
		plgcolbg( &bgr, &bgg, &bgb);  /* get background color information */
    dev->ClearBackground( bgr, bgg, bgb );
    
    /* Replay escape calls that come in before PLESC_DEVINIT.  All of them
     * required a DC that didn't exist yet.
     */
    if( dev->plstate_width )
      plD_state_wxwidgets( pls, PLSTATE_WIDTH );
    dev->plstate_width = false;

    if( dev->plstate_color0 )
      plD_state_wxwidgets( pls, PLSTATE_COLOR0 );
    dev->plstate_color0 = false;

    if( dev->plstate_color1 )
      plD_state_wxwidgets( pls, PLSTATE_COLOR1 );
    dev->plstate_color1 = false;

		/* why this? xwin driver has this */
	  /* pls->page++; */
	}
}


/*--------------------------------------------------------------------------
 *  void plD_tidy_wxwidgets( PLStream *pls )
 *
 *  This function is called, if all plots are done. 
 *--------------------------------------------------------------------------*/
void plD_tidy_wxwidgets( PLStream *pls )
{
  // Log_Verbose( "plD_tidy_wxwidgets()" );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

#ifdef HAVE_FREETYPE
  if( dev->freetype ) {
    FT_Data *FT=(FT_Data *)pls->FT;
    plscmap0n( FT->ncol0_org );
    plD_FreeType_Destroy( pls );
  }
#endif

  if( dev->ownGUI ) {
    wxPLGetApp().RemoveFrame( dev->m_frame );
		if( !wxPLGetApp().FrameCount() )
    	wxUninitialize();
  }
  
  delete dev;
  pls->dev=NULL;  /* since in plcore.c pls->dev is free_mem'd */
}


/*--------------------------------------------------------------------------*\
 *  void plD_state_wxwidgets( PLStream *pls, PLINT op )
 *
 *  Handler for several state codes. Here we take care of setting the width
 *  and color of the pen.
\*--------------------------------------------------------------------------*/
void plD_state_wxwidgets( PLStream *pls, PLINT op )
{
  // Log_Verbose( "plD_state_wxwidgets(op=%d)", op );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  switch( op ) {
		
  case PLSTATE_WIDTH:  /* 1 */
    if( dev->ready )
      dev->SetWidth( pls );
    else
      dev->plstate_width = true;
    break;
		
  case PLSTATE_COLOR0:  /* 2 */
    if( dev->ready )
      dev->SetColor0( pls );
    else
      dev->plstate_color0 = true;
    break;
		
  case PLSTATE_COLOR1:  /* 3 */
    if( dev->ready )
      dev->SetColor1( pls );
    else 
      dev->plstate_color1 = true;
    break;
		
  default:
    if( !(dev->ready) )
      install_buffer( pls );
  }
}


/*--------------------------------------------------------------------------*\
 *  void plD_esc_wxwidgets( PLStream *pls, PLINT op, void *ptr )
 *
 *  Handler for several escape codes. Here we take care of filled polygons,
 *  XOR or copy mode, initialize device (install dc from outside), and if 
 *  there is freetype support, rerendering of text.
\*--------------------------------------------------------------------------*/
void plD_esc_wxwidgets( PLStream *pls, PLINT op, void *ptr )
{
  // Log_Verbose( "plD_esc_wxwidgets(op=%d, ptr=%x)", op, ptr );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  switch (op) {

  case PLESC_FILL:
    fill_polygon( pls );
    break;

	case PLESC_XORMOD:
		/* switch between wxXOR and wxCOPY */
    /* if( dev->ready ) {
			if( dev->m_dc->GetLogicalFunction() == wxCOPY )
				dev->m_dc->SetLogicalFunction( wxXOR );    
			else if( dev->m_dc->GetLogicalFunction() == wxXOR )
				dev->m_dc->SetLogicalFunction( wxCOPY );
		} */
		break;

	case PLESC_DEVINIT:
    dev->SetExternalBuffer( ptr );

    /* replay begin of page call and state settings */
  	plD_bop_wxwidgets( pls );
    break;

  case PLESC_HAS_TEXT:
    if( !(dev->ready) )
      install_buffer( pls );

    if( dev->freetype ) {
#ifdef HAVE_FREETYPE
      plD_render_freetype_text( pls, (EscText *)ptr );
#endif
    } else
      dev->ProcessString( pls, (EscText *)ptr );
    break;

  case PLESC_RESIZE:
  	{
    	wxSize* size=(wxSize*)ptr;
    	wx_set_size( pls, size->GetWidth(), size->GetHeight() );
		}
    break;

	case PLESC_CLEAR:
		if( !(dev->ready) )
			install_buffer( pls );
		/* Since the plot is updated only every MAX_COMCOUNT commands (usually 5000)
			 before we clear the screen we need to show the plot at least once :) */
		if( !(dev->resizing) && dev->ownGUI ) {
				wxRunApp( pls, true );
				dev->comcount=0;
		}
		dev->ClearBackground( pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b,
													pls->sppxmi, pls->sppymi, pls->sppxma, pls->sppyma );
		break;
  
  case PLESC_GETC:
    if( dev->ownGUI )
      GetCursorCmd( pls, (PLGraphicsIn *) ptr );
	  break;

  default:
    break;
  }
}


/*--------------------------------------------------------------------------*\
 *  static void fill_polygon( PLStream *pls )
 *
 *  Fill polygon described in points pls->dev_x[] and pls->dev_y[].
\*--------------------------------------------------------------------------*/
static void fill_polygon( PLStream *pls )
{
  // Log_Verbose( "fill_polygon(), npts=%d, x[0]=%d, y[0]=%d", pls->dev_npts, pls->dev_y[0], pls->dev_y[0] );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

  if( !(dev->ready) )
    install_buffer( pls );

  dev->FillPolygon( pls );

  if( !(dev->resizing) && dev->ownGUI ) {
    dev->comcount+=10;
		if( dev->comcount>MAX_COMCOUNT ) {
			wxRunApp( pls, true );
			dev->comcount=0;
		}
	}
}


/*--------------------------------------------------------------------------*\
 *  void wx_set_size( PLStream* pls, int width, int height )
 *
 *  Adds a dc to the stream. The associated device is attached to the canvas
 *  as the property "dev".  
\*--------------------------------------------------------------------------*/
void wx_set_size( PLStream* pls, int width, int height )
{
  /* TODO: buffer must be resized here or in wxplotstream */
  // Log_Verbose( "wx_set_size()" );
  
  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;

	/* set new size and scale parameters */
	dev->width = width;
	dev->height = height;
  dev->scalex=(PLFLT)(dev->xmax-dev->xmin)/dev->width;
  dev->scaley=(PLFLT)(dev->ymax-dev->ymin)/dev->height;  
    
  /* recalculate the dpi used in calculation of fontsize */
  pls->xdpi = VIRTUAL_PIXELS_PER_IN/dev->scalex;
  pls->ydpi = VIRTUAL_PIXELS_PER_IN/dev->scaley;

  /* clear background if we have a dc, since it's invalid (TODO: why, since in bop
     it must be cleared anyway?) */
  if( dev->ready ) {
		PLINT bgr, bgg, bgb;  /* red, green, blue */
		plgcolbg( &bgr, &bgg, &bgb);  /* get background color information */

    dev->CreateCanvas();
    dev->ClearBackground( bgr, bgg, bgb );
	}
    
  /* freetype parameters must also be changed */
#ifdef HAVE_FREETYPE  
  if( dev->freetype ) {
    FT_Data *FT=(FT_Data *)pls->FT;
    FT->scalex=dev->scalex;   
    FT->scaley=dev->scaley;   
    FT->ymax=dev->height;
  }
#endif
}


/*----------------------------------------------------------------------
 *  int plD_errorexithandler_wxwidgets( const char *errormessage )
 *
 *  If an PLplot error occurs, this function shows a dialog regarding
 *  this error and than exits.
 *----------------------------------------------------------------------*/
int plD_errorexithandler_wxwidgets( const char *errormessage )
{  
  if( errormessage[0] ) {
    wxMessageDialog dialog( 0, wxString(errormessage, *wxConvCurrent),wxString("wxWidgets PLplot App error",*wxConvCurrent),wxOK|wxICON_ERROR );
    dialog.ShowModal();
  }

  return 0;
}


/*----------------------------------------------------------------------
 *  void plD_erroraborthandler_wxwidgets( const char *errormessage )
 *
 *  If PLplot aborts, this function shows a dialog regarding
 *  this error.
 *----------------------------------------------------------------------*/
void plD_erroraborthandler_wxwidgets( const char *errormessage )
{  
  if( errormessage[0] ) {
    wxMessageDialog dialog( 0,(wxString(errormessage, *wxConvCurrent)+wxString(" aborting operation...", *wxConvCurrent)), wxString("wxWidgets PLplot App abort",*wxConvCurrent), wxOK|wxICON_ERROR );
    dialog.ShowModal();
  }
}




#ifdef HAVE_FREETYPE

/*----------------------------------------------------------------------*\
 *  static void plD_pixel_wxwidgets( PLStream *pls, short x, short y )
 *
 *  callback function, of type "plD_pixel_fp", which specifies how a single
 *  pixel is set in the current colour.
\*----------------------------------------------------------------------*/
static void plD_pixel_wxwidgets( PLStream *pls, short x, short y )
{
  // Log_Verbose( "plD_pixel_wxwidgets" );

  wxPLDevBase *dev=(wxPLDevBase*)pls->dev;

  if( !(dev->ready) )
    install_buffer( pls );

  dev->PutPixel( x, y );

  if( !(dev->resizing) && dev->ownGUI ) {
    dev->comcount++;
		if( dev->comcount>MAX_COMCOUNT ) {
			wxRunApp( pls, true );
			dev->comcount=0;
		}
	}
}


/*----------------------------------------------------------------------*\
 *  static void plD_pixel_wxwidgets( PLStream *pls, short x, short y )
 *
 *  callback function, of type "plD_pixel_fp", which specifies how a single
 *  pixel is set in the current colour.
\*----------------------------------------------------------------------*/
static void plD_set_pixel_wxwidgets( PLStream *pls, short x, short y, PLINT colour)
{
  // Log_Verbose( "plD_set_pixel_wxwidgets" );

  wxPLDevBase *dev=(wxPLDevBase*)pls->dev;

  if( !(dev->ready) )
    install_buffer( pls );

  dev->PutPixel( x, y, colour );

  if( !(dev->resizing) && dev->ownGUI ) {
    dev->comcount++;
		if( dev->comcount>MAX_COMCOUNT ) {
			wxRunApp( pls, true );
			dev->comcount=0;
		}
	}
}


/*--------------------------------------------------------------------------*\
 *  void plD_read_pixel_wxwidgets (PLStream *pls, short x, short y)
 *
 *  callback function, of type "plD_pixel_fp", which specifies how a single
 *  pixel is read.
\*--------------------------------------------------------------------------*/
static PLINT plD_read_pixel_wxwidgets ( PLStream *pls, short x, short y )
{
  // Log_Verbose( "plD_read_pixel_wxwidgets" );

  wxPLDevBase *dev=(wxPLDevBase*)pls->dev;
  
  if( !(dev->ready) )
    install_buffer( pls );

  return dev->GetPixel( x, y );
}


/*----------------------------------------------------------------------*\
 *  void init_freetype_lv1 (PLStream *pls)
 *
 *  "level 1" initialisation of the freetype library.
 *  "Level 1" initialisation calls plD_FreeType_init(pls) which allocates
 *  memory to the pls->FT structure, then sets up the pixel callback
 *  function.
\*----------------------------------------------------------------------*/
static void init_freetype_lv1( PLStream *pls )
{
  // Log_Verbose( "init_freetype_lv1" );

  wxPLDevBase *dev=(wxPLDevBase*)pls->dev;

	plD_FreeType_init( pls );

	FT_Data *FT=(FT_Data *)pls->FT;
	FT->pixel = (plD_pixel_fp)plD_pixel_wxwidgets;

  /*
   *  See if we have a 24 bit device (or better), in which case
   *  we can use the better antialising.
   */
  // the bitmap we are using in the antialized case has always
  // 32 bit depth
  FT->BLENDED_ANTIALIASING=1;
  FT->read_pixel= (plD_read_pixel_fp)plD_read_pixel_wxwidgets;
  FT->set_pixel= (plD_set_pixel_fp)plD_set_pixel_wxwidgets;
}


/*----------------------------------------------------------------------*\
 *  void init_freetype_lv2 (PLStream *pls)
 *
 *  "Level 2" initialisation of the freetype library.
 *  "Level 2" fills in a few setting that aren't public until after the
 *  graphics sub-syetm has been initialised.
 *  The "level 2" initialisation fills in a few things that are defined
 *  later in the initialisation process for the GD driver.
 *
 *  FT->scale is a scaling factor to convert co-ordinates. This is used by
 *  the GD and other drivers to scale back a larger virtual page and this
 *  eliminate the "hidden line removal bug". Set it to 1 if your device
 *  doesn't have scaling.
 *
 *  Some coordinate systems have zero on the bottom, others have zero on
 *  the top. Freetype does it one way, and most everything else does it the
 *  other. To make sure everything is working ok, we have to "flip" the
 *  coordinates, and to do this we need to know how big in the Y dimension
 *  the page is, and whether we have to invert the page or leave it alone.
 *
 *  FT->ymax specifies the size of the page FT->invert_y=1 tells us to
 *  invert the y-coordinates, FT->invert_y=0 will not invert the
 *  coordinates.
\*----------------------------------------------------------------------*/

static void init_freetype_lv2( PLStream *pls )
{
  // Log_Verbose( "init_freetype_lv2" );

  wxPLDevBase *dev=(wxPLDevBase *)pls->dev;
  FT_Data *FT=(FT_Data *)pls->FT;
  
  FT->scalex=dev->scalex;
  FT->scaley=dev->scaley;
  FT->ymax=dev->height;
  FT->invert_y=1;
  FT->smooth_text=0;
  
  if ((FT->want_smooth_text==1)&&(FT->BLENDED_ANTIALIASING==0))    /* do we want to at least *try* for smoothing ? */
  {
    FT->ncol0_org=pls->ncol0;                                   /* save a copy of the original size of ncol0 */
    FT->ncol0_xtra=16777216-(pls->ncol1+pls->ncol0);            /* work out how many free slots we have */
    FT->ncol0_width=FT->ncol0_xtra/(pls->ncol0-1);              /* find out how many different shades of anti-aliasing we can do */
    if (FT->ncol0_width>4)     /* are there enough colour slots free for text smoothing ? */
       {
        if (FT->ncol0_width>max_number_of_grey_levels_used_in_text_smoothing)
           FT->ncol0_width=max_number_of_grey_levels_used_in_text_smoothing;                 /* set a maximum number of shades */
        plscmap0n(FT->ncol0_org+(FT->ncol0_width*pls->ncol0));      /* redefine the size of cmap0 */
    /* the level manipulations are to turn off the plP_state(PLSTATE_CMAP0)
    * call in plscmap0 which (a) leads to segfaults since the GD image is
    * not defined at this point and (b) would be inefficient in any case since
    * setcmap is always called later (see plD_bop_png) to update the driver
    * color palette to be consistent with cmap0. */
         {
          PLINT level_save;
          level_save = pls->level;
          pls->level = 0;
          pl_set_extended_cmap0(pls, FT->ncol0_width, FT->ncol0_org); /* call the function to add the extra cmap0 entries and calculate stuff */
          pls->level = level_save;
         }
        FT->smooth_text=1;      /* Yippee ! We had success setting up the extended cmap0 */
      }
  } else if ((FT->want_smooth_text==1)&&(FT->BLENDED_ANTIALIASING==1))    /* If we have a truecolour device, we wont even bother trying to change the palette */
   {
     FT->smooth_text=1;
   } else
     plwarn("Insufficient colour slots available in CMAP0 to do text smoothing.");
}

#endif


/*--------------------------------------------------------------------------
 * GetCursorCmd()
 *
 * Waits for a graphics input event and returns coordinates.
 *--------------------------------------------------------------------------*/
static void GetCursorCmd( PLStream* pls, PLGraphicsIn* ptr)
{
  // Log_Verbose( "GetCursorCmd" );

  wxPLDevBase *dev=(wxPLDevBase *)pls->dev;
  PLGraphicsIn *gin = &(dev->gin);

  /* Initialize */
  plGinInit( gin );
  dev->locate_mode = LOCATE_INVOKED_VIA_API;  
  dev->draw_xhair=true;

  /* Run event loop until a point is selected */
  wxRunApp( pls, false );
  
  *ptr = *gin;
  if( dev->locate_mode ) {
    dev->locate_mode = 0;
    dev->draw_xhair=false;
  }
}




/*----------------------------------------------------------------------
 *  This part includes wxWidgets specific functions, which allow to
 *  open a window from the command line, if needed.
 *----------------------------------------------------------------------*/


/*----------------------------------------------------------------------
 *  void install_buffer( PLStream *pls )
 *
 *  If this driver is called from a command line executable (and not
 *  from within a wxWidgets program), this function prepares a DC and a
 *  bitmap to plot into.
 *----------------------------------------------------------------------*/
static void install_buffer( PLStream *pls )
{
  // Log_Verbose( "install_buffer" );

  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;
  static bool initApp=false;
  
  if( !initApp ) {
    /* this hack enables to have a GUI on Mac OSX even if the 
       program was called from the command line (and isn't a bundle) */
#ifdef __WXMAC__
    ProcessSerialNumber psn;

    GetCurrentProcess( &psn );
    CPSEnableForegroundOperation( &psn );
    SetFrontProcess( &psn );
#endif

    /* initialize wxWidgets */
    wxInitialize();
    wxLog::GetActiveTarget();
    wxTRY {
      wxPLGetApp().CallOnInit();
    }
    wxCATCH_ALL( wxPLGetApp().OnUnhandledException(); fprintf(stderr, "Can't init wxWidgets!\n"); exit(0); )
    initApp=true;
  }
  

  wxString title=wxT("wxWidgets PLplot App");
  switch(dev->backend) {
  case wxBACKEND_DC:
  	title += wxT(" (basic)");
  	break;
  case wxBACKEND_GC:
  	title += wxT(" (wxGC)");
  	break;
  case wxBACKEND_AGG:
  	title += wxT(" (AGG)");
  	break;
  default:
  	break;
  }
  dev->m_frame = new wxPLplotFrame( title, pls );
  wxPLGetApp().AddFrame( dev->m_frame );
  dev->m_frame->SetClientSize( dev->width, dev->height );
  if( dev->showGUI ) {
    dev->m_frame->Show( true );
    dev->m_frame->Raise();
  }
  else
    dev->m_frame->Show( false );
	
  /* get a DC and a bitmap or an imagebuffer */
  dev->ownGUI = true;
  dev->bm_width=dev->width;
  dev->bm_height=dev->height;
  dev->CreateCanvas();
  dev->ready = true;

	/* Set wx error handler for various errors in plplot*/
  plsexit( plD_errorexithandler_wxwidgets );
  plsabort( plD_erroraborthandler_wxwidgets );
  
  /* replay command we may have missed */
  plD_bop_wxwidgets( pls );
}
 

/*----------------------------------------------------------------------
 *  void wxRunApp( PLStream *pls, bool runonce )
 *
 *  This is a hacked wxEntry-function, so that wxUninitialize is not
 *  called twice. Here we actually start the wxApplication.
 *----------------------------------------------------------------------*/
static void wxRunApp( PLStream *pls, bool runonce )
{
  // Log_Verbose( "wxRunApp" );  
  
  wxPLDevBase* dev = (wxPLDevBase*)pls->dev;
  
  dev->waiting=true;
  wxTRY
  {
    class CallOnExit
    {
    public:
      /* only call OnExit if exit is true (i.e. due an exception) */
      ~CallOnExit() { if(exit) wxPLGetApp().OnExit(); }
      bool exit;
    } callOnExit;
    
    callOnExit.exit=true;
    wxPLGetApp().SetAdvanceFlag( runonce );
    wxPLGetApp().SetRefreshFlag();

		/* add an idle event is necessary for Linux (wxGTK2)
		   but not for Windows, but it doesn't harm */
	  wxIdleEvent event;
    wxPLGetApp().AddPendingEvent( event );
		wxPLGetApp().OnRun();   /* start wxWidgets application */
    callOnExit.exit=false;
  }
  wxCATCH_ALL( wxPLGetApp().OnUnhandledException(); fprintf(stderr, "Problem running wxWidgets!\n"); exit(0); )

  if( dev->exit ) {
    wxPLGetApp().OnExit();
    plexit("");
  }

  dev->waiting=false;
}