Diffstat (limited to 'libopie/big-screen/osplitter.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libopie/big-screen/osplitter.cpp | 583 |
1 files changed, 0 insertions, 583 deletions
diff --git a/libopie/big-screen/osplitter.cpp b/libopie/big-screen/osplitter.cpp deleted file mode 100644 index 0c9ed6c..0000000 --- a/libopie/big-screen/osplitter.cpp +++ b/dev/null | |||
@@ -1,583 +0,0 @@ | |||
1 | /* | ||
2 | =. This file is part of the OPIE Project | ||
3 | .=l. Copyright (c) 2003 hOlgAr <zecke@handhelds.org> | ||
4 | .>+-= | ||
5 | _;:, .> :=|. This library is free software; you can | ||
6 | .> <`_, > . <= redistribute it and/or modify it under | ||
7 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
8 | .="- .-=="i, .._ License as published by the Free Software | ||
9 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
10 | ._= =} : or (at your option) any later version. | ||
11 | .%`+i> _;_. | ||
12 | .i_,=:_. -<s. This library is distributed in the hope that | ||
13 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
14 | : .. .:, . . . without even the implied warranty of | ||
15 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
16 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
17 | ..}^=.= = ; Library General Public License for more | ||
18 | ++= -. .` .: details. | ||
19 | : = ...= . :.=- | ||
20 | -. .:....=;==+<; You should have received a copy of the GNU | ||
21 | -_. . . )=. = Library General Public License along with | ||
22 | -- :-=` this library; see the file COPYING.LIB. | ||
23 | If not, write to the Free Software Foundation, | ||
24 | Inc., 59 Temple Place - Suite 330, | ||
25 | Boston, MA 02111-1307, USA. | ||
26 | |||
27 | */ | ||
28 | |||
29 | #include <qvaluelist.h> | ||
30 | #include <qvbox.h> | ||
31 | |||
32 | #include <opie/otabwidget.h> | ||
33 | |||
34 | #include "osplitter.h" | ||
35 | |||
36 | |||
37 | /** | ||
38 | * | ||
39 | * This is the constructor of OSplitter | ||
40 | * You might want to call setSizeChange to tell | ||
41 | * OSplitter to change its layout when a specefic | ||
42 | * mark was crossed. OSplitter sets a default value. | ||
43 | * | ||
44 | * You cann add widget with addWidget to the OSplitter. | ||
45 | * OSplitter supports also grouping of Splitters where they | ||
46 | * can share one OTabBar in small screen mode. This can be used | ||
47 | * for email clients like vies but see the example. | ||
48 | * | ||
49 | * @param orient The orientation wether to layout horizontal or vertical | ||
50 | * @param parent The parent of this widget | ||
51 | * @param name The name passed on to QObject | ||
52 | * @param fl Additional widgets flags passed to QWidget | ||
53 | * | ||
54 | * @short single c'tor of the OSplitter | ||
55 | */ | ||
56 | OSplitter::OSplitter( Orientation orient, QWidget* parent, const char* name, WFlags fl ) | ||
57 | : QFrame( parent, name, fl ) | ||
58 | { | ||
59 | m_orient = orient; | ||
60 | m_hbox = 0; | ||
61 | m_size_policy = 330; | ||
62 | setFontPropagation( AllChildren ); | ||
63 | setPalettePropagation( AllChildren ); | ||
64 | |||
65 | /* start by default with the tab widget */ | ||
66 | m_tabWidget = 0; | ||
67 | m_parentTab = 0; | ||
68 | changeTab(); | ||
69 | |||
70 | } | ||
71 | |||
72 | |||
73 | /** | ||
74 | * Destructor destructs this object and cleans up. All child | ||
75 | * widgets will be deleted | ||
76 | * @see addWidget | ||
77 | */ | ||
78 | OSplitter::~OSplitter() { | ||
79 | qWarning("Deleted Splitter"); | ||
80 | m_splitter.setAutoDelete( true ); | ||
81 | m_splitter.clear(); | ||
82 | |||
83 | delete m_hbox; | ||
84 | delete m_tabWidget; | ||
85 | } | ||
86 | |||
87 | |||
88 | /** | ||
89 | * Sets the label for the Splitter. This label will be used | ||
90 | * if a parent splitter is arranged as TabWidget but | ||
91 | * this splitter is in fullscreen mode. Then a tab with OSplitter::label() | ||
92 | * and iconName() gets added. | ||
93 | * | ||
94 | * @param name The name of the Label | ||
95 | */ | ||
96 | void OSplitter::setLabel( const QString& name ) { | ||
97 | m_name = name; | ||
98 | } | ||
99 | |||
100 | /** | ||
101 | * @see setLabel but this is for the icon retrieved by Resource | ||
102 | * | ||
103 | * @param name The name of the icon in example ( "zoom" ) | ||
104 | */ | ||
105 | void OSplitter::setIconName( const QString& name ) { | ||
106 | m_icon = name; | ||
107 | } | ||
108 | |||
109 | |||
110 | /** | ||
111 | * returns the iconName | ||
112 | * @see setIconName | ||
113 | */ | ||
114 | QString OSplitter::iconName()const { | ||
115 | return m_icon; | ||
116 | } | ||
117 | |||
118 | /** | ||
119 | * returns the label set with setLabel | ||
120 | * @see setLabel | ||
121 | */ | ||
122 | QString OSplitter::label()const { | ||
123 | return m_name; | ||
124 | } | ||
125 | |||
126 | /** | ||
127 | * This function sets the size change policy of the splitter. | ||
128 | * If this size marked is crossed the splitter will relayout. | ||
129 | * Note: that depending on the set Orientation it'll either look | ||
130 | * at the width or height. | ||
131 | * Note: If you want to from side to side view to tabbed view you need | ||
132 | * to make sure that the size you supply is not smaller than the minimum | ||
133 | * size of your added widgets. Note that if you use widgets like QComboBoxes | ||
134 | * you need to teach them to accept smaller sizes as well @see QWidget::setSizePolicy | ||
135 | * | ||
136 | * @param width_height The mark that will be watched. Interpreted depending on the Orientation of the Splitter. | ||
137 | * @return void | ||
138 | */ | ||
139 | void OSplitter::setSizeChange( int width_height ) { | ||
140 | m_size_policy = width_height; | ||
141 | QSize sz(width(), height() ); | ||
142 | QResizeEvent ev(sz, sz ); | ||
143 | resizeEvent(&ev); | ||
144 | } | ||
145 | |||
146 | /** | ||
147 | * This functions allows to add another OSplitter and to share | ||
148 | * the OTabBar in small screen mode. The ownerships gets transfered. | ||
149 | * OSplitters are always added after normal widget items | ||
150 | */ | ||
151 | void OSplitter::addWidget( OSplitter* split ) { | ||
152 | m_splitter.append( split ); | ||
153 | |||
154 | /* | ||
155 | * set tab widget | ||
156 | */ | ||
157 | if (m_tabWidget ) | ||
158 | setTabWidget( m_parentTab ); | ||
159 | else{ | ||
160 | Opie::OSplitterContainer con; | ||
161 | con.widget =split; | ||
162 | addToBox( con ); | ||
163 | } | ||
164 | } | ||
165 | |||
166 | /* | ||
167 | * If in a tab it should be removed | ||
168 | * and if in a hbox the reparent kills it too | ||
169 | */ | ||
170 | /** | ||
171 | * This removes the splitter again. You currently need to call this | ||
172 | * before you delete or otherwise you can get mem corruption | ||
173 | * or other weird behaviour. | ||
174 | * Owner ship gets transfered back to you it's current parent | ||
175 | * is 0 | ||
176 | */ | ||
177 | void OSplitter::removeWidget( OSplitter* split) { | ||
178 | split->setTabWidget( 0 ); | ||
179 | split->reparent( 0, 0, QPoint(0, 0) ); | ||
180 | } | ||
181 | |||
182 | /** | ||
183 | * Adds a widget to the Splitter. The widgets gets inserted | ||
184 | * at the end of either the Box or TabWidget. | ||
185 | * Ownership gets transfered and the widgets gets reparented. | ||
186 | * Note: icon and label is only available on small screensizes | ||
187 | * if size is smaller than the mark | ||
188 | * Warning: No null checking of the widget is done. Only on debug | ||
189 | * a message will be outputtet | ||
190 | * | ||
191 | * @param wid The widget which will be added | ||
192 | * @param icon The icon of the possible Tab | ||
193 | * @param label The label of the possible Tab | ||
194 | */ | ||
195 | void OSplitter::addWidget( QWidget* wid, const QString& icon, const QString& label ) { | ||
196 | #ifdef DEBUG | ||
197 | if (!wid ) { | ||
198 | qWarning("Widget is not valid!"); | ||
199 | return; | ||
200 | } | ||
201 | #endif | ||
202 | Opie::OSplitterContainer cont; | ||
203 | cont.widget = wid; | ||
204 | cont.icon =icon; | ||
205 | cont.name = label; | ||
206 | |||
207 | m_container.append( cont ); | ||
208 | |||
209 | /* | ||
210 | * | ||
211 | */ | ||
212 | if (!m_splitter.isEmpty() && (m_tabWidget || m_parentTab ) ) | ||
213 | setTabWidget( m_parentTab ); | ||
214 | else { | ||
215 | if (m_hbox ) | ||
216 | addToBox( cont ); | ||
217 | else | ||
218 | addToTab( cont ); | ||
219 | } | ||
220 | } | ||
221 | |||
222 | |||
223 | /** | ||
224 | * Removes the widget from the tab widgets if necessary. | ||
225 | * OSplitter drops ownership of this widget and the widget | ||
226 | * will be reparented i tto 0. | ||
227 | * The widget will not be deleted. | ||
228 | * | ||
229 | * @param w The widget to be removed | ||
230 | */ | ||
231 | void OSplitter::removeWidget( QWidget* w) { | ||
232 | ContainerList::Iterator it; | ||
233 | for ( it = m_container.begin(); it != m_container.end(); ++it ) | ||
234 | if ( (*it).widget == w ) | ||
235 | break; | ||
236 | |||
237 | if (it == m_container.end() ) | ||
238 | return; | ||
239 | |||
240 | |||
241 | /* only tab needs to be removed.. box recognizes it */ | ||
242 | if ( !m_hbox ) | ||
243 | removeFromTab( w ); | ||
244 | |||
245 | |||
246 | /* Find reparent it and remove it from our list */ | ||
247 | |||
248 | w->reparent( 0, 0, QPoint(0, 0)); | ||
249 | it = m_container.remove( it ); | ||
250 | |||
251 | } | ||
252 | |||
253 | |||
254 | /** | ||
255 | * This method will give focus to the widget. If in a tabwidget | ||
256 | * the tabbar will be changed | ||
257 | * | ||
258 | * @param w The widget which will be set the current one | ||
259 | */ | ||
260 | void OSplitter::setCurrentWidget( QWidget* w) { | ||
261 | if (m_tabWidget ) | ||
262 | m_tabWidget->setCurrentTab( w ); | ||
263 | // else | ||
264 | // m_hbox->setFocus( w ); | ||
265 | |||
266 | } | ||
267 | |||
268 | /** | ||
269 | * This is an overloaded member function and only differs in the | ||
270 | * argument it takes. | ||
271 | * Searches list of widgets for label. It'll pick the first label it finds | ||
272 | * | ||
273 | * @param label Label to look for. First match will be taken | ||
274 | */ | ||
275 | void OSplitter::setCurrentWidget( const QString& label ) { | ||
276 | ContainerList::Iterator it; | ||
277 | for (it = m_container.begin(); it != m_container.end(); ++it ) { | ||
278 | if ( (*it).name == label ) { | ||
279 | setCurrentWidget( (*it).widget ); | ||
280 | break; | ||
281 | } | ||
282 | } | ||
283 | } | ||
284 | |||
285 | /** | ||
286 | * This will only work when the TabWidget is active | ||
287 | * If everything is visible this signal is kindly ignored | ||
288 | * @see OTabWidget::setCurrentTab(int) | ||
289 | * | ||
290 | * @param tab The tab to make current | ||
291 | */ | ||
292 | void OSplitter::setCurrentWidget( int tab ) { | ||
293 | if (m_tabWidget ) | ||
294 | m_tabWidget->setCurrentTab( tab ); | ||
295 | } | ||
296 | |||
297 | /** | ||
298 | * return the currently activated widget if in tab widget mode | ||
299 | * or null because all widgets are visible | ||
300 | */ | ||
301 | QWidget* OSplitter::currentWidget() const{ | ||
302 | if (m_tabWidget) | ||
303 | return m_tabWidget->currentWidget(); | ||
304 | else if (m_parentTab ) | ||
305 | return m_parentTab->currentWidget(); | ||
306 | |||
307 | return 0l; | ||
308 | } | ||
309 | /* wrong */ | ||
310 | #if 0 | ||
311 | /** | ||
312 | * @reimplented for internal reasons | ||
313 | * returns the sizeHint of one of its sub widgets | ||
314 | */ | ||
315 | QSize OSplitter::sizeHint()const { | ||
316 | if (m_parentTab ) | ||
317 | return QFrame::sizeHint(); | ||
318 | |||
319 | if (m_hbox ) | ||
320 | return m_hbox->sizeHint(); | ||
321 | else | ||
322 | return m_tabWidget->sizeHint(); | ||
323 | } | ||
324 | |||
325 | QSize OSplitter::minimumSizeHint()const { | ||
326 | if (m_parentTab ) | ||
327 | return QFrame::minimumSizeHint(); | ||
328 | if (m_hbox) | ||
329 | return m_hbox->sizeHint(); | ||
330 | else | ||
331 | return m_tabWidget->sizeHint(); | ||
332 | } | ||
333 | #endif | ||
334 | |||
335 | /** | ||
336 | * @reimplemented for internal reasons | ||
337 | */ | ||
338 | void OSplitter::resizeEvent( QResizeEvent* res ) { | ||
339 | QFrame::resizeEvent( res ); | ||
340 | /* | ||
341 | * | ||
342 | */ | ||
343 | // qWarning("Old size was width = %d height = %d", res->oldSize().width(), res->oldSize().height() ); | ||
344 | bool mode = true; | ||
345 | qWarning("New size is width = %d height = %d %s", res->size().width(), res->size().height(), name() ); | ||
346 | if ( res->size().width() > m_size_policy && | ||
347 | m_orient == Horizontal ) { | ||
348 | changeHBox(); | ||
349 | mode = false; | ||
350 | }else if ( (res->size().width() <= m_size_policy && | ||
351 | m_orient == Horizontal ) || | ||
352 | (res->size().height() <= m_size_policy && | ||
353 | m_orient == Vertical ) ) { | ||
354 | changeTab(); | ||
355 | }else if ( res->size().height() > m_size_policy && | ||
356 | m_orient == Vertical ) { | ||
357 | qWarning("Changng to vbox %s", name() ); | ||
358 | changeVBox(); | ||
359 | mode = false; | ||
360 | } | ||
361 | |||
362 | emit sizeChanged(mode, m_orient ); | ||
363 | } | ||
364 | |||
365 | /* | ||
366 | * Adds a container to a tab either the parent tab | ||
367 | * or our own | ||
368 | */ | ||
369 | void OSplitter::addToTab( const Opie::OSplitterContainer& con ) { | ||
370 | QWidget *wid = con.widget; | ||
371 | // not needed widgetstack will reparent as well wid.reparent(m_tabWidget, wid->getWFlags(), QPoint(0, 0) ); | ||
372 | if (m_parentTab ) | ||
373 | m_parentTab->addTab( wid, con.icon, con.name ); | ||
374 | else | ||
375 | m_tabWidget->addTab( wid, con.icon, con.name ); | ||
376 | } | ||
377 | |||
378 | |||
379 | /* | ||
380 | * adds a container to the box | ||
381 | */ | ||
382 | void OSplitter::addToBox( const Opie::OSplitterContainer& con ) { | ||
383 | QWidget* wid = con.widget; | ||
384 | wid->reparent(m_hbox, 0, QPoint(0, 0) ); | ||
385 | } | ||
386 | |||
387 | |||
388 | /* | ||
389 | * Removes a widget from the tab | ||
390 | */ | ||
391 | void OSplitter::removeFromTab( QWidget* wid ) { | ||
392 | if (m_parentTab ) | ||
393 | m_parentTab->removePage( wid ); | ||
394 | else | ||
395 | m_tabWidget->removePage( wid ); | ||
396 | } | ||
397 | |||
398 | /* | ||
399 | * switches over to a OTabWidget layout | ||
400 | * it is recursive | ||
401 | */ | ||
402 | void OSplitter::changeTab() { | ||
403 | /* if we're the owner of the tab widget */ | ||
404 | if (m_tabWidget ) { | ||
405 | raise(); | ||
406 | show(); | ||
407 | m_tabWidget->setGeometry( frameRect() ); | ||
408 | return; | ||
409 | } | ||
410 | |||
411 | qWarning(" New Tab Widget %s", name() ); | ||
412 | /* | ||
413 | * and add all widgets this will reparent them | ||
414 | * delete m_hbox set it to 0 | ||
415 | * | ||
416 | */ | ||
417 | OTabWidget *tab; | ||
418 | if ( m_parentTab ) { | ||
419 | hide(); | ||
420 | tab = m_parentTab; | ||
421 | /* expensive but needed cause we're called from setTabWidget and resizeEvent*/ | ||
422 | if (!m_container.isEmpty() ) { | ||
423 | ContainerList::Iterator it = m_container.begin(); | ||
424 | for (; it != m_container.end(); ++it ) | ||
425 | m_parentTab->removePage( (*it).widget ); | ||
426 | } | ||
427 | }else | ||
428 | tab = m_tabWidget = new OTabWidget( this ); | ||
429 | |||
430 | connect(tab, SIGNAL(currentChanged(QWidget*) ), | ||
431 | this, SIGNAL(currentChanged(QWidget*) ) ); | ||
432 | |||
433 | for ( ContainerList::Iterator it = m_container.begin(); it != m_container.end(); ++it ) { | ||
434 | qWarning("Widget is %s", (*it).name.latin1() ); | ||
435 | addToTab( (*it) ); | ||
436 | } | ||
437 | |||
438 | for ( OSplitter* split = m_splitter.first(); split; split = m_splitter.next() ) { | ||
439 | split->reparent(this, 0, QPoint(0, 0) ); | ||
440 | split->setTabWidget( tab ); | ||
441 | } | ||
442 | |||
443 | |||
444 | delete m_hbox; | ||
445 | m_hbox = 0; | ||
446 | if (!m_tabWidget ) | ||
447 | return; | ||
448 | |||
449 | m_tabWidget->setGeometry( frameRect() ); | ||
450 | m_tabWidget->show(); | ||
451 | |||
452 | } | ||
453 | |||
454 | /* | ||
455 | * changes over to a box | ||
456 | * this is recursive as well | ||
457 | */ | ||
458 | void OSplitter::changeHBox() { | ||
459 | if (m_hbox ) { | ||
460 | m_hbox->setGeometry( frameRect() ); | ||
461 | return; | ||
462 | } | ||
463 | |||
464 | qWarning("new HBox %s", name() ); | ||
465 | m_hbox = new QHBox( this ); | ||
466 | commonChangeBox(); | ||
467 | } | ||
468 | |||
469 | void OSplitter::changeVBox() { | ||
470 | if (m_hbox ) { | ||
471 | m_hbox->setGeometry( frameRect() ); | ||
472 | return; | ||
473 | } | ||
474 | |||
475 | qWarning("New VBOX %s", name() ); | ||
476 | m_hbox = new QVBox( this ); | ||
477 | |||
478 | commonChangeBox(); | ||
479 | |||
480 | } | ||
481 | |||
482 | /* | ||
483 | * common box code | ||
484 | * first remove and add children | ||
485 | * the other splitters | ||
486 | * it is recursive as well due the call to setTabWidget | ||
487 | */ | ||
488 | void OSplitter::commonChangeBox() { | ||
489 | qWarning(" Name of Splitters is %s", name() ); | ||
490 | |||
491 | for (ContainerList::Iterator it = m_container.begin(); it != m_container.end(); ++it ) { | ||
492 | /* only if parent tab.. m_tabWidgets gets deleted and would do that as well */ | ||
493 | if (m_parentTab ) | ||
494 | removeFromTab( (*it).widget ); | ||
495 | qWarning("Adding to box %s", (*it).name.latin1() ); | ||
496 | addToBox( (*it) ); | ||
497 | } | ||
498 | for ( OSplitter* split = m_splitter.first(); split; split = m_splitter.next() ) { | ||
499 | /* tell them the world had changed */ | ||
500 | split->setTabWidget( 0 ); | ||
501 | Opie::OSplitterContainer con; | ||
502 | con.widget = split; | ||
503 | // con.widget = split->m_tabWidget ? static_cast<QWidget*>(split->m_tabWidget) | ||
504 | // : static_cast<QWidget*>(split->m_hbox); | ||
505 | addToBox( con ); | ||
506 | } | ||
507 | |||
508 | |||
509 | |||
510 | if (m_parentTab ) | ||
511 | m_parentTab->addTab(m_hbox, iconName(), label() ); | ||
512 | else { | ||
513 | qWarning(" setting Box geometry for %s", name() ); | ||
514 | m_hbox->setGeometry( frameRect() ); | ||
515 | m_hbox->show(); | ||
516 | delete m_tabWidget; | ||
517 | m_tabWidget = 0; | ||
518 | show(); // also show this widget | ||
519 | } | ||
520 | } | ||
521 | |||
522 | /* | ||
523 | * sets the tabwidget, removes tabs, and relayouts the widget | ||
524 | */ | ||
525 | void OSplitter::setTabWidget( OTabWidget* wid) { | ||
526 | /* clean up cause m_parentTab will not be available for us */ | ||
527 | if ( m_parentTab ) { | ||
528 | if (m_hbox ) | ||
529 | m_parentTab->removePage( m_hbox ); | ||
530 | else if (!m_container.isEmpty() ){ | ||
531 | ContainerList::Iterator it = m_container.begin(); | ||
532 | for ( ; it != m_container.end(); ++it ) | ||
533 | m_parentTab->removePage( (*it).widget ); | ||
534 | } | ||
535 | } | ||
536 | /* the parent Splitter changed so either make us indepent or dep */ | ||
537 | |||
538 | m_parentTab = wid; | ||
539 | |||
540 | QWidget *tab = m_tabWidget; | ||
541 | QWidget *box = m_hbox; | ||
542 | m_hbox = 0; m_tabWidget = 0; | ||
543 | |||
544 | if ( layoutMode() ) | ||
545 | changeTab(); | ||
546 | else if (m_orient == Horizontal ) | ||
547 | changeHBox(); | ||
548 | else | ||
549 | changeVBox(); | ||
550 | |||
551 | /* our own crap is added and children from change* */ | ||
552 | delete tab; | ||
553 | delete box; | ||
554 | } | ||
555 | |||
556 | |||
557 | #if 0 | ||
558 | void OSplitter::reparentAll() { | ||
559 | if (m_container.isEmpty() ) | ||
560 | return; | ||
561 | |||
562 | ContainerList::Iterator it = m_container.begin(); | ||
563 | for ( ; it != m_container.end(); ++it ) | ||
564 | (*it).wid->reparent(0, 0, QPoint(0, 0) ); | ||
565 | |||
566 | |||
567 | } | ||
568 | #endif | ||
569 | |||
570 | /** | ||
571 | * @internal | ||
572 | */ | ||
573 | bool OSplitter::layoutMode()const { | ||
574 | if ( size().width() > m_size_policy && | ||
575 | m_orient == Horizontal ) { | ||
576 | return false; | ||
577 | }else if ( size().height() > m_size_policy && | ||
578 | m_orient == Vertical ) { | ||
579 | return false; | ||
580 | } | ||
581 | |||
582 | return true; | ||
583 | } | ||