don't use XMoveResize, it doesn't work for StaticGravity windows?
[mikachu/openbox.git] / otk / widget.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #ifdef    HAVE_CONFIG_H
4 #  include "../config.h"
5 #endif // HAVE_CONFIG_H
6
7 #include "widget.hh"
8 #include "display.hh"
9 #include "assassin.hh"
10 #include "screeninfo.hh"
11
12 #include <algorithm>
13 #include <iostream>
14
15 namespace otk {
16
17 Widget::Widget(Widget *parent, Direction direction)
18   : EventHandler(),
19     _dirty(false), _focused(false),
20     _parent(parent), _style(parent->style()), _direction(direction),
21     _cursor(parent->cursor()), _bevel_width(parent->bevelWidth()),
22     _ignore_config(0),
23     _visible(false), _grabbed_mouse(false),
24     _grabbed_keyboard(false), _stretchable_vert(false),
25     _stretchable_horz(false), _texture(0), _bg_pixmap(0), _bg_pixel(0),
26     _bcolor(0), _bwidth(0), _screen(parent->screen()), _fixed_width(false),
27     _fixed_height(false), _event_dispatcher(parent->eventDispatcher())
28 {
29   assert(parent);
30   parent->addChild(this);
31   create();
32   _event_dispatcher->registerHandler(_window, this);
33   setStyle(_style); // let the widget initialize stuff
34 }
35
36 Widget::Widget(EventDispatcher *event_dispatcher, Style *style,
37                      Direction direction, Cursor cursor, int bevel_width,
38                      bool override_redirect)
39   : EventHandler(),
40     _dirty(false),_focused(false),
41     _parent(0), _style(style), _direction(direction), _cursor(cursor),
42     _bevel_width(bevel_width), _ignore_config(0), _visible(false),
43     _grabbed_mouse(false), _grabbed_keyboard(false),
44     _stretchable_vert(false), _stretchable_horz(false), _texture(0),
45     _bg_pixmap(0), _bg_pixel(0), _bcolor(0), _bwidth(0),
46     _screen(style->getScreen()), _fixed_width(false), _fixed_height(false),
47     _event_dispatcher(event_dispatcher)
48 {
49   assert(event_dispatcher);
50   assert(style);
51   create(override_redirect);
52   _event_dispatcher->registerHandler(_window, this);
53   setStyle(_style); // let the widget initialize stuff
54 }
55
56 Widget::~Widget()
57 {
58   if (_visible)
59     hide();
60
61   _event_dispatcher->clearHandler(_window);
62
63   std::for_each(_children.begin(), _children.end(), PointerAssassin());
64
65   if (_parent)
66     _parent->removeChild(this);
67
68   XDestroyWindow(**display, _window);
69 }
70
71 void Widget::create(bool override_redirect)
72 {
73   const ScreenInfo *scr_info = display->screenInfo(_screen);
74   Window p_window = _parent ? _parent->window() : scr_info->rootWindow();
75
76   _rect.setRect(0, 0, 1, 1); // just some initial values
77
78   XSetWindowAttributes attrib_create;
79   unsigned long create_mask = CWBackPixmap | CWBorderPixel | CWEventMask;
80
81   attrib_create.background_pixmap = None;
82   attrib_create.colormap = scr_info->colormap();
83   attrib_create.event_mask = ButtonPressMask | ButtonReleaseMask |
84     ButtonMotionMask | ExposureMask | StructureNotifyMask;
85
86   if (override_redirect) {
87     create_mask |= CWOverrideRedirect;
88     attrib_create.override_redirect = true;
89   }
90
91   if (_cursor) {
92     create_mask |= CWCursor;
93     attrib_create.cursor = _cursor;
94   }
95
96   _window = XCreateWindow(**display, p_window, _rect.x(),
97                           _rect.y(), _rect.width(), _rect.height(), 0,
98                           scr_info->depth(), InputOutput,
99                           scr_info->visual(), create_mask, &attrib_create);
100   _ignore_config++;
101 }
102
103 void Widget::setWidth(int w)
104 {
105   assert(w > 0);
106   _fixed_width = true;  
107   setGeometry(_rect.x(), _rect.y(), w, _rect.height());
108 }
109
110 void Widget::setHeight(int h)
111 {
112   assert(h > 0);
113   _fixed_height = true;
114   setGeometry(_rect.x(), _rect.y(), _rect.width(), h);
115 }
116
117 void Widget::move(const Point &to)
118 {
119   move(to.x(), to.y());
120 }
121
122 void Widget::move(int x, int y)
123 {
124   _rect.setPos(x, y);
125   XMoveWindow(**display, _window, x, y);
126   _ignore_config++;
127 }
128
129 void Widget::resize(const Point &to)
130 {
131   resize(to.x(), to.y());
132 }
133
134 void Widget::resize(int w, int h)
135 {
136   assert(w > 0 && h > 0);
137   _fixed_width = _fixed_height = true;
138   setGeometry(_rect.x(), _rect.y(), w, h);
139 }
140
141 void Widget::setGeometry(const Rect &new_geom)
142 {
143   setGeometry(new_geom.x(), new_geom.y(), new_geom.width(), new_geom.height());
144 }
145  
146 void Widget::setGeometry(const Point &topleft, int width, int height)
147 {
148   setGeometry(topleft.x(), topleft.y(), width, height);
149 }
150
151 void Widget::setGeometry(int x, int y, int width, int height)
152 {
153   _rect = Rect(x, y, width, height);
154   _dirty = true;
155
156   XResizeWindow(**display, _window, width, height);
157   XMoveWindow(**display, _window, x, y);
158   _ignore_config+=2;
159 }
160
161 void Widget::show(bool recursive)
162 {
163   if (_visible)
164     return;
165
166   // make sure the internal state isn't mangled
167   if (_dirty)
168     update();
169
170   if (recursive) {
171     WidgetList::iterator it = _children.begin(), end = _children.end();
172     for (; it != end; ++it)
173       (*it)->show();
174   }
175
176   XMapWindow(**display, _window);
177   _visible = true;
178 }
179
180 void Widget::hide(bool recursive)
181 {
182   if (! _visible)
183     return;
184
185   if (recursive) {
186     WidgetList::iterator it = _children.begin(), end = _children.end();
187     for (; it != end; ++it)
188       (*it)->hide();
189   }
190   
191   XUnmapWindow(**display, _window);
192   _visible = false;
193 }
194
195 void Widget::focus(void)
196 {
197   _focused = true;
198   
199   Widget::WidgetList::iterator it = _children.begin(),
200     end = _children.end();
201   for (; it != end; ++it)
202     (*it)->focus();
203 }
204
205 void Widget::unfocus(void)
206 {
207   _focused = false;
208   
209   Widget::WidgetList::iterator it = _children.begin(),
210     end = _children.end();
211   for (; it != end; ++it)
212     (*it)->unfocus();
213 }
214
215 bool Widget::grabMouse(void)
216 {
217   Status ret = XGrabPointer(**display, _window, True,
218                             (ButtonPressMask | ButtonReleaseMask |
219                              ButtonMotionMask | EnterWindowMask |
220                              LeaveWindowMask | PointerMotionMask),
221                             GrabModeSync, GrabModeAsync, None, None,
222                             CurrentTime);
223   _grabbed_mouse = (ret == GrabSuccess);
224   return _grabbed_mouse;
225 }
226
227 void Widget::ungrabMouse(void)
228 {
229   if (! _grabbed_mouse)
230     return;
231
232   XUngrabPointer(**display, CurrentTime);
233   _grabbed_mouse = false;
234 }
235
236 bool Widget::grabKeyboard(void)
237 {
238   Status ret = XGrabKeyboard(**display, _window, True,
239                              GrabModeSync, GrabModeAsync, CurrentTime);
240   _grabbed_keyboard = (ret == GrabSuccess);
241   return _grabbed_keyboard;
242
243 }
244
245 void Widget::ungrabKeyboard(void)
246 {
247   if (! _grabbed_keyboard)
248     return;
249
250   XUngrabKeyboard(**display, CurrentTime);
251   _grabbed_keyboard = false;
252 }
253
254 void Widget::render(void)
255 {
256   if (!_texture) return;
257
258   _bg_pixmap = _texture->render(_rect.width(), _rect.height(), _bg_pixmap);
259
260   if (_bg_pixmap) {
261     XSetWindowBackgroundPixmap(**display, _window, _bg_pixmap);
262     _bg_pixel = None;
263   } else {
264     unsigned int pix = _texture->color().pixel();
265     if (pix != _bg_pixel) {
266       _bg_pixel = pix;
267       XSetWindowBackground(**display, _window, pix);
268     }
269   }
270 }
271
272 void Widget::adjust(void)
273 {
274   if (_direction == Horizontal)
275     adjustHorz();
276   else
277     adjustVert();
278 }
279
280 void Widget::adjustHorz(void)
281 {
282   if (_children.size() == 0)
283     return;
284
285   Widget *tmp;
286   WidgetList::iterator it, end = _children.end();
287
288   int tallest = 0;
289   int width = _bevel_width;
290   WidgetList stretchable;
291
292   for (it = _children.begin(); it != end; ++it) {
293     tmp = *it;
294     if (tmp->isStretchableVert())
295       tmp->setHeight(_rect.height() > _bevel_width * 2 ?
296                      _rect.height() - _bevel_width * 2 : _bevel_width);
297     if (tmp->isStretchableHorz())
298       stretchable.push_back(tmp);
299     else
300       width += tmp->_rect.width() + _bevel_width;
301
302     if (tmp->_rect.height() > tallest)
303       tallest = tmp->_rect.height();
304   }
305
306   if (stretchable.size() > 0) {
307     WidgetList::iterator str_it = stretchable.begin(),
308       str_end = stretchable.end();
309
310     int str_width = _rect.width() - width / stretchable.size();
311
312     for (; str_it != str_end; ++str_it)
313       (*str_it)->setWidth(str_width > _bevel_width ? str_width - _bevel_width
314                           : _bevel_width);
315   }
316
317   Widget *prev_widget = 0;
318
319   for (it = _children.begin(); it != end; ++it) {
320     tmp = *it;
321     int x, y;
322
323     if (prev_widget)
324       x = prev_widget->_rect.x() + prev_widget->_rect.width() + _bevel_width;
325     else
326       x = _rect.x() + _bevel_width;
327     y = (tallest - tmp->_rect.height()) / 2 + _bevel_width;
328
329     tmp->move(x, y);
330
331     prev_widget = tmp;
332   }
333
334   internalResize(width, tallest + _bevel_width * 2);
335 }
336
337 void Widget::adjustVert(void)
338 {
339   if (_children.size() == 0)
340     return;
341
342   Widget *tmp;
343   WidgetList::iterator it, end = _children.end();
344
345   int widest = 0;
346   int height = _bevel_width;
347   WidgetList stretchable;
348
349   for (it = _children.begin(); it != end; ++it) {
350     tmp = *it;
351     if (tmp->isStretchableHorz())
352       tmp->setWidth(_rect.width() > _bevel_width * 2 ?
353                     _rect.width() - _bevel_width * 2 : _bevel_width);
354     if (tmp->isStretchableVert())
355       stretchable.push_back(tmp);
356     else
357       height += tmp->_rect.height() + _bevel_width;
358
359     if (tmp->_rect.width() > widest)
360       widest = tmp->_rect.width();
361   }
362
363   if (stretchable.size() > 0) {
364     WidgetList::iterator str_it = stretchable.begin(),
365       str_end = stretchable.end();
366
367     int str_height = _rect.height() - height / stretchable.size();
368
369     for (; str_it != str_end; ++str_it)
370       (*str_it)->setHeight(str_height > _bevel_width ?
371                            str_height - _bevel_width : _bevel_width);
372   }
373
374   Widget *prev_widget = 0;
375
376   for (it = _children.begin(); it != end; ++it) {
377     tmp = *it;
378     int x, y;
379
380     if (prev_widget)
381       y = prev_widget->_rect.y() + prev_widget->_rect.height() + _bevel_width;
382     else
383       y = _rect.y() + _bevel_width;
384     x = (widest - tmp->_rect.width()) / 2 + _bevel_width;
385
386     tmp->move(x, y);
387
388     prev_widget = tmp;
389   }
390
391   internalResize(widest + _bevel_width * 2, height);
392 }
393
394 void Widget::update(void)
395 {
396   if (_dirty) {
397     adjust();
398     render();
399     XClearWindow(**display, _window);
400   }
401
402   WidgetList::iterator it = _children.begin(), end = _children.end();
403   for (; it != end; ++it)
404     (*it)->update();
405
406   _dirty = false;
407 }
408
409 void Widget::internalResize(int w, int h)
410 {
411   assert(w > 0 && h > 0);
412
413   if (! _fixed_width && ! _fixed_height)
414     resize(w, h);
415   else if (! _fixed_width)
416     resize(w, _rect.height());
417   else if (! _fixed_height)
418     resize(_rect.width(), h);
419 }
420
421 void Widget::addChild(Widget *child, bool front)
422 {
423   assert(child);
424   if (front)
425     _children.push_front(child);
426   else
427     _children.push_back(child);
428 }
429
430 void Widget::removeChild(Widget *child)
431 {
432   assert(child);
433   WidgetList::iterator it, end = _children.end();
434   for (it = _children.begin(); it != end; ++it) {
435     if ((*it) == child)
436       break;
437   }
438
439   if (it != _children.end())
440     _children.erase(it);
441 }
442
443 void Widget::setStyle(Style *style)
444 {
445   assert(style);
446   _style = style;
447   _dirty = true;
448
449   WidgetList::iterator it, end = _children.end();
450   for (it = _children.begin(); it != end; ++it)
451     (*it)->setStyle(style);
452 }
453
454
455 void Widget::setEventDispatcher(EventDispatcher *disp)
456 {
457   if (_event_dispatcher)
458     _event_dispatcher->clearHandler(_window);
459   _event_dispatcher = disp;
460   _event_dispatcher->registerHandler(_window, this);
461 }
462
463 void Widget::exposeHandler(const XExposeEvent &e)
464 {
465   EventHandler::exposeHandler(e);
466   _dirty = true;
467   update();
468 }
469
470 void Widget::configureHandler(const XConfigureEvent &e)
471 {
472   EventHandler::configureHandler(e);
473   if (_ignore_config) {
474     _ignore_config--;
475   } else {
476     if (!(e.width == _rect.width() && e.height == _rect.height())) {
477       _dirty = true;
478       _rect.setSize(e.width, e.height);
479     }
480     update();
481   }
482 }
483
484 }