Plot.h

#ifndef _WINC_PLOT
#define _WINC_PLOT
 
#include <WXP/ColorBar.h>
#include <WXP/ColorMap.h>
#include <WXP/Date.h>
#include <WXP/Domain.h>
#include <WXP/DomainVal.h>
#include <WXP/EarthPoint.h>
#include <WXP/EarthPoints.h>
#include <WXP/GeomBox.h>
#include <WXP/Graph.h>
#include <WXP/GridPoint.h>
#include <WXP/Image.h>
#include <WXP/Listener.h>
#include <WXP/Panel.h>
#include <WXP/PlotAttr.h>
#include <WXP/PlotLabel.h>
#include <WXP/Point.h>
#include <WXP/Points.h>
#include <WXP/Rect.h>
#include <WXP/String.h>
#include <WXP/Timezone.h>
 
namespace WXP {
   class Plot : public Listener {
      Graph graph;
      ColorMap colormap;
      String color_label;
 
      static const int max_panel = 16;
      char def_panel[50];
      Panel panels[max_panel];
      int cur_panel;
      int num_panel;
     
      int full;
      int output;
      int permit_callbacks;
      bool draw[13];
      char title[80];
    
      int line_color;
      int fill_color;
      int text_color;
      int mark_color;
 
      int layer;
      char trans_color[20];
 
      static const int max_label = 30;
      PlotLabel label[30];
      int num_label;
      char label_format[100];
      int bar;
      ColorBar cbar;
      String logo;
      bool time_sync;
      char source[10];
      float fore_hour;
      Date date;
      Timezone tz;
   
      public:
      Plot();
      Plot( const char *param );
      ~Plot();
      int init();
      int open( const char *param );
      int open();
      int close();
      int setParam( const char *param );
      int setLogo( const char *rlogo );
      inline int setFixed( bool val ){ return graph.setFixed( val ); };
      int getDevice( String &str );
      void callback( const char *ev_str, const char *ev_data, const void *data );
      inline int permitCallbacks( int val ){ permit_callbacks = val; return 1; };
      int initPanel();
      inline int setDefaultPanel( const char *str ){ StrLib::copy( def_panel, 30, str ); return 1 ;};
      int setPanel( Rect &offset, float aspect, int halign, int valign );
      int setPanel( Rect &offset, float aspect );
      int setPanel( Rect &offset, Domain &ndomain );
      int setPanel( Domain &domain );
      int setPanel( Rect &offset );
      int setPanel();
      int setPanel( int ind );
      int setPanelDomain( int ind, Domain &dom );
      int getPanelDomain( int ind, Domain &dom );
      int setDomain( Rect &offset, float aspect, int halign, int valign );
      int setDomain( Rect &offset, float aspect );
      int setDomain( Rect &offset, Domain &ndomain );
      int setDomain( Domain &domain );
      int setDomain( DomainVal &dv );
      int setDomain( Rect &offset );
      int setDomain();
      DomainVal getDomainVal();
      Domain getDomain();
      int getProj();
      float getPLat();
      float getPLon();
      float getDomVert();
      float getDomAspect();
      float getDomCLat();
      float getDomCLon();
      int getDomNx();
      int getDomNy();
      float getDomDx();
      float getDomDy();
      float getVert();
      bool withinDomain( Point &pt );
      bool withinDomain( EarthPoint &ept );
      bool withinDomainExt( Point &pt, int ext );
      bool withinDomainExt( EarthPoint &ept, int ext );
      int whereDomain( Point &pt );
      int whereDomain( EarthPoint &ept );
      
      int newPanel( const char *params );
      int clear();
      int clearRect( Rect &rect );
      int update();
      int manage();
      inline bool isManaged(){ return graph.isManaged(); };
      int end();
   
      inline bool isTimeSync(){ return time_sync; };
      inline int setTimeSync( bool val ){ time_sync = val; return 1; };
      inline int setDate( Date &rdate ){ date = rdate; return 1; };
      inline bool isDateSet(){ return date.isSet(); };
      inline int setForeHour( float val ){ fore_hour = val; return 1; };
      int setDataSource( const char *str );
 
      ColorMap getColorMap();
      int getColorMap( ColorMap &map );
      inline int getNumFill(){ return colormap.getNumFill(); };
      int allocColor( int ind );
      int setColorMap( ColorMap &cmap );
      int getColorRGB( int ind, float &r, float &g, float &b );
      int getColorValue( const char *name );
   
