uwin.hpp

/************************************************************************
 *
 *  uwin.hpp: ubit windows
 *  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 _uwin_hpp_
#define _uwin_hpp_ 1
#include <ubit/ubox.hpp>
#include <ubit/uview.hpp>
namespace ubit {
  
  class UWinPlacement;
  class UWinImpl;
  
  class UWin : public UBox {
  public:
    UCLASS(UWin)
    
    UWin(UArgs nodelist = UArgs::none);
    
    virtual ~UWin();
    
    virtual UWin* toWin() {return this;}  // redefined
    virtual const UWin* toWin() const {return this;}  // redefined
    
    static UStyle* createStyle();  // redefined
    virtual int getDisplayType() const {return wmodes.IS_HARDWIN ? HARDWIN : SOFTWIN;}
    
    // - - - position - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual UWin& setTitle(const UStr& title);
    
    virtual UStr getTitle() const;
    
    virtual void setPos(UMouseEvent&, float x = 0, float y = 0);
    virtual void setPos(const UWin& win, const UPoint&, UDisp* = null);
    
    virtual void setPos(const UView& view, const UPoint&);
    
    virtual void setPos(const UView& view, const UWinPlacement&);
    
    virtual void setScreenPos(const UPoint&, UDisp* = null);
    
    virtual void centerOnScreen(UDisp* = null);
    // centers the window on the screen.
    
    virtual UPoint getPos(const UWin& win, UDisp* = null) const;
    
    virtual UPoint getPos(const UView& view) const;
    
    virtual UPoint getScreenPos(UDisp* = null) const;
    
    // - - - size and stacking order - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual float getWidth(UDisp* = null) const;
    
    virtual float getHeight(UDisp* = null) const;
    
    virtual UDimension getSize(UDisp* = null) const;
    
    virtual void setSize(const UDimension&, UDisp* = null);
    
    virtual void adjustSize();
    void pack() {adjustSize();}
    
    virtual void setFullScreen(bool state, UDisp* = null);
    
    virtual void toBack(UDisp* = null);
    
    virtual void toFront(UDisp* = null);
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual bool isShown() const;
    
    virtual bool isShown(UDisp*) const;
    
    virtual bool isModal() const;
    
    virtual void setModal(bool = true) ;
    
    virtual void show(bool state = true) {UWin::show(state, null);}
    virtual void show(bool state, UDisp*);
    
    virtual int showModal(UDisp* = null);
    virtual void close(int status = 0);
    void repaint() {update(UUpdate::paint);}          // redefined
    void update() {update(UUpdate::layoutAndPaint);}  // redefined
        
    virtual void update(const UUpdate& update_options, UDisp* = null);
    virtual void doUpdate(const UUpdate&, UDisp* = null);  // redefined

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool isHardwin() const {return wmodes.IS_HARDWIN;}
    bool isSoftwin() const {return !wmodes.IS_HARDWIN;}
    virtual UWin& setSoftwin(bool state = true);
    UWin& setSoftWin(bool state = true) {return setSoftwin(state);}
    
    UWin& softwin(bool state = true) {return setSoftwin(state);}
    
    bool isMapped() const {return wmodes.IS_MAPPED;}
    void setMapped(bool s) {wmodes.IS_MAPPED = s;}
    
    // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual bool realize();
    UView* getWinView(UDisp* = null) const;
    
    UHardwinImpl* getHardwin(UDisp* = null) const;
#ifndef NO_DOC
    UHardwinImpl* hardImpl() const;
    USoftwinImpl* softImpl() const;  
    virtual void highlight(bool state);
    void addWinView(UView*);
    virtual void initView(UView* parent_view);
    virtual UView* initViewImpl(UView* parent_view, UDisp*);
    virtual void deleteViewsInside(const std::vector<UView*>& parent_views);
    
  protected:
    friend class UBox;
    friend class UAppli;
    friend class UAppliImpl;
    friend class UHardwinImpl;
    friend class USoftwinImpl;
    
    struct Modes {
      unsigned IS_HARDWIN:1;    // has a UHardwinImpl implementation (USoftWin otherwise) 
      unsigned IS_MENU:1;
      unsigned IS_DIALOG:1;
      unsigned IS_FRAME:1;
      unsigned IS_MAINFRAME:1; // main frame window?
      unsigned IS_MODAL:1;      // this window is modal
      unsigned IS_AUTO_OPENED:1; // automatically opened if parent is ARMable
      unsigned IS_MAPPED:1;    // this window is currently mapped on the screen
    };
    Modes wmodes;
    std::vector<UWinImpl*> wimpl; // liste pour multiple displays
        
    virtual UView* realizeSoftwin(UWin* hardwin, UView* hardwin_view,
                                  UDisp*, bool add_to_the_end);
    
    virtual bool realizeHardwin(char window_type);
    // internal realization function (window_type as defined in UNatWin).
    
    virtual void realizeChildren(UView* winview);
    // called by realize() to create the views of the children
#endif
  };
  

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  class UWinPlacement {
  public:
    UWinPlacement();
    
    // Horizontal placement. 
    // -- Explicit if &uleft() or &uright()
    // -- Default placement if null or other UHalign values.
    UHalign* halign;
    
    // vertical placement. Explicit if &utop() or &ubottom()
    UValign* valign;
    
    // Relative location from reference object:
    //
    // if oppositeBorder is true:
    //    the specified border (eg. uleft()) of the reference object is 
    //    aligned with the OPPOSITE border of 'this' object (eg. right)
    //    --> this implies that 'this' object will be located OUTSIDE
    //    the ref. object (exemple: a cascaded submenu located on the
    //    right side of its parent menu)
    //
    // if oppositeBorder is false:
    //    same borders are used for both objects (eg. both left
    //    sides are aligned together)
    //    --> this implies that 'this' object will be located INSIDE
    //    the ref. object (in the same way as for usual UH/Valign rules)
    
    bool hoppositeBorder, voppositeBorder;
    
    // relative 'distance' between reference and 'this' object borders.
    // Usually 1 or 0. Can be < 0 as it is a relative 'distance'.
    int hdist, vdist;
  };
  
}
#endif