ugraph.hpp

/*************************************************************************
 *
 *  ugraph.hpp: Graphics Layer
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE : 
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
 * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
 * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
 * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************/

#ifndef _ugraph_hpp_
#define _ugraph_hpp_ 1
#include <vector>
#include <ubit/udefs.hpp>
#include <ubit/ucolor.hpp>
#include <ubit/ugeom.hpp>
namespace ubit {
  
  
struct UGraphAttributes {
  UGraphAttributes() : color_rgba(0u,0u,0u,255u), bgcolor_rgba(255u,255u,255u,255u) {}
  short font_styles;
  float width;
  unsigned long color, bgcolor;      // for 2D_GRAPHICS
  URgba color_rgba, bgcolor_rgba;    // for GL
  enum {OPAQUE, UNIFORM_BLEND, PSEUDO_BLEND, TRUE_BLEND} blend_mode;
  bool in_xor_mode;
  bool in_3d_mode;      // true when displaying inside a 3Dcanvas
};

  
class UGraph : public UGraphAttributes {
public:
  class Glpaint {
  public:
    Glpaint(UPaintEvent&, bool _push_attrib);
    Glpaint(UView*, bool _push_attrib);
    virtual ~Glpaint();
    virtual void begin(UView*, bool _push_attrib);
    virtual void end();
  protected:
    static int count;
    int no;
    bool push_attrib;
    UHardwinImpl* hardwin;
  };
  
  
  UGraph(UPaintEvent&);
  virtual ~UGraph();
    
  UBox* getBox() const;
  UView* getView() const {return boxview;}
  UDisp* getDisp() const {return disp;}

  URect getClip() const {URect r; getClip(r); return r;}
  
  void getClip(URect&) const;

  void setClip(const URect&);

  // ==== Attributes ===========================================================

  void setPaintMode();
  void setXORMode(const UColor& background_color);
  bool isXORMode() const {return in_xor_mode;}
  void setColor(const UColor&);
  void setColor(const UColor&, float alpha);
  void setColor(const UColor&, unsigned int alpha);
  void setBackground(const UColor&);
  void setFont(const UFont&);
  void setFont(const UFontDesc&);
  void getFontMetrics(const UFont&, UFontMetrics&) const;
  void setWidth(float);
  float getWidth() const;
  void flush() const;

  // ==== Drawing routines =====================================================
     
  void draw(const UShape&) const;
  
  void fill(const UShape&) const;

  void drawArc(double x, double y, double width, double height, 
               double start_angle, double ext_angle) const;
  void fillArc(double x, double y, double width, double height, 
               double start_angle, double ext_angle) const;
  
  void drawEllipse(double x, double y, double width, double height) const; 
        
  void fillEllipse(double x, double y, double width, double height) const; 
  
  void drawIma(const UIma&, double x, double y, double scale = 1.) const;

  void drawLine(double x1, double y1, double x2, double y2) const;
  
  void drawLine(const UPoint& p1, const UPoint& p2) const;
  
  static const int LINE_STRIP, LINE_LOOP, FILLED;

  void drawPolygon(const std::vector<UPoint>& points, int type = LINE_LOOP) const;
  void drawPolygon(const float* points, int npoints, int type = LINE_LOOP) const;
  void drawPolyline(const std::vector<UPoint>& points) const {drawPolygon(points, LINE_STRIP);}
     
  void fillPolygon(const std::vector<UPoint>& points) const {drawPolygon(points, FILLED);}
  
  void drawRect(double x, double y, double width, double height) const;
 
  void fillRect(double x, double y, double width, double height) const;
    
  void drawRoundRect(double x, double y, double width, double height, 
                     double arc_w, double arc_h) const;
  void fillRoundRect(double x, double y, double width, double height, 
                     double arc_w, double arc_h) const;
  
  void drawString(const UStr& string, double x, double y) const;

  void drawString(const char* string, int length, double x, double y) const;

  void copyArea(double x, double y, double width, double height,
                double delta_x, double delta_y, 
                bool paint_events_when_obscured) const;
  // === Impl. =================================================================
#ifndef NO_DOC

  UGraph(UView*);
  UHardwinImpl* getHardwin() const {return hardwin;}
  /* [Impl] returns the hard window where this UGraph can draw on.
   * Ubit Windows (UWin and subclasses) can either be hard (system windows) or
   * soft (simulated), in which case they are drawn on the top of a hard window.
   * getHardwin() always returns the hard window.
   */
  
  void getHardwinClip(URect&) const; 
  
  void setHardwinClip(const URect&);
  
  void set3Dmode(bool state);
  bool in3Dmode() const {return in_3d_mode;}
    
  void getWinOffset(float& x, float& y) const;  
  void setWinOffset(float x, float y) const;  
  static void setViewportOrtho(UHardwinImpl*);

private:
  UGraph(UGraph&);
  UGraph& operator=(const UGraph&);
protected:
  friend class UView;
  friend class U3DcanvasView;
  friend class UPaintEvent;
  friend class UFontMetrics;
  friend class URenderContext;
  friend class UGlcontext;
  friend class UX11context;
  UDisp* disp;         // display 
  UView* boxview;      // view where the graphics are drawn
  UHardwinImpl* hardwin;   // corresponding hard window 
  UHardFont* font;     // native font that is currently used
  URenderContext* rc;  // corresponding rendering context
  bool is_client;
#endif // NO_DOC
};

}
#endif