all repos — openbox @ b3a87e3a6f0001949af5e1547c4ef6af470a83ff

openbox fork - make it a bit more like ryudo

otk/widget.hh (raw)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
#ifndef __widget_hh
#define __widget_hh

#include "eventhandler.hh"
#include "rect.hh"
#include "renderstyle.hh"

#include <list>
#include <algorithm>
#include <cassert>

namespace otk {

class Surface;
class RenderTexture;
class RenderColor;
class EventDispatcher;

class Widget : public EventHandler, public StyleNotify {
public:
  enum Direction { Horizontal, Vertical };

  Widget(int screen, EventDispatcher *ed, Direction direction = Horizontal,
         int bevel = 3, bool overrideredir = false);
  Widget(Widget *parent, Direction direction = Horizontal, int bevel = 3);
  virtual ~Widget();

  inline int screen() const { return _screen; }
  inline Window window() const { return _window; }
  inline Widget *parent() const { return _parent; }
  inline Direction direction() const { return _direction; }

  inline RenderStyle::Justify alignment() const { return _alignment; }
  void setAlignment(RenderStyle::Justify a);

  inline long eventMask() const { return _event_mask; }
  virtual void setEventMask(long e);
  
  inline const Rect& area() const { return _area; }
  inline Rect usableArea() const { return Rect(_area.position(),
                                               Size(_area.width() -
                                                    _borderwidth * 2,
                                                    _area.height() -
                                                    _borderwidth * 2));}
  inline const Size& minSize() const { return _min_size; }
  inline const Size& maxSize() const { return _max_size; }
  virtual void setMaxSize(const Size &s);

  virtual void show(bool children = false);
  virtual void hide();
  inline bool visible() const { return _visible; }

  virtual void update();
  virtual void refresh() { if (_visible) { _dirty = true; render(); } }
  
  virtual void setBevel(int b);
  inline int bevel() const { return _bevel; }

  void move(const Point &p)
    { moveresize(Rect(p, _area.size())); }
  void resize(const Size &s)
    { moveresize(Rect(_area.position(), s)); }
  /*!
    When a widget has a parent, this won't change the widget directly, but will
    just cause the parent to re-layout all its children.
  */
  virtual void moveresize(const Rect &r);

  inline const RenderColor *borderColor() const { return _bordercolor; }
  virtual void setBorderColor(const RenderColor *c);

  inline int borderWidth() const { return _borderwidth; }
  virtual void setBorderWidth(int w);

  const std::list<Widget*>& children() const { return _children; }

  virtual void exposeHandler(const XExposeEvent &e);
  virtual void configureHandler(const XConfigureEvent &e);
  virtual void styleChanged(const RenderStyle &style);

protected:
  virtual void addChild(Widget *w) { assert(w); _children.push_back(w); }
  virtual void removeChild(Widget *w) { assert(w); _children.remove(w); }

  //! Find the default min/max sizes for the widget. Useful after the in-use
  //! style has changed.
  virtual void calcDefaultSizes();

  virtual void setMinSize(const Size &s);

  //! Arrange the widget's children
  virtual void layout();
  virtual void layoutHorz();
  virtual void layoutVert();
  virtual void render();
  virtual void renderForeground(Surface&) {};
  virtual void renderChildren();

  void createWindow(bool overrideredir);

  RenderTexture *_texture;

  EventDispatcher *dispatcher() const { return _dispatcher; }
  
private:
  void internal_moveresize(int x, int y, int w, int h);

  int _screen;
  Widget *_parent;
  Window _window;
  Surface *_surface;
  long _event_mask;
  
  RenderStyle::Justify _alignment;
  Direction _direction;
  Rect _area;
  //! This size is the size *inside* the border, so they won't match the
  //! actual size of the widget
  Size _min_size;
  //! This size is the size *inside* the border, so they won't match the
  //! actual size of the widget 
  Size _max_size;

  bool _visible;
  
  const RenderColor *_bordercolor;
  int _borderwidth;
  int _bevel;
  bool _dirty;

  std::list<Widget*> _children;

  EventDispatcher *_dispatcher;

  int _ignore_config;
};

}

#endif // __widget_hh