      int cropLine( Point &pt1, Point &pt2 );
      int cropLine( Points &pts );
      int drawLine( float x1, float y1, float x2, float y2 );
      int drawLine( Point &pt1, Point &pt2 );
      int drawLine( EarthPoint &ept1, EarthPoint &ept2 );
      int drawLine( GridPoint &gpt1, GridPoint &gpt2 );
      int drawLine( Points &pts );
      int drawLine( EarthPoints &data );
      int drawSpline( Points &data );
      int drawSpline( EarthPoints &data );
      int drawRect( float x1, float y1, float x2, float y2 );
      int drawRect( Rect &rect );
      int drawCircle( Point &pt, float rad );
      int drawCircle( EarthPoint &ept, float rad );
      int setLineColor( const char *name );
      int setLineColor( int ind );
      int setLineWidth( float width );
      int setLineStyle( int style );
      int setLine();
      int setLine( PlotAttr &plot );
      int setLine( const char *str );
   
      int drawFill( Points &pts );
      int drawFill( EarthPoints &data );
      int drawFill( Rect &data );
      int drawFillarea( Points &data );
      int setFillColor( const char *name );
      int setFillColor( int ind );
      int setFillStyle( int index );
      int setFill();
      int setFill( PlotAttr &plot );
      int setFill( const char *str );
   
      int drawText( float x, float y, const char *text );
      int drawText( Point &pt, const char *text );
      int drawText( EarthPoint &ept, const char *text );
      int drawText( GridPoint &gpt, const char *text );
      int drawFormText( Point &pt, const char *format, ... );
      int drawFormText( EarthPoint &ept, const char *format, ... );
      int setTextHeight( float height );
      int setTextWeight( float weight );
      int setTextAlign( int hor, int vert );
      int setTextColor( const char *name );
      int setTextColor( int ind );
      int setTextExpansion( float expansion );
      int setTextSpacing( float space );
      int setTextCharWidth( float width );
      int setTextDirection( float x, float y );
      int setFont( const char *str );
      inline int setDropShadow( int val ){ return graph.setDropShadow( val ); };
      inline int getDropShadow(){ return graph.getDropShadow(); };
      int setText();
      int setText( PlotAttr &plot );
      int setText( PlotAttr &plot, float scale );
      int setText( const char *str );
   
      int drawMark( float x, float y );
      int drawMark( Point &pt );
      int drawMark( EarthPoint &ept );
      int drawMark( GridPoint &gpt );
      int setMarkColor( const char *name );
      int setMarkColor( int ind );
      int setMarkType( const char *type );
      int setMarkType( int type );
      int setMarkSize( float size );
      int setMarkWeight( float weight );
      int setMark();
      int setMark( PlotAttr &plot );
      int setMark( PlotAttr &plot, float scale );
      int setMark( const char *str );
 
      inline int setSymbol( const char *symbol ){
         return graph.setSymbol( symbol );
      }
   
      inline int drawSymbol( Point pt, const char *string, float size ){
         return graph.drawSymbol( pt, string, size );
      }
   
      int setImageAlign( int h, int v );
      int drawImage( Image &image );
      int drawImage( Image &image, int bgcolor );
 
      inline int drawImage( Image &image, float x, float y ){
         return graph.drawImage( image, x, y );
      }
      
      inline int drawImage( Image &image, int bgcolor, float x, float y ){
         return graph.drawImage( image, bgcolor, x, y );
      }
      
      int drawImage( const char *file, float x, float y );
      int drawImage( const char *file, float x, float y, const char *option );
 
      inline int getTran(){
         return graph.getTran();
      }
      
      inline int activateTran( int val ){
         return graph.activateTran( val );
      }
      
      inline int setViewport( int num, Rect rect ){
         return graph.setViewport( num, rect );
      }
      
      inline int getViewport( Rect &lim ){
         return graph.getViewport( lim );
      }
      
      inline int setWindow( int num, Rect rect ){
         return graph.setWindow( num, rect );
      }
      
      inline int getWindow( Rect &lim ){
         return graph.getWindow( lim );
      }
      
      inline int tran( EarthPoint &ept, Point &pt ){
         return panels[cur_panel].domain.tran( ept, pt );
      }
      
      inline int tran( Point &pt, EarthPoint &ept ){
         return panels[cur_panel].domain.tran( pt, ept );
      }
      
      inline int tran( GridPoint &gpt, Point &pt ){
         return panels[cur_panel].domain.tran( gpt, pt );
      }
      
