udisp.hpp

/*************************************************************************
 *
 *  udisp.cpp: Graphical Display (may be remotely located)
 *  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 _udisp_hpp_
#define _udisp_hpp_ 1
#include <list>
#include <ubit/udefs.hpp>
#include <ubit/ustr.hpp>
#include <ubit/uelem.hpp>
#include <ubit/ugeom.hpp>
namespace ubit {
  
class UGraphImpl;
class UCursorImpl;
  
class UDisp {
public:
  static UDisp* create(const UStr& display_name);
  virtual ~UDisp();

  bool isOpened() const {return is_opened;}
  
  int getID() const {return id;}
  const UConf& getConf() const {return conf;}

  int getBpp() const {return bpp;}
  const UStr& getDisplayName() const {return display_name;}
    
  int getScreenWidth() const {return screen_width;}
  
  int getScreenHeight() const {return screen_height;}
  
  void setPixelPerInch(double pixel_per_inch);
  
  void setPixelPerMM(double pixel_per_mm);
       
  // - - - windows - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual void add(UWin&);
  void add(UWin*);
    
  virtual void remove(UWin&, bool auto_delete);
  void remove(UWin*, bool auto_delete);
  
  // - - - pointer - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual void setPointerPos(const UPoint& screen_pos) = 0;

  virtual UPoint getPointerPos() const = 0;

  virtual int getPointerState() const = 0;

  virtual bool grabPointer(const UCursor* = null) = 0;
  virtual void ungrabPointer() = 0;
  virtual bool pickWindow(int& x_in_win, int& y_in_win, UHardwinImpl* window,
                          UCursor* cursor = null, UCall* callback = null) = 0;
  // - - - event flow - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  UEventFlow* getChannelFlow(int channel) const;
  UEventFlow* obtainChannelFlow(int channel);
  USelection* getChannelSelection(int channel);
  // - - - cut & paste - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  const UStr& getCopyBuffer() const {return copy_buffer;}

  UStr* getPasteTarget(int& pos) const;
    
  void clearPasteTarget();

  virtual void copySelection(UMouseEvent&, USelection&);
  virtual void pasteSelection(UMouseEvent&, UStr* paste_str, int paste_pos);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // Internals.
#ifndef NO_DOC
public:
  URenderContext* getDefaultContext();  
  void makeDefaultContextCurrentIfNeeded();
  
  void addHardwin(UWin*);
  void removeHardwin(UWin*);
  
  virtual unsigned long createColorPixel(const URgba&) = 0;  // for 2D_GRAPHICS
  virtual UHardwinImpl* createWinImpl(UWin*) = 0;
  virtual UCursorImpl*  createCursorImpl(int curtype) = 0;
  virtual void          deleteCursorImpl(UCursorImpl*) = 0;
  
  virtual UHardFont* getFont(const UFontDesc*);
  virtual UHardFont* realizeFont(const UFont&);
  virtual UHardFont* realizeFont(const UFontDesc&);  
  virtual void realizeFontFamily(const UFontFamily&);
  
  // - - - WITHOUT OpenGL 
  
  unsigned long getBlackPixel() const {return black_pixel;}  
  unsigned long getWhitePixel() const {return white_pixel;}
  
  // attention: les masks varient suivant l'architecture (big endian ou little endian).
  unsigned long getRedMask() const {return red_mask;}  
  unsigned long getGreenMask() const {return green_mask;}  
  unsigned long getBlueMask() const {return blue_mask;}  
  int getRedShift()  const {return red_shift;}  
  int getGreenShift()const {return green_shift;}  
  int getBlueShift() const {return blue_shift;}  
  int getRedBits()   const {return red_bits;}  
  int getGreenBits() const {return green_bits;}  
  int getBlueBits()  const {return blue_bits;} 
  static void countBits(unsigned long mask, int& bits, int& shift);
       
  // - - - Event management 
  
  UEventFlow* obtainFlow(unsigned int ev_state, int channel);
  
  virtual void onPaint(UView* winview, float x, float y, float w, float h);
  virtual void onResize(UView* winview, const UDimension& size);
  void onResizeCB(UView* winview);

  virtual bool setSelectionOwner(UMouseEvent&) {return false;}
  
  virtual void pasteSelectionRequest(UMouseEvent&) {}
  virtual void copySelectionCB(void* system_event) {}
  virtual void pasteSelectionCB(void* system_event) {}
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
private:
  friend class UAppli;
  friend class UAppliImpl;
  friend class UWin;
  friend class UHardwinImpl;
  friend class UView;
  friend class UGraph;
  friend class UEvent;
  friend class UFontFamily;
  friend class UFontMetrics;
  friend class UGlcontext;
  friend class UGlcanvas;
  friend class ULength;
  friend class UFont;
  UDisp(const UDisp&);
  UDisp& operator=(const UDisp&); 
  
protected:
  UDisp(const UStr& display_name);

  virtual void startAppli() = 0;
  virtual void quitAppli() = 0;
  virtual void startLoop(bool main_loop) = 0;  // starts the mainloop or a subloop.
  virtual void quitLoop(bool main_loop) = 0;   // quits the mainloop or a subloop.

  // attention: l'ordre de destruction importe ici: winlist doit etre
  // detruit en premier ca ca entraine des destructions qui font reference
  // a flowlist => winlist doit etre declare en DERNIER
  int id;
  UConf& conf;             // configuration data (may be shared with the UAppli)
  UStr display_name;       // name of the X Display
  int bpp;                   // bit per pixel
  int depth_size, stencil_size;
  int screen_width, screen_height;
  int screen_width_mm, screen_height_mm;
  bool is_opened;
  URenderContext *default_context;
  const UGlcontext *current_glcontext;
  std::vector<UHardFont**> font_map;
  unsigned long app_motion_time, nat_motion_time;  // for lag control
  unsigned long black_pixel, white_pixel, red_mask, green_mask, blue_mask;
  int red_shift, green_shift, blue_shift, red_bits, green_bits, blue_bits;  
  double IN_TO_PX, CM_TO_PX, MM_TO_PX, PT_TO_PX, PC_TO_PX;
  
  typedef std::list<UHardwinImpl*> HardwinList;
  HardwinList hardwin_list;  // list of hardwins that are event managed

  // copySelection() copies the content of the selection in this buffer
  // note: there is 1 selection per UEventFlow but only 1 copy_buffer per UDisp
  UStr copy_buffer;

  // pasteSelection() specifies that the selection will be pasted in this UStr
  // at this pos (uptr<> to avoid deletion)
  uptr<UStr> paste_str;
  int paste_pos;

  // attention: winlist doit etre detruit en premier!
  UElem winlist;  // list of windows belonging to this display
    
  struct LastResize {
    LastResize() : count(0), winview(null) {}
    int count;
    UView* winview;
    UDimension newsize;
  } last_resize;
  
#endif // NO_DOC
};

}
#endif