- allow close of dialog
[enigma2.git] / lib / gui / ewidget.cpp
1 #include <lib/gui/ewidget.h>
2 #include <lib/gui/ewidgetdesktop.h>
3
4 extern void dumpRegion(const gRegion &region);
5
6 eWidget::eWidget(eWidget *parent): m_parent(parent ? parent->child() : 0)
7 {
8         m_vis = 0;
9         m_desktop = 0;
10         
11         if (m_parent)
12                 m_vis = wVisShow;
13                 
14         if (m_parent)
15         {
16                 m_parent->m_childs.push_back(this);
17                 m_parent->getStyle(m_style);
18         }
19 }
20
21 void eWidget::move(ePoint pos)
22 {
23         if (m_position == pos)
24                 return;
25         
26         m_position = pos;
27         
28                 /* we invalidate before and after the move to
29                    cause a correct redraw. The area which is
30                    included both before and after isn't redrawn
31                    twice because a invalidate doesn't immediately
32                    redraws the region. */
33         invalidate();
34         event(evtChangedPosition);
35         recalcClipRegionsWhenVisible(); 
36         invalidate();
37 }
38
39 void eWidget::resize(eSize size)
40 {
41                 /* same strategy as with move: we first check if
42                    the size changed at all, and if it did, we
43                    invalidate both the old and new area. 
44                    TODO: check if either the old or new area
45                    fits into the other completely, and invalidate
46                    only once. */
47         eSize old_size = m_size;
48         event(evtWillChangeSize, &size);
49         if (old_size == m_size)
50                 return;
51
52         invalidate();
53         event(evtChangedSize);
54         recalcClipRegionsWhenVisible(); 
55         invalidate();
56 }
57
58 void eWidget::invalidate(const gRegion &region)
59 {
60                 /* we determine the area to redraw, and re-position this
61                    area to the absolute position, and then call the
62                    desktop's invalidate() with that, which adds this
63                    area into the dirty region. */
64         gRegion res = m_visible_with_childs;
65         if (region.valid())
66                 res &= region;
67
68         if (res.empty())
69                 return;
70         
71         eWidget *root = this;
72         ePoint abspos = position();
73         while (root && !root->m_desktop)
74         {
75                 root = root->m_parent;
76                 assert(root);
77                 abspos += root->position();
78         }
79         
80         res.moveBy(abspos);
81 //      eDebug("region to invalidate:");
82 //      dumpRegion(res);
83         root->m_desktop->invalidate(res);
84 }
85
86 void eWidget::show()
87 {
88         if (m_vis & wVisShow)
89                 return;
90         
91         m_vis |=  wVisShow;
92
93                 /* TODO: optimize here to only recalc what's required. possibly merge with hide. */
94         eWidget *root = this;
95         ePoint abspos = position();
96         while (root && !root->m_desktop)
97         {
98                 root = root->m_parent;
99                 assert(root);
100                 abspos += root->position();
101         }
102
103         root->m_desktop->recalcClipRegions();
104
105         gRegion abs = m_visible_with_childs;
106         abs.moveBy(abspos);
107         root->m_desktop->invalidate(abs);
108 }
109
110 void eWidget::hide()
111 {
112                 /* TODO: when hiding an upper level widget, widgets get hidden but keep the */
113                 /* wVisShow flag (because when the widget is shown again, the widgets must */
114                 /* become visible again. */
115         if (!(m_vis & wVisShow))
116                 return;
117         m_vis &= ~wVisShow;
118         
119                 /* this is a workaround to the above problem. when we are in the delete phase, 
120                    don't hide childs. */
121         if (!(m_parent || m_desktop))
122                 return;
123
124                 /* TODO: optimize here to only recalc what's required. possibly merge with show. */
125         eWidget *root = this;
126         ePoint abspos = position();
127         while (root && !root->m_desktop)
128         {
129                 root = root->m_parent;
130                 abspos += root->position();
131         }
132         assert(root->m_desktop);
133
134         gRegion abs = m_visible_with_childs;
135         abs.moveBy(abspos);
136
137         root->m_desktop->recalcClipRegions();
138         root->m_desktop->invalidate(abs);
139 }
140
141 void eWidget::destruct()
142 {
143         if (m_parent)
144                 m_parent->m_childs.remove(this);
145         delete this;
146 }
147
148 eWidget::~eWidget()
149 {
150         hide();
151         
152         if (m_parent)
153                 m_parent->m_childs.remove(this);
154
155         m_parent = 0;
156
157                 /* destroy all childs */
158         ePtrList<eWidget>::iterator i(m_childs.begin());
159         while (i != m_childs.end())
160         {
161                 (*i)->m_parent = 0;
162                 delete *i;
163                 i = m_childs.erase(i);
164         }
165 }
166
167 void eWidget::doPaint(gPainter &painter, const gRegion &r)
168 {
169         if (m_visible_with_childs.empty())
170                 return;
171         
172         gRegion region = r;
173                         /* we were in parent's space, now we are in local space */
174         region.moveBy(-position());
175         
176         painter.moveOffset(position());
177                 /* walk all childs */
178         for (ePtrList<eWidget>::iterator i(m_childs.begin()); i != m_childs.end(); ++i)
179                 i->doPaint(painter, region);
180         
181                 /* check if there's anything for us to paint */
182         region &= m_visible_region;
183         
184         if (!region.empty())
185         {
186                 painter.resetClip(region);
187                 event(evtPaint, &region, &painter);
188         }
189         
190         painter.moveOffset(-position());
191 }
192
193 void eWidget::recalcClipRegionsWhenVisible()
194 {
195         eWidget *t = this;
196         do
197         {
198                 if (!(t->m_vis & wVisShow))
199                         break;
200                 if (t->m_desktop)
201                 {
202                         t->m_desktop->recalcClipRegions();
203                         break;
204                 }
205                 t = t->m_parent;
206                 assert(t);
207         } while(1);
208 }
209
210 int eWidget::event(int event, void *data, void *data2)
211 {
212         switch (event)
213         {
214         case evtPaint:
215         {
216                 gPainter &painter = *(gPainter*)data2;
217                 
218 //              eDebug("eWidget::evtPaint");
219 //              dumpRegion(*(gRegion*)data);
220                 ePtr<eWindowStyle> style;
221                 if (!getStyle(style))
222                         style->paintBackground(painter, ePoint(0, 0), size());
223                 break;
224         }
225         case evtKey:
226                 break;
227         case evtWillChangeSize:
228                 m_size = *static_cast<eSize*>(data);
229                 break;
230         case evtChangedSize:
231         {
232                 m_clip_region = gRegion(eRect(ePoint(0, 0),  m_size));
233                 break;
234         }
235         default:
236                 return -1;
237         }
238         return 0;
239 }
240