      inline int tran( Point &pt, GridPoint &gpt ){
         return panels[cur_panel].domain.tran( pt, gpt );
      }
      
      inline int tran( EarthPoint &ept, GridPoint &gpt ){
         return panels[cur_panel].domain.tran( ept, gpt );
      }
      
      inline int tran( GridPoint &gpt, EarthPoint &ept ){
         return panels[cur_panel].domain.tran( gpt, ept );
      }
      
      inline int tran( int val, Point &pt ){
         return panels[cur_panel].domain.tran( val, pt );
      }
      
      inline int tran( int val, GridPoint &gpt ){
         return panels[cur_panel].domain.tran( val, gpt );
      }
      
      inline int tran( int val, EarthPoint &ept ){
         return panels[cur_panel].domain.tran( val, ept );
      }
      
      inline int tran( Domain &dom, Point &pt1, Point &pt2 ){
         return Domain::translate( dom, panels[cur_panel].domain, pt1, pt2 );
      }
 
      int tranPlotWindow( float x1, float y1, float &x2, float &y2 );
 
      inline int tranWindow( int tran1, Point &pt1, int tran2, Point &pt2 ){
         return graph.tranWindow( tran1, pt1, tran2, pt2 );
      }
      
      inline int adjustDom( Point &pt ){
         return panels[cur_panel].domain.adjust( pt );
      }
 
      inline int adjustDom( Points &pts ){
         return panels[cur_panel].domain.adjust( pts );
      }
 
      inline float adjustDir( float dir, Point &pt ){
         return panels[cur_panel].domain.adjustDir( dir, pt );
      }
 
      inline int offsetPoint( Point pt, float dir, float rad, Point &opt ){
         return panels[cur_panel].domain.offset( pt, dir, rad, opt );
      }
      
      inline int offsetPoint( EarthPoint pt, float dir, float rad, EarthPoint &opt ){
         return panels[cur_panel].domain.offsetLatLon( pt, dir, rad, opt );
      }
      
      inline float getMapFactor( EarthPoint ept ){
         return panels[cur_panel].domain.getMapFactor( ept );
      }
 
      inline int getInverse(){
         return graph.getInverse();
      }
 
      int addCallback( const char *ev, Listener *list, const void *data );
      int message( const char *str, ... );
   
      int getViewDomain( Domain &domain );
      int drawBorder();
      int saveImage(const char *file, const char *type);
      int saveImage(const char *file);
      int getImage(Image &image);
      int setLabelColor( const char *str );
      int setLabelFormat( const char *str );
      int addLabel( const char *loc, const char *label );
      int setLabel( const char *loc, const char *label );
      int getLabelPosIndex( const char *str );
      int printLabels();
      int formatLabel( const char *form, char *str, int len );
      int clearLabels();
      int drawLabels();
      int setBarLocate( const char *str );
      int setBarRange( Range &rrange );
      int setBar( ColorFill &rfile, Range &rrange );
      int setBar( ColorFill &rfill );
      int setBar( Enhance &renh );
      int drawBar( Range &rrange );
      int drawEnhBar();
      int drawBar();
      int setCursor( int type );
      int done();
      int newFrame();
      int clearFrame();
      int deleteFrame( int ind );
      int deleteAllFrames();
      int setFull( int val );
      int getFull();
      int setDrawing( const char *str );
      bool isDrawing( int ind );
      int printDrawing();
      inline int wrapLine( Points &pts ){ return panels[cur_panel].domain.wrapLine( pts ); };
      inline int offsetLine( Points &pts, int flag ){ return panels[cur_panel].domain.offsetLine( pts, flag ); };
 
      inline int printTran(){ graph.printTran(); return 1; };
      inline int printDomain(){ panels[cur_panel].domain.print(); return 1; };
 
      static int decodeGeometryStr( const char *str, GeomBox &geom );
      static int decodePanelStr( Rect rect, const char *str, GeomBox &geom );
   
      /*
         Output types
      */
      enum Output { 
         WINDOW, 
         IMAGE, 
         PRINT
      };
      enum DrawingType {
         DRAW_PLOT,
         DRAW_DATA,
         DRAW_MAP,
         DRAW_TEXT_UL,
         DRAW_TEXT_UC,
         DRAW_TEXT_UR,
         DRAW_TEXT_LL,
         DRAW_TEXT_LC,
         DRAW_TEXT_LR,
         DRAW_BORD
      };
      enum TranType {
         TRAN_BASE,
         TRAN_PROJ,
         TRAN_OVER
      };
 
   };
}    
#endif