• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdemdi
 

tdemdi

  • tdemdi
tdemdimainfrm.cpp
1 //----------------------------------------------------------------------------
2 // filename : tdemdimainfrm.cpp
3 //----------------------------------------------------------------------------
4 // Project : KDE MDI extension
5 //
6 // begin : 07/1999 by Szymon Stefanek as part of kvirc
7 // (an IRC application)
8 // changes : 09/1999 by Falk Brettschneider to create an
9 // - 06/2000 stand-alone Qt extension set of
10 // classes and a Qt-based library
11 // 2000-2003 maintained by the KDevelop project
12 // patches : 02/2000 by Massimo Morin (mmorin@schedsys.com)
13 // */2000 by Lars Beikirch (Lars.Beikirch@gmx.net)
14 // 01/2003 by Jens Zurheide (jens.zurheide@gmx.de)
15 //
16 // copyright : (C) 1999-2003 by Szymon Stefanek (stefanek@tin.it)
17 // and
18 // Falk Brettschneider
19 // email : falkbr@kdevelop.org (Falk Brettschneider)
20 //----------------------------------------------------------------------------
21 //
22 //----------------------------------------------------------------------------
23 //
24 // This program is free software; you can redistribute it and/or modify
25 // it under the terms of the GNU Library General Public License as
26 // published by the Free Software Foundation; either version 2 of the
27 // License, or (at your option) any later version.
28 //
29 //----------------------------------------------------------------------------
30 
31 
32 /*
33  * ATTENTION: please do you part to try to make this file legible. It's
34  * extremely hard to read already. Especially follow the indenting rules.
35  */
36 #include "config.h"
37 
38 #include <assert.h>
39 
40 #include <tqcursor.h>
41 #include <tqclipboard.h>
42 #include <tqobjectlist.h>
43 #include <tqpopupmenu.h>
44 #include <tqmenubar.h>
45 
46 #include <tdemenubar.h>
47 #include <tdeapplication.h>
48 #include <kdebug.h>
49 #include <tdeversion.h>
50 #include <tqtabwidget.h>
51 #include <tdelocale.h>
52 #include <tdestdaccel.h>
53 
54 #include <kiconloader.h>
55 #include <tdemdidockcontainer.h>
56 
57 
58 #include <tqtoolbutton.h>
59 #include <tqdockarea.h>
60 #include <tqlayout.h>
61 #include <tqtimer.h>
62 #include <tqtextstream.h>
63 #include <tqstring.h>
64 #include <tqmap.h>
65 #include <tqvaluelist.h>
66 
67 #include "tdemdimainfrm.h"
68 #include "tdemditaskbar.h"
69 #include "tdemdichildfrm.h"
70 #include "tdemdichildarea.h"
71 #include "tdemdichildview.h"
72 #include "tdemdidockcontainer.h"
73 #include "tdemditoolviewaccessor_p.h"
74 #include "tdemdifocuslist.h"
75 #include "tdemdidocumentviewtabwidget.h"
76 #include "tdemdiguiclient.h"
77 
78 #include "win_undockbutton.xpm"
79 #include "win_minbutton.xpm"
80 #include "win_restorebutton.xpm"
81 #include "win_closebutton.xpm"
82 #include "kde_undockbutton.xpm"
83 #include "kde_minbutton.xpm"
84 #include "kde_restorebutton.xpm"
85 #include "kde_closebutton.xpm"
86 #include "kde2_undockbutton.xpm"
87 #include "kde2_minbutton.xpm"
88 #include "kde2_restorebutton.xpm"
89 #include "kde2_closebutton.xpm"
90 #include "kde2laptop_undockbutton.xpm"
91 #include "kde2laptop_minbutton.xpm"
92 #include "kde2laptop_restorebutton.xpm"
93 #include "kde2laptop_closebutton.xpm"
94 #include "kde2laptop_closebutton_menu.xpm"
95 
96 #ifdef Q_WS_X11
97 #ifndef NO_KDE
98 #include <X11/X.h> // schroder
99 #include <X11/Xlib.h> // schroder
100 #endif
101 
102 #ifdef KeyRelease
103 /* I hate the defines in the X11 header files. Get rid of one of them */
104 #undef KeyRelease
105 #endif
106 
107 #ifdef KeyPress
108 /* I hate the defines in the X11 header files. Get rid of one of them */
109 #undef KeyPress
110 #endif
111 #endif // Q_WS_X11 && ! K_WS_QTONLY
112 
113 using namespace KParts;
114 
115 KMdi::FrameDecor KMdiMainFrm::m_frameDecoration = KMdi::KDELook;
116 
117 class KMdiMainFrmPrivate
118 {
119 public:
120  KMdiMainFrmPrivate() : focusList( 0 )
121  {
122  for ( int i = 0;i < 4;i++ )
123  {
124  activeDockPriority[ i ] = 0;
125  m_styleIDEAlMode = 0;
126  m_toolviewStyle = 0;
127  }
128  }
129  ~KMdiMainFrmPrivate()
130  {}
131  KMdiDockContainer* activeDockPriority[ 4 ];
132  KMdiFocusList *focusList;
133  int m_styleIDEAlMode;
134  int m_toolviewStyle;
135  TDEAction *closeWindowAction;
136 };
137 
138 //============ constructor ============//
139 KMdiMainFrm::KMdiMainFrm( TQWidget* parentWidget, const char* name, KMdi::MdiMode mdiMode, WFlags flags )
140  : KParts::DockMainWindow( parentWidget, name, flags )
141  , m_mdiMode( KMdi::UndefinedMode )
142  , m_pMdi( 0L )
143  , m_pTaskBar( 0L )
144  , m_pDocumentViews( 0L )
145  , m_pCurrentWindow( 0L )
146  , m_pWindowPopup( 0L )
147  , m_pTaskBarPopup( 0L )
148  , m_pWindowMenu( 0L )
149  , m_pDockMenu( 0L )
150  , m_pMdiModeMenu( 0L )
151  , m_pPlacingMenu( 0L )
152  , m_pMainMenuBar( 0L )
153  , m_pUndockButtonPixmap( 0L )
154  , m_pMinButtonPixmap( 0L )
155  , m_pRestoreButtonPixmap( 0L )
156  , m_pCloseButtonPixmap( 0L )
157  , m_pUndock( 0L )
158  , m_pMinimize( 0L )
159  , m_pRestore( 0L )
160  , m_pClose( 0L )
161  , m_bMaximizedChildFrmMode( false )
162  , m_oldMainFrmHeight( 0 )
163  , m_oldMainFrmMinHeight( 0 )
164  , m_oldMainFrmMaxHeight( 0 )
165  , m_bSDIApplication( false )
166  , m_pDockbaseAreaOfDocumentViews( 0L )
167  , m_pTempDockSession( 0L )
168  , m_bClearingOfWindowMenuBlocked( false )
169  , m_pDragEndTimer( 0L )
170  , m_bSwitching( false )
171  , m_leftContainer( 0 )
172  , m_rightContainer( 0 )
173  , m_topContainer( 0 )
174  , m_bottomContainer( 0 )
175  , d( new KMdiMainFrmPrivate() )
176  , m_mdiGUIClient( 0 )
177  , m_managedDockPositionMode( false )
178  , m_documentTabWidget( 0 )
179 {
180  kdDebug(760) << k_funcinfo << endl;
181  // Create the local lists of windows
182  m_pDocumentViews = new TQPtrList<KMdiChildView>;
183  m_pDocumentViews->setAutoDelete( false );
184  m_pToolViews = new TQMap<TQWidget*, KMdiToolViewAccessor*>;
185 
186  // This seems to be needed (re-check it after Qt2.0 comed out)
187  setFocusPolicy( TQ_ClickFocus );
188 
189  // create the central widget
190  createMdiManager();
191 
192  // cover KMdi's childarea by a dockwidget
193  m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", TQPixmap(), 0L, "mdi_area_cover" );
194  m_pDockbaseAreaOfDocumentViews->setDockWindowTransient( this, true );
195  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
196  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
197  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
198  // set this dock to main view
199  setView( m_pDockbaseAreaOfDocumentViews );
200  setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
201 
202  // Apply options for the MDI manager
203  applyOptions();
204 
205  m_pTaskBarPopup = new TQPopupMenu( this, "taskbar_popup_menu" );
206  m_pWindowPopup = new TQPopupMenu( this, "window_popup_menu" );
207 
208  m_pWindowMenu = new TQPopupMenu( this, "window_menu" );
209  m_pWindowMenu->setCheckable( true );
210  TQObject::connect( m_pWindowMenu, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( fillWindowMenu() ) );
211 
212  m_pDockMenu = new TQPopupMenu( this, "dock_menu" );
213  m_pDockMenu->setCheckable( true );
214 
215  m_pMdiModeMenu = new TQPopupMenu( this, "mdimode_menu" );
216  m_pMdiModeMenu->setCheckable( true );
217 
218  m_pPlacingMenu = new TQPopupMenu( this, "placing_menu" );
219 
220  d->closeWindowAction = new TDEAction(i18n("&Close"), TDEStdAccel::close(),
221  TQT_TQOBJECT(this), TQT_SLOT(closeActiveView()), actionCollection(), "window_close");
222 
223  // the MDI view taskbar
224  createTaskBar();
225 
226  // this is only a hack, but prevents us from crash because the buttons are otherwise
227  // not created before we switch the modes where we need them !!!
228  setMenuForSDIModeSysButtons( menuBar() );
229 
230  switch ( mdiMode )
231  {
232  case KMdi::IDEAlMode:
233  kdDebug(760) << k_funcinfo << "Switching to IDEAl mode" << endl;
234  switchToIDEAlMode();
235  break;
236  case KMdi::TabPageMode:
237  kdDebug(760) << k_funcinfo << "Switching to tab page mode" << endl;
238  switchToTabPageMode();
239  break;
240  case KMdi::ToplevelMode:
241  kdDebug(760) << k_funcinfo << "Switching to top level mode" << endl;
242  switchToToplevelMode();
243  break;
244  default:
245  m_mdiMode = KMdi::ChildframeMode;
246  kdDebug(760) << k_funcinfo << "Switching to child frame mode" << endl;
247  break;
248  }
249 
250  // drag end timer
251  m_pDragEndTimer = new TQTimer();
252  connect( m_pDragEndTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( dragEndTimeOut() ) );
253  connect( guiFactory(), TQT_SIGNAL( clientAdded( KXMLGUIClient* ) ),
254  this, TQT_SLOT( verifyToplevelHeight() ) );
255  connect( guiFactory(), TQT_SIGNAL( clientRemoved( KXMLGUIClient* ) ),
256  this, TQT_SLOT( verifyToplevelHeight() ) );
257 }
258 
259 void KMdiMainFrm::verifyToplevelHeight()
260 {
261  if ( m_mdiMode != KMdi::ToplevelMode )
262  return;
263 
264  //kdDebug(760) << k_funcinfo << endl;
265  int topDockHeight = topDock() ? topDock()->height() : 0;
266  int menuBarHeight = hasMenuBar() ? menuBar()->height() : 0;
267  setFixedHeight( topDockHeight + menuBarHeight );
268  resize( width(), height() );
269 }
270 
271 void KMdiMainFrm::setStandardMDIMenuEnabled( bool showModeMenu )
272 {
273  m_mdiGUIClient = new KMDIPrivate::KMDIGUIClient( this, showModeMenu );
274  connect( m_mdiGUIClient, TQT_SIGNAL( toggleTop() ), this, TQT_SIGNAL( toggleTop() ) );
275  connect( m_mdiGUIClient, TQT_SIGNAL( toggleLeft() ), this, TQT_SIGNAL( toggleLeft() ) );
276  connect( m_mdiGUIClient, TQT_SIGNAL( toggleRight() ), this, TQT_SIGNAL( toggleRight() ) );
277  connect( m_mdiGUIClient, TQT_SIGNAL( toggleBottom() ), this, TQT_SIGNAL( toggleBottom() ) );
278 
279  if ( m_mdiMode == KMdi::IDEAlMode )
280  {
281  if ( m_topContainer )
282  connect( this, TQT_SIGNAL( toggleTop() ), m_topContainer->getWidget(), TQT_SLOT( toggle() ) );
283  if ( m_leftContainer )
284  connect( this, TQT_SIGNAL( toggleLeft() ), m_leftContainer->getWidget(), TQT_SLOT( toggle() ) );
285  if ( m_rightContainer )
286  connect( this, TQT_SIGNAL( toggleRight() ), m_rightContainer->getWidget(), TQT_SLOT( toggle() ) );
287  if ( m_bottomContainer )
288  connect( this, TQT_SIGNAL( toggleBottom() ), m_bottomContainer->getWidget(), TQT_SLOT( toggle() ) );
289  }
290 
291  emit mdiModeHasBeenChangedTo( m_mdiMode );
292 }
293 
294 //============ ~KMdiMainFrm ============//
295 KMdiMainFrm::~KMdiMainFrm()
296 {
297  //save the children first to a list, as removing invalidates our iterator
298  TQValueList<KMdiChildView*> children;
299  for ( KMdiChildView * w = m_pDocumentViews->first();w;w = m_pDocumentViews->next() )
300  children.append( w );
301 
302  // safely close the windows so properties are saved...
303  TQValueListIterator<KMdiChildView*> childIt;
304  for ( childIt = children.begin(); childIt != children.end(); ++childIt )
305  {
306  closeWindow( *childIt, false ); // without re-layout taskbar!
307  }
308 
309  emit lastChildViewClosed();
310  delete m_pDocumentViews;
311  delete m_pToolViews;
312  m_pToolViews = 0;
313  delete m_pDragEndTimer;
314 
315  delete m_pUndockButtonPixmap;
316  delete m_pMinButtonPixmap;
317  delete m_pRestoreButtonPixmap;
318  delete m_pCloseButtonPixmap;
319 
320  //deletes added for Release-Version-Pop-Up-WinMenu-And-Go-Out-Problem
321  delete m_pDockMenu;
322  delete m_pMdiModeMenu;
323  delete m_pPlacingMenu;
324  delete m_pTaskBarPopup;
325  delete m_pWindowPopup;
326  delete m_pWindowMenu;
327  delete m_mdiGUIClient;
328  delete m_pTempDockSession;
329  m_mdiGUIClient = 0;
330  delete d;
331  d = 0;
332 }
333 
334 //============ applyOptions ============//
335 //FIXME something wrong with this function. dunno what though
336 void KMdiMainFrm::applyOptions()
337 {
338  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
339  for ( ; ( *it ); ++it )
340  {
341  TQWidget* childFrame = 0L;
342  if ( ( *it )->mdiParent() )
343  {
344  kdDebug(760) << k_funcinfo << "using child view's mdi parent for resize hack" << endl;
345  childFrame = ( *it )->mdiParent();
346  }
347  else
348  {
349  kdDebug(760) << k_funcinfo << "using child view for resize hack" << endl;
350  childFrame = ( *it );
351  }
352 
353  int w = childFrame->width();
354  int h = childFrame->height();
355  childFrame->resize( w + 1, h + 1 );
356  childFrame->resize( w - 1, h - 1 );
357  }
358 }
359 
360 //============ createMdiManager ============//
361 void KMdiMainFrm::createMdiManager()
362 {
363  kdDebug(760) << k_funcinfo << "creating MDI manager" << endl;
364  m_pMdi = new KMdiChildArea( this );
365  setCentralWidget( m_pMdi );
366  TQObject::connect( m_pMdi, TQT_SIGNAL( nowMaximized( bool ) ),
367  this, TQT_SLOT( setEnableMaximizedChildFrmMode( bool ) ) );
368  TQObject::connect( m_pMdi, TQT_SIGNAL( noMaximizedChildFrmLeft( KMdiChildFrm* ) ),
369  this, TQT_SLOT( switchOffMaximizeModeForMenu( KMdiChildFrm* ) ) );
370  TQObject::connect( m_pMdi, TQT_SIGNAL( sysButtonConnectionsMustChange( KMdiChildFrm*, KMdiChildFrm* ) ),
371  this, TQT_SLOT( updateSysButtonConnections( KMdiChildFrm*, KMdiChildFrm* ) ) );
372  TQObject::connect( m_pMdi, TQT_SIGNAL( popupWindowMenu( TQPoint ) ),
373  this, TQT_SLOT( popupWindowMenu( TQPoint ) ) );
374  TQObject::connect( m_pMdi, TQT_SIGNAL( lastChildFrmClosed() ),
375  this, TQT_SIGNAL( lastChildFrmClosed() ) );
376 }
377 
378 //============ createTaskBar ==============//
379 void KMdiMainFrm::createTaskBar()
380 {
381  m_pTaskBar = new KMdiTaskBar( this, TQMainWindow::DockBottom );
382  m_pTaskBar->installEventFilter( this );
383 }
384 
385 void KMdiMainFrm::slot_toggleTaskBar()
386 {
387  if ( !m_pTaskBar )
388  return;
389  m_pTaskBar->switchOn( !m_pTaskBar->isSwitchedOn() );
390 }
391 
392 void KMdiMainFrm::resizeEvent( TQResizeEvent *e )
393 {
394  if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
395  {
396  if ( e->oldSize().height() != e->size().height() )
397  return ;
398  }
399  KParts::DockMainWindow::resizeEvent( e );
400  if ( !m_mdiGUIClient )
401  return ;
402  setSysButtonsAtMenuPosition();
403 }
404 
405 //================ setMinimumSize ===============//
406 
407 void KMdiMainFrm::setMinimumSize( int minw, int minh )
408 {
409  if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
410  return ;
411  DockMainWindow::setMinimumSize( minw, minh );
412 }
413 
414 //================ wrapper ===============//
415 
416 KMdiChildView* KMdiMainFrm::createWrapper( TQWidget *view, const TQString& name, const TQString& shortName )
417 {
418  Q_ASSERT( view ); // if this assert fails, then some part didn't return a widget. Fix the part ;)
419 
420  KMdiChildView* pMDICover = new KMdiChildView( name /*caption*/, 0L /*parent*/,
421  name.latin1() );
422  TQBoxLayout* pLayout = new TQHBoxLayout( pMDICover, 0, -1, "layout" );
423  view->reparent( pMDICover, TQPoint( 0, 0 ) );
424  pLayout->addWidget( view );
425  // pMDICover->setName(name);
426  pMDICover->setTabCaption( shortName );
427  pMDICover->setCaption( name );
428 
429  const TQPixmap* wndIcon = view->icon();
430  if ( wndIcon )
431  pMDICover->setIcon( *wndIcon );
432 
433  pMDICover->trackIconAndCaptionChanges( view );
434  return pMDICover;
435 }
436 
437 //================ addWindow ===============//
438 
439 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags )
440 {
441  addWindow( pWnd, flags, -1 );
442 }
443 
444 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags, int index )
445 {
446  if ( windowExists( pWnd, AnyView ) ) //already added
447  return;
448 
449  if ( flags & KMdi::ToolWindow )
450  {
451  addToolWindow( pWnd );
452  // some kind of cascading
453  pWnd->move( m_pMdi->mapToGlobal( m_pMdi->getCascadePoint() ) );
454 
455  return ;
456  }
457 
458  d->closeWindowAction->setEnabled(true);
459 
460  // common connections used when under MDI control
461  TQObject::connect( pWnd, TQT_SIGNAL( clickedInWindowMenu( int ) ), this, TQT_SLOT( windowMenuItemActivated( int ) ) );
462  TQObject::connect( pWnd, TQT_SIGNAL( focusInEventOccurs( KMdiChildView* ) ), this, TQT_SLOT( activateView( KMdiChildView* ) ) );
463  TQObject::connect( pWnd, TQT_SIGNAL( childWindowCloseRequest( KMdiChildView* ) ), this, TQT_SLOT( childWindowCloseRequest( KMdiChildView* ) ) );
464  TQObject::connect( pWnd, TQT_SIGNAL( attachWindow( KMdiChildView*, bool ) ), this, TQT_SLOT( attachWindow( KMdiChildView*, bool ) ) );
465  TQObject::connect( pWnd, TQT_SIGNAL( detachWindow( KMdiChildView*, bool ) ), this, TQT_SLOT( detachWindow( KMdiChildView*, bool ) ) );
466  TQObject::connect( pWnd, TQT_SIGNAL( clickedInDockMenu( int ) ), this, TQT_SLOT( dockMenuItemActivated( int ) ) );
467  TQObject::connect( pWnd, TQT_SIGNAL( activated( KMdiChildView* ) ), this, TQT_SIGNAL( viewActivated( KMdiChildView* ) ) );
468  TQObject::connect( pWnd, TQT_SIGNAL( deactivated( KMdiChildView* ) ), this, TQT_SIGNAL( viewDeactivated( KMdiChildView* ) ) );
469 
470  if ( index == -1 )
471  m_pDocumentViews->append( pWnd );
472  else
473  m_pDocumentViews->insert( index, pWnd );
474 
475  if ( m_pTaskBar )
476  {
477  KMdiTaskBarButton* but = m_pTaskBar->addWinButton( pWnd );
478  TQObject::connect( pWnd, TQT_SIGNAL( tabCaptionChanged( const TQString& ) ), but, TQT_SLOT( setNewText( const TQString& ) ) );
479  }
480 
481  // embed the view depending on the current MDI mode
482  if ( m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode )
483  {
484  TQPixmap pixmap;
485  if ( pWnd->icon() )
486  pixmap = *( pWnd->icon() );
487 
488  m_documentTabWidget->insertTab( pWnd, pixmap, pWnd->tabCaption(), index );
489 
490  connect( pWnd, TQT_SIGNAL( iconUpdated( TQWidget*, TQPixmap ) ), m_documentTabWidget, TQT_SLOT( updateIconInView( TQWidget*, TQPixmap ) ) );
491  connect( pWnd, TQT_SIGNAL( captionUpdated( TQWidget*, const TQString& ) ), m_documentTabWidget, TQT_SLOT( updateCaptionInView( TQWidget*, const TQString& ) ) );
492  }
493  else
494  {
495  if ( ( flags & KMdi::Detach ) || ( m_mdiMode == KMdi::ToplevelMode ) )
496  {
497  detachWindow( pWnd, !( flags & KMdi::Hide ) );
498  emit childViewIsDetachedNow( pWnd ); // fake it because detach won't call it in this case of addWindow-to-MDI
499  }
500  else
501  attachWindow( pWnd, !( flags & KMdi::Hide ), flags & KMdi::UseKMdiSizeHint );
502 
503  if ( ( m_bMaximizedChildFrmMode && ( !m_bSDIApplication && ( flags & KMdi::Detach ) )
504  && m_mdiMode != KMdi::ToplevelMode ) || ( flags & KMdi::Maximize ) )
505  {
506  if ( !pWnd->isMaximized() )
507  pWnd->maximize();
508  }
509 
510  if ( !m_bSDIApplication || ( flags & KMdi::Detach ) )
511  {
512  if ( flags & KMdi::Minimize )
513  pWnd->minimize();
514 
515  if ( !( flags & KMdi::Hide ) )
516  {
517  if ( pWnd->isAttached() )
518  pWnd->mdiParent()->show();
519  else
520  pWnd->show();
521  }
522  }
523  }
524 }
525 
526 //============ addWindow ============//
527 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, TQRect rectNormal, int flags )
528 {
529  addWindow( pWnd, flags );
530  if ( m_bMaximizedChildFrmMode && pWnd->isAttached() )
531  pWnd->setRestoreGeometry( rectNormal );
532  else
533  pWnd->setGeometry( rectNormal );
534 }
535 
536 //============ addWindow ============//
537 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, TQPoint pos, int flags )
538 {
539  addWindow( pWnd, flags );
540  if ( m_bMaximizedChildFrmMode && pWnd->isAttached() )
541  pWnd->setRestoreGeometry( TQRect( pos, pWnd->restoreGeometry().size() ) );
542  else
543  pWnd->move( pos );
544 }
545 
546 
547 
548 KMdiToolViewAccessor *KMdiMainFrm::createToolWindow()
549 {
550  return new KMdiToolViewAccessor( this );
551 }
552 
553 
554 void KMdiMainFrm::deleteToolWindow( TQWidget* pWnd )
555 {
556  if ( m_pToolViews->contains( pWnd ) )
557  deleteToolWindow( ( *m_pToolViews ) [ pWnd ] );
558 }
559 
560 void KMdiMainFrm::deleteToolWindow( KMdiToolViewAccessor *accessor )
561 {
562  delete accessor;
563 }
564 
565 //============ addWindow ============//
566 KMdiToolViewAccessor *KMdiMainFrm::addToolWindow( TQWidget* pWnd, KDockWidget::DockPosition pos, TQWidget* pTargetWnd,
567  int percent, const TQString& tabToolTip, const TQString& tabCaption )
568 {
569  TQWidget* tvta = pWnd;
570  KDockWidget* pDW = dockManager->getDockWidgetFromName( pWnd->name() );
571  if ( pDW )
572  {
573  // probably readDockConfig already created the widgetContainer, use that
574  pDW->setWidget( pWnd );
575 
576  if ( pWnd->icon() )
577  pDW->setPixmap( *pWnd->icon() );
578 
579  pDW->setTabPageLabel( ( tabCaption == 0 ) ? pWnd->caption() : tabCaption );
580  pDW->setToolTipString( tabToolTip );
581  dockManager->removeFromAutoCreateList( pDW );
582  pWnd = pDW;
583  }
584 
585  TQRect r = pWnd->geometry();
586 
587  KMdiToolViewAccessor *mtva = new KMdiToolViewAccessor( this, pWnd, tabToolTip, ( tabCaption == 0 ) ? pWnd->caption() : tabCaption );
588  m_pToolViews->insert( tvta, mtva );
589 
590  if ( pos == KDockWidget::DockNone )
591  {
592  mtva->d->widgetContainer->setEnableDocking( KDockWidget::DockNone );
593  mtva->d->widgetContainer->reparent( this, (WFlags)(WType_TopLevel | WType_Dialog), r.topLeft(), true ); //pToolView->isVisible());
594  }
595  else //add and dock the toolview as a dockwidget view
596  mtva->place( pos, pTargetWnd, percent );
597 
598 
599  return mtva;
600 }
601 
602 //============ attachWindow ============//
603 void KMdiMainFrm::attachWindow( KMdiChildView *pWnd, bool bShow, bool bAutomaticResize )
604 {
605  pWnd->installEventFilter( this );
606 
607  // decide whether window shall be cascaded
608  bool bCascade = false;
609  TQApplication::sendPostedEvents();
610  TQRect frameGeo = pWnd->frameGeometry();
611  TQPoint topLeftScreen = pWnd->mapToGlobal( TQPoint( 0, 0 ) );
612  TQPoint topLeftMdiChildArea = m_pMdi->mapFromGlobal( topLeftScreen );
613  TQRect childAreaGeo = m_pMdi->geometry();
614  if ( topLeftMdiChildArea.x() < 0 || topLeftMdiChildArea.y() < 0 ||
615  ( topLeftMdiChildArea.x() + frameGeo.width() > childAreaGeo.width() ) ||
616  ( topLeftMdiChildArea.y() + frameGeo.height() > childAreaGeo.height() ) )
617  {
618  bCascade = true;
619  }
620 
621  // create frame and insert child view
622  KMdiChildFrm *lpC = new KMdiChildFrm( m_pMdi );
623  pWnd->hide();
624  if ( !bCascade )
625  lpC->move( topLeftMdiChildArea );
626 
627  lpC->setClient( pWnd, bAutomaticResize );
628  lpC->setFocus();
629  pWnd->youAreAttached( lpC );
630  if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
631  {
632  setMinimumHeight( m_oldMainFrmMinHeight );
633  setMaximumHeight( m_oldMainFrmMaxHeight );
634  resize( width(), m_oldMainFrmHeight );
635  m_oldMainFrmHeight = 0;
636  switchToChildframeMode();
637  }
638 
639  m_pMdi->manageChild( lpC, false, bCascade );
640  if ( m_pMdi->topChild() && m_pMdi->topChild() ->isMaximized() )
641  {
642  TQRect r = lpC->geometry();
643  lpC->setGeometry( -lpC->m_pClient->x(), -lpC->m_pClient->y(),
644  m_pMdi->width() + KMDI_CHILDFRM_DOUBLE_BORDER,
645  m_pMdi->height() + lpC->captionHeight() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER );
646  lpC->setRestoreGeometry( r );
647  }
648 
649  if ( bShow )
650  {
651  lpC->show();
652  }
653 
654 #undef FocusIn
655  TQFocusEvent fe( TQEvent::FocusIn );
656  TQApplication::sendEvent( pWnd, &fe );
657 
658  m_pCurrentWindow = pWnd; // required for checking the active item
659 }
660 
661 //============= detachWindow ==============//
662 void KMdiMainFrm::detachWindow( KMdiChildView *pWnd, bool bShow )
663 {
664  if ( pWnd->isAttached() )
665  {
666  pWnd->removeEventFilter( this );
667  pWnd->youAreDetached();
668  // this is only if it was attached and you want to detach it
669  if ( pWnd->parent() )
670  {
671  KMdiChildFrm * lpC = pWnd->mdiParent();
672  if ( lpC )
673  {
674  if ( lpC->icon() )
675  {
676  TQPixmap pixm( *( lpC->icon() ) );
677  pWnd->setIcon( pixm );
678  }
679  TQString capt( lpC->caption() );
680  if ( !bShow )
681  lpC->hide();
682  lpC->unsetClient( m_undockPositioningOffset );
683  m_pMdi->destroyChildButNotItsView( lpC, false ); //Do not focus the new top child , we loose focus...
684  pWnd->setCaption( capt );
685  }
686  }
687  }
688  else
689  {
690  if ( pWnd->size().isEmpty() || ( pWnd->size() == TQSize( 1, 1 ) ) )
691  {
692  if ( m_pCurrentWindow )
693  {
694  pWnd->setGeometry( TQRect( m_pMdi->getCascadePoint( m_pDocumentViews->count() - 1 ), m_pCurrentWindow->size() ) );
695  }
696  else
697  {
698  pWnd->setGeometry( TQRect( m_pMdi->getCascadePoint( m_pDocumentViews->count() - 1 ), defaultChildFrmSize() ) );
699  }
700  }
701 #ifdef Q_WS_X11
702  if ( mdiMode() == KMdi::ToplevelMode )
703  {
704  XSetTransientForHint( tqt_xdisplay(), pWnd->winId(), topLevelWidget() ->winId() );
705  }
706 #endif
707 
708  return ;
709  }
710 
711 #ifdef Q_WS_X11
712  if ( mdiMode() == KMdi::ToplevelMode )
713  {
714  XSetTransientForHint( tqt_xdisplay(), pWnd->winId(), topLevelWidget() ->winId() );
715  }
716 #endif
717 
718  // this will show it...
719  if ( bShow )
720  {
721  activateView( pWnd );
722  }
723 
724  emit childViewIsDetachedNow( pWnd );
725 }
726 
727 //============== removeWindowFromMdi ==============//
728 void KMdiMainFrm::removeWindowFromMdi( KMdiChildView *pWnd )
729 {
730  Q_UNUSED( pWnd );
731  //Closes a child window. sends no close event : simply deletes it
732  //FIXME something wrong with this, but nobody knows whatcart
733 #if 0
734  if ( !( m_pWinList->removeRef( pWnd ) ) )
735  return ;
736  if ( m_pWinList->count() == 0 )
737  m_pCurrentWindow = 0L;
738 
739  TQObject::disconnect( pWnd, TQT_SIGNAL( attachWindow( KMdiChildView*, bool ) ), this, TQT_SLOT( attachWindow( KMdiChildView*, bool ) ) );
740  TQObject::disconnect( pWnd, TQT_SIGNAL( detachWindow( KMdiChildView*, bool ) ), this, TQT_SLOT( detachWindow( KMdiChildView*, bool ) ) );
741  TQObject::disconnect( pWnd, TQT_SIGNAL( focusInEventOccurs( KMdiChildView* ) ), this, TQT_SLOT( activateView( KMdiChildView* ) ) );
742  TQObject::disconnect( pWnd, TQT_SIGNAL( childWindowCloseRequest( KMdiChildView* ) ), this, TQT_SLOT( childWindowCloseRequest( KMdiChildView* ) ) );
743  TQObject::disconnect( pWnd, TQT_SIGNAL( clickedInWindowMenu( int ) ), this, TQT_SLOT( windowMenuItemActivated( int ) ) );
744  TQObject::disconnect( pWnd, TQT_SIGNAL( clickedInDockMenu( int ) ), this, TQT_SLOT( dockMenuItemActivated( int ) ) );
745 
746  if ( m_pTaskBar )
747  {
748  KMdiTaskBarButton * but = m_pTaskBar->getButton( pWnd );
749  if ( but != 0L )
750  {
751  TQObject::disconnect( pWnd, TQT_SIGNAL( tabCaptionChanged( const TQString& ) ), but, TQT_SLOT( setNewText( const TQString& ) ) );
752  }
753  m_pTaskBar->removeWinButton( pWnd );
754  }
755 
756  if ( m_mdiMode == KMdi::TabPageMode )
757  {
758  if ( m_pWinList->count() == 0 )
759  {
760  if ( !m_pDockbaseAreaOfDocumentViews )
761  {
762  m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", TQPixmap(), 0L, "mdi_area_cover" );
763  m_pDockbaseAreaOfDocumentViews->setDockWindowTransient( this, true );
764 
765  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
766  setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
767  }
768  m_pDockbaseOfTabPage->setDockSite( KDockWidget::DockFullSite );
769  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockCenter );
770  m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter );
771  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
772  m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
773  m_pClose->hide();
774  }
775  KDockWidget* pDockW = ( KDockWidget* ) pWnd->parentWidget();
776  pWnd->reparent( 0L, TQPoint( 0, 0 ) );
777  pDockW->setWidget( 0L );
778  if ( pDockW == m_pDockbaseOfTabPage )
779  {
780  TQTabWidget * pTab = ( TQTabWidget* ) pDockW->parentWidget() ->parentWidget();
781  int cnt = pTab->count();
782  m_pDockbaseOfTabPage = ( KDockWidget* ) pTab->page( cnt - 2 );
783  if ( pDockW == m_pDockbaseOfTabPage )
784  {
785  m_pDockbaseOfTabPage = ( KDockWidget* ) pTab->page( cnt - 1 ); // different to the one deleted next
786  }
787  }
788  delete pDockW;
789  if ( m_pWinList->count() == 1 )
790  {
791  m_pWinList->last() ->activate(); // all other views are activated by tab switch
792  }
793  }
794  else if ( pWnd->isAttached() )
795  {
796  pWnd->mdiParent() ->hide();
797  m_pMdi->destroyChildButNotItsView( pWnd->mdiParent() );
798  }
799  else
800  {
801  // is not attached
802  if ( m_pMdi->getVisibleChildCount() > 0 )
803  {
804  setActiveWindow();
805  m_pCurrentWindow = 0L;
806  KMdiChildView* pView = m_pMdi->topChild() ->m_pClient;
807  if ( pView )
808  {
809  pView->activate();
810  }
811  }
812  else if ( m_pWinList->count() > 0 )
813  {
814  //crash? m_pWinList->last()->activate();
815  //crash? m_pWinList->last()->setFocus();
816  }
817  }
818 
819  if ( pWnd->isToolView() )
820  pWnd->m_bToolView = false;
821 
822  if ( !m_pCurrentWindow )
823  emit lastChildViewClosed();
824 #endif
825 }
826 
827 //============== closeWindow ==============//
828 void KMdiMainFrm::closeWindow( KMdiChildView *pWnd, bool layoutTaskBar )
829 {
830  if ( !pWnd )
831  return ;
832  //Closes a child window. sends no close event : simply deletes it
833  m_pDocumentViews->removeRef( pWnd );
834  if ( m_pDocumentViews->count() == 0 )
835  m_pCurrentWindow = 0L;
836 
837  if ( m_pTaskBar )
838  {
839  m_pTaskBar->removeWinButton( pWnd, layoutTaskBar );
840  }
841 
842  if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
843  {
844  if ( !m_documentTabWidget )
845  return ; //oops
846  if ( m_pDocumentViews->count() == 0 )
847  m_pClose->hide();
848  pWnd->reparent( 0L, TQPoint( 0, 0 ) );
849  kdDebug(760) << "-------- 1" << endl;
850  if ( m_pDocumentViews->count() == 1 )
851  {
852  m_pDocumentViews->last() ->activate(); // all other views are activated by tab switch
853  }
854  }
855  if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
856  {
857  if ( m_pDocumentViews->count() == 0 )
858  {
859  if ( !m_pDockbaseAreaOfDocumentViews )
860  {
861  m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", TQPixmap(), 0L, "mdi_area_cover" );
862  m_pDockbaseAreaOfDocumentViews->setDockWindowTransient( this, true );
863  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
864  setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
865  }
866 #if 0
867  m_pDockbaseOfTabPage->setDockSite( KDockWidget::DockFullSite );
868  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockCenter );
869  m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter );
870  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
871  m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
872 #endif
873 
874  m_pClose->hide();
875  }
876 #if 0
877  KDockWidget* pDockW = ( KDockWidget* ) pWnd->parentWidget();
878  pWnd->reparent( 0L, TQPoint( 0, 0 ) );
879  pDockW->setWidget( 0L );
880  if ( pDockW == m_pDockbaseOfTabPage )
881  {
882  TQTabWidget * pTab = ( TQTabWidget* ) pDockW->parentWidget() ->parentWidget();
883  int cnt = pTab->count();
884  m_pDockbaseOfTabPage = ( KDockWidget* ) pTab->page( cnt - 2 );
885  if ( pDockW == m_pDockbaseOfTabPage )
886  {
887  m_pDockbaseOfTabPage = ( KDockWidget* ) pTab->page( cnt - 1 ); // different to the one deleted next
888  }
889  }
890  delete pDockW;
891 #endif
892 
893  delete pWnd;
894  if ( m_pDocumentViews->count() == 1 )
895  {
896  m_pDocumentViews->last() ->activate(); // all other views are activated by tab switch
897  }
898  }
899  else if ( pWnd->isAttached() )
900  {
901  m_pMdi->destroyChild( pWnd->mdiParent() );
902  }
903  else
904  {
905  delete pWnd;
906  // is not attached
907  if ( m_pMdi->getVisibleChildCount() > 0 )
908  {
909  setActiveWindow();
910  m_pCurrentWindow = 0L;
911  KMdiChildView* pView = m_pMdi->topChild() ->m_pClient;
912  if ( pView )
913  {
914  pView->activate();
915  }
916  }
917  else if ( m_pDocumentViews->count() > 0 )
918  {
919  if ( m_pDocumentViews->current() )
920  {
921  m_pDocumentViews->current() ->activate();
922  m_pDocumentViews->current() ->setFocus();
923  }
924  else
925  {
926  m_pDocumentViews->last() ->activate();
927  m_pDocumentViews->last() ->setFocus();
928  }
929  }
930  }
931 
932  if ( !m_pCurrentWindow )
933  {
934  d->closeWindowAction->setEnabled(false);
935  emit lastChildViewClosed();
936  }
937 }
938 
939 //================== findWindow =================//
940 KMdiChildView* KMdiMainFrm::findWindow( const TQString& caption )
941 {
942  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
943  for ( ; ( *it ); ++it )
944  {
945  if ( ( *it )->caption() == caption )
946  return ( *it );
947  }
948  return 0L;
949 }
950 
951 //================== activeWindow ===================//
952 KMdiChildView* KMdiMainFrm::activeWindow()
953 {
954  return m_pCurrentWindow;
955 }
956 
957 //================== windowExists ? =================//
958 bool KMdiMainFrm::windowExists( KMdiChildView *pWnd, ExistsAs as )
959 {
960  if ( ( as == ToolView ) || ( as == AnyView ) )
961  {
962  if ( m_pToolViews->contains( pWnd ) )
963  return true;
964  if ( as == ToolView )
965  return false;
966  }
967 
968  if ( m_pDocumentViews->findRef( pWnd ) != -1 )
969  return true;
970 
971  return false;
972 }
973 
974 TQPopupMenu * KMdiMainFrm::windowPopup( KMdiChildView * pWnd, bool bIncludeTaskbarPopup )
975 {
976  m_pWindowPopup->clear();
977  if ( bIncludeTaskbarPopup )
978  {
979  m_pWindowPopup->insertItem( i18n( "Window" ), taskBarPopup( pWnd, false ) );
980  m_pWindowPopup->insertSeparator();
981  }
982  return m_pWindowPopup;
983 }
984 
985 //================ taskBarPopup =================//
986 TQPopupMenu* KMdiMainFrm::taskBarPopup( KMdiChildView *pWnd, bool /*bIncludeWindowPopup*/ )
987 {
988  //returns the g_pTaskBarPopup filled according to the KMdiChildView state
989  m_pTaskBarPopup->clear();
990  if ( pWnd->isAttached() )
991  {
992  m_pTaskBarPopup->insertItem( i18n( "Undock" ), pWnd, TQT_SLOT( detach() ) );
993  m_pTaskBarPopup->insertSeparator();
994  if ( pWnd->isMinimized() || pWnd->isMaximized() )
995  m_pTaskBarPopup->insertItem( i18n( "Restore" ), pWnd, TQT_SLOT( restore() ) );
996  if ( !pWnd->isMaximized() )
997  m_pTaskBarPopup->insertItem( i18n( "Maximize" ), pWnd, TQT_SLOT( maximize() ) );
998  if ( !pWnd->isMinimized() )
999  m_pTaskBarPopup->insertItem( i18n( "Minimize" ), pWnd, TQT_SLOT( minimize() ) );
1000  }
1001  else
1002  m_pTaskBarPopup->insertItem( i18n( "Dock" ), pWnd, TQT_SLOT( attach() ) );
1003  m_pTaskBarPopup->insertSeparator();
1004  m_pTaskBarPopup->insertItem( i18n( "Close" ), pWnd, TQT_SLOT( close() ) );
1005  // the window has a view...get the window popup
1006  m_pTaskBarPopup->insertSeparator();
1007  m_pTaskBarPopup->insertItem( i18n( "Operations" ), windowPopup( pWnd, false ) ); //alvoid recursion
1008  return m_pTaskBarPopup;
1009 }
1010 
1011 void KMdiMainFrm::slotDocCurrentChanged( TQWidget* pWidget )
1012 {
1013  KMdiChildView * pWnd = static_cast<KMdiChildView*>( pWidget );
1014  pWnd->m_bMainframesActivateViewIsPending = true;
1015 
1016  bool bActivateNecessary = true;
1017  if ( m_pCurrentWindow != pWnd )
1018  m_pCurrentWindow = pWnd;
1019 
1020  if ( m_pTaskBar )
1021  m_pTaskBar->setActiveButton( pWnd );
1022 
1023  if ( m_documentTabWidget && ( m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode ) )
1024  {
1025  m_documentTabWidget->showPage( pWnd );
1026  pWnd->activate();
1027  }
1028  else
1029  {
1030  if ( pWnd->isAttached() )
1031  {
1032  if ( bActivateNecessary && ( m_pMdi->topChild() == pWnd->mdiParent() ) )
1033  pWnd->activate();
1034 
1035  pWnd->mdiParent()->raiseAndActivate();
1036  }
1037  if ( !pWnd->isAttached() )
1038  {
1039  if ( bActivateNecessary )
1040  pWnd->activate();
1041 
1042  m_pMdi->setTopChild( 0L ); // lose focus in the mainframe window
1043  if ( !pWnd->isActiveWindow() )
1044  pWnd->setActiveWindow();
1045 
1046  pWnd->raise();
1047  }
1048  }
1049  if ( !switching() )
1050  activeWindow()->updateTimeStamp();
1051  emit collapseOverlapContainers();
1052  pWnd->m_bMainframesActivateViewIsPending = false;
1053 }
1054 
1055 
1056 void KMdiMainFrm::activateView( KMdiChildView* pWnd )
1057 {
1058  pWnd->m_bMainframesActivateViewIsPending = true;
1059 
1060  bool bActivateNecessary = true;
1061  if ( m_pCurrentWindow != pWnd )
1062  m_pCurrentWindow = pWnd;
1063  else
1064  {
1065  bActivateNecessary = false;
1066  // if this method is called as answer to view->activate(),
1067  // interrupt it because it's not necessary
1068  pWnd->m_bInterruptActivation = true;
1069  }
1070 
1071  if ( m_pTaskBar )
1072  m_pTaskBar->setActiveButton( pWnd );
1073 
1074  if ( m_documentTabWidget && m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode )
1075  {
1076  m_documentTabWidget->showPage( pWnd );
1077  pWnd->activate();
1078  }
1079  else
1080  {
1081  if ( pWnd->isAttached() )
1082  {
1083  if ( bActivateNecessary && ( m_pMdi->topChild() == pWnd->mdiParent() ) )
1084  pWnd->activate();
1085 
1086  pWnd->mdiParent() ->raiseAndActivate();
1087  }
1088  if ( !pWnd->isAttached() )
1089  {
1090  if ( bActivateNecessary )
1091  pWnd->activate();
1092 
1093  m_pMdi->setTopChild( 0L ); // lose focus in the mainframe window
1094  if ( !pWnd->isActiveWindow() )
1095  pWnd->setActiveWindow();
1096 
1097  pWnd->raise();
1098  }
1099  }
1100 
1101  emit collapseOverlapContainers();
1102 
1103  pWnd->m_bMainframesActivateViewIsPending = false;
1104 }
1105 
1106 void KMdiMainFrm::taskbarButtonRightClicked( KMdiChildView *pWnd )
1107 {
1108  activateView( pWnd ); // set focus
1109  //TQApplication::sendPostedEvents();
1110  taskBarPopup( pWnd, true ) ->popup( TQCursor::pos() );
1111 }
1112 
1113 void KMdiMainFrm::childWindowCloseRequest( KMdiChildView *pWnd )
1114 {
1115  KMdiViewCloseEvent * ce = new KMdiViewCloseEvent( pWnd );
1116  TQApplication::postEvent( this, ce );
1117 }
1118 
1119 bool KMdiMainFrm::event( TQEvent* e )
1120 {
1121  if ( e->type() == TQEvent::User )
1122  {
1123  KMdiChildView * pWnd = ( KMdiChildView* ) ( ( KMdiViewCloseEvent* ) e )->data();
1124  if ( pWnd != 0L )
1125  closeWindow( pWnd );
1126  return true;
1127  // A little hack: If MDI child views are moved implicietly by moving
1128  // the main widget they should know this too. Unfortunately there seems to
1129  // be no way to catch the move start / move stop situations for the main
1130  // widget in a clean way. (There is no MouseButtonPress/Release or
1131  // something like that.) Therefore we do the following: When we get the
1132  // "first" move event we start a timer and interprete it as "drag begin".
1133  // If we get the next move event and the timer is running we restart the
1134  // timer and don't do anything else. If the timer elapses (this meens we
1135  // haven't had any move event for a while) we interprete this as "drag
1136  // end". If the moving didn't stop actually, we will later get another
1137  // "drag begin", so we get a drag end too much, but this would be the same
1138  // as if the user would stop moving for a little while.
1139  // Actually we seem to be lucky that the timer does not elapse while we
1140  // are moving -> so we have no obsolete drag end / begin
1141  }
1142  else if ( isVisible() && e->type() == TQEvent::Move )
1143  {
1144  if ( m_pDragEndTimer->isActive() )
1145  {
1146  // this is not the first move -> stop old timer
1147  m_pDragEndTimer->stop();
1148  }
1149  else
1150  {
1151  // this is the first move -> send the drag begin to all concerned views
1152  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
1153  for ( ; ( *it ); ++it )
1154  {
1155  KMdiChildFrmDragBeginEvent dragBeginEvent( 0L );
1156  TQApplication::sendEvent( ( *it ), &dragBeginEvent );
1157  }
1158  }
1159  m_pDragEndTimer->start( 200, true ); // single shot after 200 ms
1160  }
1161 
1162  return DockMainWindow::event( e );
1163 }
1164 
1165 bool KMdiMainFrm::eventFilter( TQObject * /*obj*/, TQEvent *e )
1166 {
1167  if ( e->type() == TQEvent::Resize && m_mdiMode == KMdi::ToplevelMode )
1168  {
1169  verifyToplevelHeight();
1170  return false; //let the rest of the resize magic do its work
1171  }
1172 
1173  if ( e->type() == TQEvent::FocusIn )
1174  {
1175  TQFocusEvent * pFE = ( TQFocusEvent* ) e;
1176  if ( pFE->reason() == TQFocusEvent::ActiveWindow )
1177  {
1178  if ( m_pCurrentWindow && !m_pCurrentWindow->isHidden() &&
1179  !m_pCurrentWindow->isAttached() && m_pMdi->topChild() )
1180  {
1181  return true; // eat the event
1182  }
1183  }
1184  if ( m_pMdi )
1185  {
1186  static bool focusTCIsPending = false;
1187  if ( !focusTCIsPending && m_mdiMode == KMdi::ChildframeMode )
1188  {
1189  focusTCIsPending = true;
1190  m_pMdi->focusTopChild();
1191  focusTCIsPending = false;
1192  }
1193  }
1194  }
1195  else if ( e->type() == TQEvent::KeyRelease )
1196  {
1197  if ( switching() )
1198  {
1199  TDEAction * a = actionCollection() ->action( "view_last_window" ) ;
1200  if ( a )
1201  {
1202  const TDEShortcut cut( a->shortcut() );
1203  const KKeySequence& seq = cut.seq( 0 );
1204  const KKey& key = seq.key( 0 );
1205  int modFlags = key.modFlags();
1206  int state = ( ( TQKeyEvent * ) e ) ->state();
1207  KKey key2( ( TQKeyEvent * ) e );
1208 
1213  if ( state != ( ( TQKeyEvent * ) e ) ->stateAfter() &&
1214  ( ( modFlags & KKey::CTRL ) > 0 ) == ( ( state & TQt::ControlButton ) > 0 ) &&
1215  ( ( modFlags & KKey::ALT ) > 0 ) == ( ( state & TQt::AltButton ) > 0 ) &&
1216  ( ( modFlags & KKey::WIN ) > 0 ) == ( ( state & TQt::MetaButton ) > 0 ) )
1217  {
1218  activeWindow() ->updateTimeStamp();
1219  setSwitching( false );
1220  }
1221  return true;
1222  }
1223  else
1224  {
1225  kdDebug(760) << "TDEAction( \"view_last_window\") not found." << endl;
1226  }
1227  }
1228  }
1229  return false; // standard event processing
1230 }
1231 
1235 void KMdiMainFrm::closeAllViews()
1236 {
1237  //save the children first to a list, as removing invalidates our iterator
1238  TQValueList<KMdiChildView*> children;
1239  for ( KMdiChildView * w = m_pDocumentViews->first();w;w = m_pDocumentViews->next() )
1240  {
1241  children.append( w );
1242  }
1243  TQValueListIterator<KMdiChildView *> childIt;
1244  for ( childIt = children.begin(); childIt != children.end(); ++childIt )
1245  {
1246  ( *childIt )->close();
1247  }
1248 }
1249 
1250 
1254 void KMdiMainFrm::iconifyAllViews()
1255 {
1256  kdDebug(760) << k_funcinfo << "minimizing all the views" << endl;
1257  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
1258  for ( ; ( *it ); ++it )
1259  ( *it )->minimize();
1260 }
1261 
1265 void KMdiMainFrm::closeActiveView()
1266 {
1267  kdDebug(760) << k_funcinfo << "closing the active view" << endl;
1268  if ( m_pCurrentWindow )
1269  m_pCurrentWindow->close();
1270 }
1271 
1273 void KMdiMainFrm::findRootDockWidgets( TQPtrList<KDockWidget>* rootDockWidgetList, TQValueList<TQRect>* positionList )
1274 {
1275  //nothing is valid
1276  if ( !rootDockWidgetList && !positionList )
1277  return ;
1278 
1279  // since we set some windows to toplevel, we must consider the window manager's window frame
1280  const int frameBorderWidth = 7; // @todo: Can we / do we need to ask the window manager?
1281  const int windowTitleHeight = 10; // @todo: -"-
1282 
1283  TQObjectList* pObjList = queryList( "KDockWidget" );
1284  if ( pObjList->isEmpty() )
1285  pObjList = queryList( "KDockWidget_Compat::KDockWidget" );
1286 
1287  TQObjectListIt it( *pObjList );
1288  // for all dockwidgets (which are children of this mainwindow)
1289  while ( ( *it ) )
1290  {
1291  KDockWidget* dockWindow = 0L; /* pDockW */
1292  KDockWidget* rootDockWindow = 0L; /* pRootDockWindow */
1293  KDockWidget* undockCandidate = 0L; /* pUndockCandidate */
1294  TQWidget* pW = TQT_TQWIDGET( ( *it ) );
1295 
1296  // find the oldest ancestor of the current dockwidget that can be undocked
1297  while ( !pW->isTopLevel() )
1298  {
1299  if ( ::tqqt_cast<KDockWidget*>( pW ) || pW->inherits( "KDockWidget_Compat::KDockWidget" ) )
1300  {
1301  undockCandidate = static_cast<KDockWidget*>( pW );
1302  if ( undockCandidate->enableDocking() != KDockWidget::DockNone )
1303  rootDockWindow = undockCandidate;
1304  }
1305  pW = pW->parentWidget();
1306  }
1307 
1308  if ( rootDockWindow )
1309  {
1310  // if that oldest ancestor is not already in the list, append it
1311  bool found = false;
1312  if ( !rootDockWidgetList->isEmpty() )
1313  {
1314  TQPtrListIterator<KDockWidget> it2( *rootDockWidgetList );
1315  for ( ; it2.current() && !found; ++it2 )
1316  {
1317  dockWindow = it2.current();
1318  if ( dockWindow == rootDockWindow )
1319  found = true;
1320  }
1321  }
1322 
1323  if ( !found || rootDockWidgetList->isEmpty() )
1324  {
1325  rootDockWidgetList->append( dockWindow );
1326  kdDebug(760) << k_funcinfo << "Appending " << rootDockWindow << " to our list of " <<
1327  "root dock windows" << endl;
1328  TQPoint p = rootDockWindow->mapToGlobal( rootDockWindow->pos() ) - rootDockWindow->pos();
1329  TQRect r( p.x(), p.y() + m_undockPositioningOffset.y(),
1330  rootDockWindow->width() - windowTitleHeight - frameBorderWidth * 2,
1331  rootDockWindow->height() - windowTitleHeight - frameBorderWidth * 2 );
1332  positionList->append( r );
1333  }
1334  }
1335  ++it;
1336  }
1337  delete pObjList;
1338 }
1339 
1343 void KMdiMainFrm::switchToToplevelMode()
1344 {
1345  if ( m_mdiMode == KMdi::ToplevelMode )
1346  {
1347  emit mdiModeHasBeenChangedTo( KMdi::ToplevelMode );
1348  return ;
1349  }
1350 
1351  KMdi::MdiMode oldMdiMode = m_mdiMode;
1352 
1353  const int frameBorderWidth = 7; // @todo: Can we / do we need to ask the window manager?
1354  setUndockPositioningOffset( TQPoint( 0, ( m_pTaskBar ? m_pTaskBar->height() : 0 ) + frameBorderWidth ) );
1355 
1356  // 1.) select the dockwidgets to be undocked and store their geometry
1357  TQPtrList<KDockWidget> rootDockWidgetList;
1358  TQValueList<TQRect> positionList;
1359 
1360  // 2.) undock the MDI views of KMDI
1361  switch( oldMdiMode )
1362  {
1363  case KMdi::ChildframeMode:
1364  finishChildframeMode();
1365  break;
1366  case KMdi::TabPageMode:
1367  finishTabPageMode();
1368  break;
1369  case KMdi::IDEAlMode:
1370  finishIDEAlMode();
1371  findRootDockWidgets( &rootDockWidgetList, &positionList );
1372  break;
1373  default:
1374  break; //do nothing
1375  }
1376 
1377  // 3.) undock all these found oldest ancestors (being KDockWidgets)
1378  TQPtrListIterator<KDockWidget> kdwit( rootDockWidgetList );
1379  for ( ; ( *kdwit ); ++kdwit )
1380  ( *kdwit )->undock();
1381 
1382  // 4.) recreate the MDI childframe area and hide it
1383  if ( oldMdiMode == KMdi::TabPageMode || oldMdiMode == KMdi::IDEAlMode )
1384  {
1385  if ( !m_pDockbaseAreaOfDocumentViews )
1386  {
1387  m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", TQPixmap(), 0L, "mdi_area_cover" );
1388  m_pDockbaseAreaOfDocumentViews->setDockWindowTransient( this, true );
1389  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
1390  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
1391  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
1392  }
1393  // set this dock to main view
1394  setView( m_pDockbaseAreaOfDocumentViews );
1395  setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
1396  }
1397  // TQApplication::sendPostedEvents(); //why do we need to empty the event queue?
1398  if ( !parentWidget() )
1399  {
1400  //if we don't have a parent widget ( which i expect we wouldn't )
1401  //make sure we take into account the size of the docks provided by
1402  //QMainWindow
1403  int topDockHeight = topDock() ? topDock()->height() : 0;
1404  int bottomDockHeight = bottomDock() ? bottomDock()->height() : 0;
1405  int menuBarHeight = hasMenuBar() ? menuBar()->height() : 0;
1406  if ( m_pDocumentViews->count() != 0 )
1407  setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height() );
1408  else
1409  {
1410  kdDebug(760) << k_funcinfo << "height is: " << height() << endl;
1411  kdDebug(760) << k_funcinfo << "top dock height: " << topDockHeight << endl;
1412  kdDebug(760) << k_funcinfo << "bottom dock height: " << bottomDockHeight << endl;
1413  kdDebug(760) << k_funcinfo << "menu bar height: " << menuBarHeight << endl;
1414  kdDebug(760) << k_funcinfo << "dock base area height: " << m_pDockbaseAreaOfDocumentViews->height() << endl;
1415  setFixedHeight( topDockHeight + menuBarHeight );
1416  }
1417  }
1418 
1419  //FIXME although i don't know what to fix
1420  // 5. show the child views again
1421  TQPtrListIterator<KMdiChildView> tdemdicvit( *m_pDocumentViews );
1422  for ( tdemdicvit.toFirst(); ( *tdemdicvit ); ++tdemdicvit )
1423  {
1424 #ifdef Q_WS_X11
1425  XSetTransientForHint( tqt_xdisplay(), ( *tdemdicvit )->winId(), winId() );
1426 #endif
1427  ( *tdemdicvit )->show();
1428  }
1429 
1430  // 6.) reset all memorized positions of the undocked ones and show them again
1431  TQValueList<TQRect>::Iterator qvlqrit;
1432  TQValueList<TQRect>::Iterator qvlEnd = positionList.end();
1433  for ( tdemdicvit.toFirst(), qvlqrit = positionList.begin() ; ( *tdemdicvit ) && qvlqrit != qvlEnd; ++tdemdicvit, ++qvlqrit )
1434  {
1435  ( *tdemdicvit )->setGeometry( ( *qvlqrit ) );
1436  ( *tdemdicvit )->show();
1437  }
1438 
1439  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockNone );
1440  m_mdiMode = KMdi::ToplevelMode;
1441 
1442  kdDebug(760) << k_funcinfo << "Switch to toplevel mode completed" << endl;
1443  emit mdiModeHasBeenChangedTo( KMdi::ToplevelMode );
1444 
1445 }
1446 
1447 void KMdiMainFrm::finishToplevelMode()
1448 {
1449  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
1450 }
1451 
1455 void KMdiMainFrm::switchToChildframeMode()
1456 {
1457  if ( m_mdiMode == KMdi::ChildframeMode )
1458  {
1459  emit mdiModeHasBeenChangedTo( KMdi::ChildframeMode );
1460  return ;
1461  }
1462 
1463  TQPtrList<KDockWidget> rootDockWidgetList;
1464  TQValueList<TQRect> positionList;
1465 
1466  if ( m_mdiMode == KMdi::TabPageMode )
1467  {
1468  kdDebug(760) << k_funcinfo << "finishing tab page mode" << endl;
1469  // select the dockwidgets to be undocked and store their geometry
1470  findRootDockWidgets( &rootDockWidgetList, &positionList );
1471  kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
1472 
1473  // undock all these found oldest ancestors (being KDockWidgets)
1474  TQPtrListIterator<KDockWidget> it( rootDockWidgetList );
1475  for ( ; ( *it ) ; ++it )
1476  ( *it )->undock();
1477 
1478  finishTabPageMode();
1479  }
1480  else if ( m_mdiMode == KMdi::ToplevelMode )
1481  {
1482  finishToplevelMode();
1483  }
1484  else if ( m_mdiMode == KMdi::IDEAlMode )
1485  {
1486  kdDebug(760) << k_funcinfo << "finishing ideal mode" << endl;
1487  finishIDEAlMode( false );
1488 
1489  // select the dockwidgets to be undocked and store their geometry
1490  findRootDockWidgets( &rootDockWidgetList, &positionList );
1491  kdDebug(760) << k_funcinfo << "Found " << rootDockWidgetList.count() << " widgets to undock" << endl;
1492 
1493  // undock all these found oldest ancestors (being KDockWidgets)
1494  TQPtrListIterator<KDockWidget> it( rootDockWidgetList );
1495  for ( ; ( *it ) ; ++it )
1496  ( *it )->undock();
1497 
1498  m_mdiMode = KMdi::TabPageMode;
1499  finishTabPageMode();
1500  m_mdiMode = KMdi::IDEAlMode;
1501  }
1502 
1503  if ( !m_pDockbaseAreaOfDocumentViews )
1504  {
1505  // cover KMdi's childarea by a dockwidget
1506  m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", TQPixmap(), 0L, "mdi_area_cover" );
1507  m_pDockbaseAreaOfDocumentViews->setDockWindowTransient( this, true );
1508  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
1509  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
1510  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi );
1511  kdDebug(760) << k_funcinfo << "childarea is now covered by a dockwidget" << endl;
1512  }
1513 
1514  if ( m_pDockbaseAreaOfDocumentViews->isTopLevel() )
1515  {
1516  // set this dock to main view
1517  setView( m_pDockbaseAreaOfDocumentViews );
1518  setMainDockWidget( m_pDockbaseAreaOfDocumentViews );
1519  m_pDockbaseAreaOfDocumentViews->setEnableDocking( KDockWidget::DockNone );
1520  m_pDockbaseAreaOfDocumentViews->setDockSite( KDockWidget::DockCorner );
1521  kdDebug(760) << k_funcinfo << "Dock base area has been set to the main view" << endl;
1522  }
1523  m_pDockbaseAreaOfDocumentViews->setWidget( m_pMdi ); //JW
1524  m_pDockbaseAreaOfDocumentViews->show();
1525 
1526  if ( ( m_mdiMode == KMdi::TabPageMode ) || ( m_mdiMode == KMdi::IDEAlMode ) )
1527  {
1528  kdDebug(760) << k_funcinfo << "trying to dock back the undock toolviews" << endl;
1529  TQPtrListIterator<KDockWidget> it( rootDockWidgetList );
1530  for ( ; ( *it ); ++it )
1531  ( *it )->dockBack();
1532  }
1533 
1534  if ( m_mdiMode == KMdi::ToplevelMode && m_pTempDockSession )
1535  {
1536  // restore the old dock scenario which we memorized at the time we switched to toplevel mode
1537  kdDebug(760) << k_funcinfo << "Restoring old dock scenario memorized from toplevel mode" << endl;
1538  TQDomElement oldDockState = m_pTempDockSession->namedItem( "cur_dock_state" ).toElement();
1539  readDockConfig( oldDockState );
1540  }
1541 
1542  KMdi::MdiMode oldMdiMode = m_mdiMode;
1543  m_mdiMode = KMdi::ChildframeMode;
1544 
1545  //FIXME although i don't know what to fix.
1546  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
1547  for ( ; ( *it ); ++it )
1548  {
1549  KMdiChildView* pView = ( *it );
1550  if ( !pView->isToolView() && pView->isAttached() )
1551  attachWindow( pView, true );
1552  }
1553  for ( it.toFirst(); ( *it ); ++it )
1554  {
1555  KMdiChildView* pView = ( *it );
1556  if ( !pView->isToolView() )
1557  pView->show();
1558  }
1559  if ( ( oldMdiMode == KMdi::ToplevelMode ) && !parentWidget() )
1560  {
1561  setMinimumHeight( m_oldMainFrmMinHeight );
1562  setMaximumHeight( m_oldMainFrmMaxHeight );
1563  resize( width(), m_oldMainFrmHeight );
1564  m_oldMainFrmHeight = 0;
1565  kdDebug(760) << k_funcinfo << "left top level mode completely" << endl;
1566  emit leftTopLevelMode();
1567  }
1568  emit mdiModeHasBeenChangedTo( KMdi::ChildframeMode );
1569 }
1570 
1571 void KMdiMainFrm::finishChildframeMode()
1572 {
1573  // save the old dock scenario of the dockwidget-like tool views to a DOM tree
1574  kdDebug(760) << k_funcinfo << "saving the current dock scenario" << endl;
1575  delete m_pTempDockSession;
1576  m_pTempDockSession = new TQDomDocument( "docksession" );
1577  TQDomElement curDockState = m_pTempDockSession->createElement( "cur_dock_state" );
1578  m_pTempDockSession->appendChild( curDockState );
1579  writeDockConfig( curDockState );
1580 
1581  // detach all non-tool-views to toplevel
1582  kdDebug(760) << k_funcinfo << "detaching all document views and moving them to toplevel" << endl;
1583  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
1584  for ( ; ( *it ); ++it )
1585  {
1586  KMdiChildView* pView = ( *it );
1587  if ( pView->isToolView() )
1588  continue;
1589  if ( pView->isAttached() )
1590  {
1591  if ( pView->isMaximized() )
1592  pView->mdiParent()->setGeometry( 0, 0, m_pMdi->width(), m_pMdi->height() );
1593  detachWindow( pView, false );
1594  }
1595  }
1596 }
1597 
1601 void KMdiMainFrm::switchToTabPageMode()
1602 {
1603  if ( m_mdiMode == KMdi::TabPageMode )
1604  {
1605  emit mdiModeHasBeenChangedTo( KMdi::TabPageMode );
1606  return ; // nothing need to be done
1607  }
1608 
1609  switch( m_mdiMode )
1610  {
1611  case KMdi::ChildframeMode:
1612  finishChildframeMode();
1613  break;
1614  case KMdi::ToplevelMode:
1615  finishToplevelMode();
1616  break;
1617  case KMdi::IDEAlMode:
1618  finishIDEAlMode( false );
1619  emit mdiModeHasBeenChangedTo( KMdi::TabPageMode );
1620  m_mdiMode = KMdi::TabPageMode;
1621  return;
1622  break;
1623  default:
1624  break;
1625  }
1626 
1627  setupTabbedDocumentViewSpace();
1628  m_mdiMode = KMdi::TabPageMode;
1629  if ( m_pCurrentWindow )
1630  m_pCurrentWindow->setFocus();
1631 
1632  m_pTaskBar->switchOn( false );
1633 
1634  if ( m_pClose )
1635  {
1636  TQObject::connect( m_pClose, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeViewButtonPressed() ) );
1637  if ( m_pDocumentViews->count() > 0 )
1638  m_pClose->show();
1639  }
1640  else
1641  kdDebug(760) << "close button nonexistant. strange things might happen" << endl;
1642 
1643  kdDebug(760) << "Switch to tab page mode complete" << endl;
1644  emit mdiModeHasBeenChangedTo( KMdi::TabPageMode );
1645 }
1646 
1647 void KMdiMainFrm::finishTabPageMode()
1648 {
1649  // if tabified, release all views from their docking covers
1650  if ( m_mdiMode == KMdi::TabPageMode )
1651  {
1652  m_pClose->hide();
1653  TQObject::disconnect( m_pClose, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeViewButtonPressed() ) );
1654 
1655  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
1656  for ( ; it.current(); ++it )
1657  {
1658  KMdiChildView* pView = it.current();
1659  if ( pView->isToolView() )
1660  continue;
1661  kdDebug(760) << "KMdiMainFrm::finishTabPageMode: in loop" << endl;
1662  TQSize mins = pView->minimumSize();
1663  TQSize maxs = pView->maximumSize();
1664  TQSize sz = pView->size();
1665  TQWidget* pParent = pView->parentWidget();
1666  TQPoint p( pParent->mapToGlobal( pParent->pos() ) - pParent->pos() + m_undockPositioningOffset );
1667  m_documentTabWidget->removePage( pView );
1668  pView->reparent( 0, 0, p );
1669  // pView->reparent(0,0,p);
1670  pView->resize( sz );
1671  pView->setMinimumSize( mins.width(), mins.height() );
1672  pView->setMaximumSize( maxs.width(), maxs.height() );
1673  // ((KDockWidget*)pParent)->undock(); // this destroys the dockwiget cover, too
1674  // pParent->close();
1675  // delete pParent;
1676  // if (centralWidget() == pParent) {
1677  // setCentralWidget(0L); // avoid dangling pointer
1678  // }
1679  }
1680  delete m_documentTabWidget;
1681  m_documentTabWidget = 0;
1682  m_pTaskBar->switchOn( true );
1683  }
1684 }
1685 
1686 
1687 
1688 void KMdiMainFrm::setupTabbedDocumentViewSpace()
1689 {
1690  // resize to childframe mode size of the mainwindow if we were in toplevel mode
1691  if ( ( m_mdiMode == KMdi::ToplevelMode ) && !parentWidget() )
1692  {
1693  setMinimumHeight( m_oldMainFrmMinHeight );
1694  setMaximumHeight( m_oldMainFrmMaxHeight );
1695  resize( width(), m_oldMainFrmHeight );
1696  m_oldMainFrmHeight = 0;
1697  //tqDebug("TopLevelMode off");
1698  emit leftTopLevelMode();
1699  TQApplication::sendPostedEvents();
1700 
1701  // restore the old dock szenario which we memorized at the time we switched to toplevel mode
1702  if ( m_pTempDockSession )
1703  {
1704  TQDomElement oldDockState = m_pTempDockSession->namedItem( "cur_dock_state" ).toElement();
1705  readDockConfig( oldDockState );
1706  }
1707  }
1708 
1709 #if 0
1710  if ( m_pDockbaseOfTabPage != m_pDockbaseAreaOfDocumentViews )
1711  {
1712  delete m_pDockbaseOfTabPage;
1713  m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
1714  }
1715 #endif
1716  delete m_documentTabWidget;
1717  m_documentTabWidget = new KMdiDocumentViewTabWidget( m_pDockbaseAreaOfDocumentViews );
1718  connect( m_documentTabWidget, TQT_SIGNAL( currentChanged( TQWidget* ) ), this, TQT_SLOT( slotDocCurrentChanged( TQWidget* ) ) );
1719  m_pDockbaseAreaOfDocumentViews->setWidget( m_documentTabWidget );
1720  m_documentTabWidget->show();
1721  TQPtrListIterator<KMdiChildView> it4( *m_pDocumentViews );
1722  for ( ; it4.current(); ++it4 )
1723  {
1724  KMdiChildView* pView = it4.current();
1725  m_documentTabWidget->addTab( pView, pView->icon() ? *( pView->icon() ) : TQPixmap(), pView->tabCaption() );
1726  /*
1727  connect(pView,TQT_SIGNAL(iconOrCaptionUdpated(TQWidget*,TQPixmap,const TQString&)),
1728  m_documentTabWidget,TQT_SLOT(updateView(TQWidget*,TQPixmap,const TQString&)));
1729  */
1730  connect( pView, TQT_SIGNAL( iconUpdated( TQWidget*, TQPixmap ) ), m_documentTabWidget, TQT_SLOT( updateIconInView( TQWidget*, TQPixmap ) ) );
1731  connect( pView, TQT_SIGNAL( captionUpdated( TQWidget*, const TQString& ) ), m_documentTabWidget, TQT_SLOT( updateCaptionInView( TQWidget*, const TQString& ) ) );
1732 
1733  }
1734 }
1735 
1736 
1737 void KMdiMainFrm::setIDEAlModeStyle( int flags )
1738 {
1739  d->m_styleIDEAlMode = flags; // see KMultiTabBar for the first 3 bits
1740  if ( m_leftContainer )
1741  {
1742  KMdiDockContainer * tmpL = ::tqqt_cast<KMdiDockContainer*>( m_leftContainer->getWidget() );
1743  if ( tmpL )
1744  tmpL->setStyle( flags );
1745  }
1746 
1747  if ( m_rightContainer )
1748  {
1749  KMdiDockContainer * tmpR = ::tqqt_cast<KMdiDockContainer*>( m_rightContainer->getWidget() );
1750  if ( tmpR )
1751  tmpR->setStyle( flags );
1752  }
1753 
1754  if ( m_topContainer )
1755  {
1756  KMdiDockContainer * tmpT = ::tqqt_cast<KMdiDockContainer*>( m_topContainer->getWidget() );
1757  if ( tmpT )
1758  tmpT->setStyle( flags );
1759  }
1760 
1761  if ( m_bottomContainer )
1762  {
1763  KMdiDockContainer * tmpB = ::tqqt_cast<KMdiDockContainer*>( m_bottomContainer->getWidget() );
1764  if ( tmpB )
1765  tmpB->setStyle( flags );
1766  }
1767 }
1768 
1769 void KMdiMainFrm::setToolviewStyle( int flag )
1770 {
1771  if ( m_mdiMode == KMdi::IDEAlMode )
1772  {
1773  setIDEAlModeStyle( flag );
1774  }
1775  d->m_toolviewStyle = flag;
1776  bool toolviewExists = false;
1777  TQMap<TQWidget*, KMdiToolViewAccessor*>::Iterator it;
1778  for ( it = m_pToolViews->begin(); it != m_pToolViews->end(); ++it )
1779  {
1780  KDockWidget *dockWidget = tqt_dynamic_cast<KDockWidget*>( it.data()->wrapperWidget() );
1781  if ( dockWidget )
1782  {
1783  switch ( flag )
1784  {
1785  case KMdi::IconOnly:
1786  dockWidget->setTabPageLabel( TQString::null );
1787  dockWidget->setPixmap( *( it.data()->wrappedWidget()->icon() ) );
1788  break;
1789  case KMdi::TextOnly:
1790  dockWidget->setPixmap(); //FIXME: Does not hide the icon in the IDEAl mode.
1791  dockWidget->setTabPageLabel( it.data()->wrappedWidget()->caption() );
1792  break;
1793  case KMdi::TextAndIcon:
1794  dockWidget->setPixmap( *( it.data()->wrappedWidget()->icon() ) );
1795  dockWidget->setTabPageLabel( it.data()->wrappedWidget()->caption() );
1796  default:
1797  break;
1798  }
1799  toolviewExists = true;
1800  }
1801  }
1802 
1803  if ( toolviewExists )
1804  {
1805  //workaround for the above FIXME to make switching to TextOnly mode work in IDEAl as well. Be sure that this version of switch* is called.
1806  if ( m_mdiMode == KMdi::IDEAlMode && flag == KMdi::TextOnly )
1807  {
1808  KMdiMainFrm::switchToTabPageMode();
1809  KMdiMainFrm::switchToIDEAlMode();
1810  }
1811  else
1812  {
1813  writeDockConfig();
1814  readDockConfig();
1815  }
1816  }
1817 }
1818 
1822 void KMdiMainFrm::switchToIDEAlMode()
1823 {
1824  kdDebug(760) << k_funcinfo << "switching to IDEAl mode" << endl;
1825 
1826  if ( m_mdiMode == KMdi::IDEAlMode )
1827  {
1828  emit mdiModeHasBeenChangedTo( KMdi::IDEAlMode );
1829  return ; // nothing need to be done
1830  }
1831 
1832  switch( m_mdiMode )
1833  {
1834  case KMdi::ChildframeMode:
1835  finishChildframeMode();
1836  break;
1837  case KMdi::ToplevelMode:
1838  finishToplevelMode();
1839  break;
1840  case KMdi::TabPageMode:
1841  m_mdiMode = KMdi::IDEAlMode;
1842  setupToolViewsForIDEALMode();
1843  emit mdiModeHasBeenChangedTo( KMdi::IDEAlMode );
1844  return;
1845  break;
1846  default:
1847  break;
1848  }
1849 
1850  setupTabbedDocumentViewSpace();
1851  m_mdiMode = KMdi::IDEAlMode;
1852  setupToolViewsForIDEALMode();
1853 
1854  if ( m_pCurrentWindow )
1855  m_pCurrentWindow->setFocus();
1856 
1857  m_pTaskBar->switchOn( false );
1858 
1859  if ( m_pClose )
1860  {
1861  TQObject::connect( m_pClose, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeViewButtonPressed() ) );
1862  if ( m_pDocumentViews->count() > 0 )
1863  m_pClose->show();
1864  }
1865  else
1866  kdWarning(760) << k_funcinfo << "close button pointer does not exist!" << endl;
1867 
1868  kdDebug(760) << k_funcinfo << "switch to IDEAl mode complete" << endl;
1869 
1870  emit mdiModeHasBeenChangedTo( KMdi::IDEAlMode );
1871 }
1872 
1873 
1874 void KMdiMainFrm::dockToolViewsIntoContainers( TQPtrList<KDockWidget>& widgetsToReparent, KDockWidget *container )
1875 {
1876  TQPtrListIterator<KDockWidget> it( widgetsToReparent );
1877  for ( ; ( *it ); ++it )
1878  {
1879  ( *it )->manualDock( container, KDockWidget::DockCenter, 20 );
1880  ( *it )->loseFormerBrotherDockWidget();
1881  }
1882 }
1883 
1884 void KMdiMainFrm::findToolViewsDockedToMain( TQPtrList<KDockWidget>* list, KDockWidget::DockPosition dprtmw )
1885 {
1886  KDockWidget* mainDock = getMainDockWidget();
1887  if ( mainDock->parentDockTabGroup() )
1888  {
1889  mainDock = tqt_dynamic_cast<KDockWidget*>( mainDock->parentDockTabGroup()->parent() );
1890  // FIXME: will likely crash below due to unchecked cast
1891  }
1892 
1893  if ( !mainDock )
1894  {
1895  kdDebug(760) << k_funcinfo << "mainDock invalid. No main dock widget found." << endl;
1896  return;
1897  }
1898 
1899  KDockWidget* widget = mainDock->findNearestDockWidget( dprtmw );
1900  if ( widget && widget->parentDockTabGroup() )
1901  {
1902  widget = static_cast<KDockWidget*>( TQT_TQWIDGET(widget->parentDockTabGroup() ->parent()) );
1903 
1904  if ( widget )
1905  {
1906  KDockTabGroup* tg = tqt_dynamic_cast<KDockTabGroup*>( widget->getWidget() );
1907  if ( tg )
1908  {
1909  kdDebug(760) << k_funcinfo << "KDockTabGroup found" << endl;
1910  for ( int i = 0;i < tg->count();i++ )
1911  list->append( static_cast<KDockWidget*>( tg->page( i ) ) );
1912  }
1913  else
1914  list->append( widget );
1915  }
1916  else
1917  kdDebug(760) << k_funcinfo << "no widget found" << endl;
1918  }
1919  else
1920  kdDebug(760) << "No main dock widget found" << endl;
1921 }
1922 
1923 
1924 void KMdiMainFrm::setupToolViewsForIDEALMode()
1925 {
1926  m_leftContainer = createDockWidget( "KMdiDock::leftDock", SmallIcon( "misc" ), 0L, "Left Dock" );
1927  m_rightContainer = createDockWidget( "KMdiDock::rightDock", SmallIcon( "misc" ), 0L, "Right Dock" );
1928  m_topContainer = createDockWidget( "KMdiDock::topDock", SmallIcon( "misc" ), 0L, "Top Dock" );
1929  m_bottomContainer = createDockWidget( "KMdiDock::bottomDock", SmallIcon( "misc" ), 0L, "Bottom Dock" );
1930 
1931  KDockWidget *mainDock = getMainDockWidget();
1932  KDockWidget *w = mainDock;
1933  if ( mainDock->parentDockTabGroup() )
1934  w = static_cast<KDockWidget*>( TQT_TQWIDGET(mainDock->parentDockTabGroup()->parent()) );
1935 
1936  TQPtrList<KDockWidget> leftReparentWidgets;
1937  TQPtrList<KDockWidget> rightReparentWidgets;
1938  TQPtrList<KDockWidget> bottomReparentWidgets;
1939  TQPtrList<KDockWidget> topReparentWidgets;
1940 
1941  if ( mainDock->parentDockTabGroup() )
1942  mainDock = static_cast<KDockWidget*>( TQT_TQWIDGET(mainDock->parentDockTabGroup() ->parent()) );
1943 
1944  findToolViewsDockedToMain( &leftReparentWidgets, KDockWidget::DockLeft );
1945  findToolViewsDockedToMain( &rightReparentWidgets, KDockWidget::DockRight );
1946  findToolViewsDockedToMain( &bottomReparentWidgets, KDockWidget::DockBottom );
1947  findToolViewsDockedToMain( &topReparentWidgets, KDockWidget::DockTop );
1948 
1949  mainDock->setEnableDocking( KDockWidget::DockNone ); //::DockCorner);
1950  mainDock->setDockSite( KDockWidget::DockCorner );
1951 
1952 
1953  KMdiDockContainer *tmpDC;
1954  m_leftContainer->setWidget( tmpDC = new KMdiDockContainer( m_leftContainer, this, KDockWidget::DockLeft, d->m_styleIDEAlMode ) );
1955  m_leftContainer->setEnableDocking( KDockWidget::DockLeft );
1956  m_leftContainer->manualDock( mainDock, KDockWidget::DockLeft, 20 );
1957  tmpDC->init();
1958  if ( m_mdiGUIClient )
1959  connect ( this, TQT_SIGNAL( toggleLeft() ), tmpDC, TQT_SLOT( toggle() ) );
1960  connect( this, TQT_SIGNAL( collapseOverlapContainers() ), tmpDC, TQT_SLOT( collapseOverlapped() ) );
1961  connect( tmpDC, TQT_SIGNAL( activated( KMdiDockContainer* ) ), this, TQT_SLOT( setActiveToolDock( KMdiDockContainer* ) ) );
1962  connect( tmpDC, TQT_SIGNAL( deactivated( KMdiDockContainer* ) ), this, TQT_SLOT( removeFromActiveDockList( KMdiDockContainer* ) ) );
1963 
1964  m_rightContainer->setWidget( tmpDC = new KMdiDockContainer( m_rightContainer, this, KDockWidget::DockRight, d->m_styleIDEAlMode ) );
1965  m_rightContainer->setEnableDocking( KDockWidget::DockRight );
1966  m_rightContainer->manualDock( mainDock, KDockWidget::DockRight, 80 );
1967  tmpDC->init();
1968  if ( m_mdiGUIClient )
1969  connect ( this, TQT_SIGNAL( toggleRight() ), tmpDC, TQT_SLOT( toggle() ) );
1970  connect( this, TQT_SIGNAL( collapseOverlapContainers() ), tmpDC, TQT_SLOT( collapseOverlapped() ) );
1971  connect( tmpDC, TQT_SIGNAL( activated( KMdiDockContainer* ) ), this, TQT_SLOT( setActiveToolDock( KMdiDockContainer* ) ) );
1972  connect( tmpDC, TQT_SIGNAL( deactivated( KMdiDockContainer* ) ), this, TQT_SLOT( removeFromActiveDockList( KMdiDockContainer* ) ) );
1973 
1974  m_topContainer->setWidget( tmpDC = new KMdiDockContainer( m_topContainer, this, KDockWidget::DockTop, d->m_styleIDEAlMode ) );
1975  m_topContainer->setEnableDocking( KDockWidget::DockTop );
1976  m_topContainer->manualDock( mainDock, KDockWidget::DockTop, 20 );
1977  tmpDC->init();
1978  if ( m_mdiGUIClient )
1979  connect ( this, TQT_SIGNAL( toggleTop() ), tmpDC, TQT_SLOT( toggle() ) );
1980  connect( this, TQT_SIGNAL( collapseOverlapContainers() ), tmpDC, TQT_SLOT( collapseOverlapped() ) );
1981  connect( tmpDC, TQT_SIGNAL( activated( KMdiDockContainer* ) ), this, TQT_SLOT( setActiveToolDock( KMdiDockContainer* ) ) );
1982  connect( tmpDC, TQT_SIGNAL( deactivated( KMdiDockContainer* ) ), this, TQT_SLOT( removeFromActiveDockList( KMdiDockContainer* ) ) );
1983 
1984  m_bottomContainer->setWidget( tmpDC = new KMdiDockContainer( m_bottomContainer, this, KDockWidget::DockBottom, d->m_styleIDEAlMode ) );
1985  m_bottomContainer->setEnableDocking( KDockWidget::DockBottom );
1986  m_bottomContainer->manualDock( mainDock, KDockWidget::DockBottom, 80 );
1987  tmpDC->init();
1988  if ( m_mdiGUIClient )
1989  connect ( this, TQT_SIGNAL( toggleBottom() ), tmpDC, TQT_SLOT( toggle() ) );
1990  connect( this, TQT_SIGNAL( collapseOverlapContainers() ), tmpDC, TQT_SLOT( collapseOverlapped() ) );
1991  connect( tmpDC, TQT_SIGNAL( activated( KMdiDockContainer* ) ), this, TQT_SLOT( setActiveToolDock( KMdiDockContainer* ) ) );
1992  connect( tmpDC, TQT_SIGNAL( deactivated( KMdiDockContainer* ) ), this, TQT_SLOT( removeFromActiveDockList( KMdiDockContainer* ) ) );
1993 
1994  m_leftContainer->setDockSite( KDockWidget::DockCenter );
1995  m_rightContainer->setDockSite( KDockWidget::DockCenter );
1996  m_topContainer->setDockSite( KDockWidget::DockCenter );
1997  m_bottomContainer->setDockSite( KDockWidget::DockCenter );
1998 
1999  dockToolViewsIntoContainers( leftReparentWidgets, m_leftContainer );
2000  dockToolViewsIntoContainers( rightReparentWidgets, m_rightContainer );
2001  dockToolViewsIntoContainers( bottomReparentWidgets, m_bottomContainer );
2002  dockToolViewsIntoContainers( topReparentWidgets, m_topContainer );
2003 
2004 
2005  dockManager->setSpecialLeftDockContainer( m_leftContainer );
2006  dockManager->setSpecialRightDockContainer( m_rightContainer );
2007  dockManager->setSpecialTopDockContainer( m_topContainer );
2008  dockManager->setSpecialBottomDockContainer( m_bottomContainer );
2009 
2010 
2011  ( ( KMdiDockContainer* ) ( m_leftContainer->getWidget() ) ) ->hideIfNeeded();
2012  ( ( KMdiDockContainer* ) ( m_rightContainer->getWidget() ) ) ->hideIfNeeded();
2013  ( ( KMdiDockContainer* ) ( m_topContainer->getWidget() ) ) ->hideIfNeeded();
2014  ( ( KMdiDockContainer* ) ( m_bottomContainer->getWidget() ) ) ->hideIfNeeded();
2015 
2016 }
2017 
2018 
2019 
2020 void KMdiMainFrm::finishIDEAlMode( bool full )
2021 {
2022  // if tabified, release all views from their docking covers
2023  if ( m_mdiMode == KMdi::IDEAlMode )
2024  {
2025  assert( m_pClose );
2026  m_pClose->hide();
2027  TQObject::disconnect( m_pClose, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeViewButtonPressed() ) );
2028 
2029 
2030  TQStringList leftNames;
2031  leftNames = prepareIdealToTabs( m_leftContainer );
2032  int leftWidth = m_leftContainer->width();
2033 
2034  TQStringList rightNames;
2035  rightNames = prepareIdealToTabs( m_rightContainer );
2036  int rightWidth = m_rightContainer->width();
2037 
2038  TQStringList topNames;
2039  topNames = prepareIdealToTabs( m_topContainer );
2040  int topHeight = m_topContainer->height();
2041 
2042  TQStringList bottomNames;
2043  bottomNames = prepareIdealToTabs( m_bottomContainer );
2044  int bottomHeight = m_bottomContainer->height();
2045 
2046 
2047  kdDebug(760) << "leftNames" << leftNames << endl;
2048  kdDebug(760) << "rightNames" << rightNames << endl;
2049  kdDebug(760) << "topNames" << topNames << endl;
2050  kdDebug(760) << "bottomNames" << bottomNames << endl;
2051 
2052  delete m_leftContainer;
2053  m_leftContainer = 0;
2054  delete m_rightContainer;
2055  m_rightContainer = 0;
2056  delete m_bottomContainer;
2057  m_bottomContainer = 0;
2058  delete m_topContainer;
2059  m_topContainer = 0;
2060 
2061 
2062  idealToolViewsToStandardTabs( bottomNames, KDockWidget::DockBottom, bottomHeight );
2063  idealToolViewsToStandardTabs( leftNames, KDockWidget::DockLeft, leftWidth );
2064  idealToolViewsToStandardTabs( rightNames, KDockWidget::DockRight, rightWidth );
2065  idealToolViewsToStandardTabs( topNames, KDockWidget::DockTop, topHeight );
2066 
2067  TQApplication::sendPostedEvents();
2068 
2069  if ( !full )
2070  return ;
2071 
2072  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
2073  for ( ; it.current(); ++it )
2074  {
2075  KMdiChildView* pView = it.current();
2076  if ( pView->isToolView() )
2077  continue;
2078  TQSize mins = pView->minimumSize();
2079  TQSize maxs = pView->maximumSize();
2080  TQSize sz = pView->size();
2081  TQWidget* pParent = pView->parentWidget();
2082  TQPoint p( pParent->mapToGlobal( pParent->pos() ) - pParent->pos() + m_undockPositioningOffset );
2083  pView->reparent( 0, 0, p );
2084  pView->reparent( 0, 0, p );
2085  pView->resize( sz );
2086  pView->setMinimumSize( mins.width(), mins.height() );
2087  pView->setMaximumSize( maxs.width(), maxs.height() );
2088  KDockWidget* pDockW = 0L;
2089  // find the oldest ancestor of the current dockwidget that can be undocked
2090  do
2091  {
2092  if ( pParent->inherits( "KDockWidget" ) || pParent->inherits( "KDockWidget_Compat::KDockWidget" ) )
2093  {
2094  pDockW = ( KDockWidget* ) pParent;
2095  pDockW->undock(); // this destroys the dockwiget cover, too
2096  if ( pParent != m_pDockbaseAreaOfDocumentViews )
2097  {
2098  pParent->close();
2099  delete pParent;
2100  }
2101  }
2102  else
2103  {
2104  pParent = pParent->parentWidget();
2105  }
2106  }
2107  while ( pParent && !pDockW );
2108  if ( centralWidget() == pParent )
2109  {
2110  setCentralWidget( 0L ); // avoid dangling pointer
2111  }
2112  }
2113  m_pTaskBar->switchOn( true );
2114 
2115  }
2116 
2117 }
2118 
2119 TQStringList KMdiMainFrm::prepareIdealToTabs( KDockWidget* container )
2120 {
2121  KDockContainer * pDW = tqt_dynamic_cast<KDockContainer*>( container->getWidget() );
2122  TQStringList widgetNames = ( ( KMdiDockContainer* ) pDW ) ->containedWidgets();
2123  for ( TQStringList::iterator it = widgetNames.begin();it != widgetNames.end();++it )
2124  {
2125  KDockWidget* dw = ( KDockWidget* ) manager() ->getDockWidgetFromName( *it );
2126  dw->undock();
2127  dw->setLatestKDockContainer( 0 );
2128  dw->loseFormerBrotherDockWidget();
2129  }
2130  return widgetNames;
2131 }
2132 
2133 void KMdiMainFrm::idealToolViewsToStandardTabs( TQStringList widgetNames, KDockWidget::DockPosition pos, int size )
2134 {
2135  Q_UNUSED( size )
2136 
2137  KDockWidget * mainDock = getMainDockWidget();
2138  if ( mainDock->parentDockTabGroup() )
2139  {
2140  mainDock = static_cast<KDockWidget*>( TQT_TQWIDGET(mainDock->parentDockTabGroup() ->parent()) );
2141  }
2142 
2143  if ( widgetNames.count() > 0 )
2144  {
2145  TQStringList::iterator it = widgetNames.begin();
2146  KDockWidget *dwpd = manager() ->getDockWidgetFromName( *it );
2147  if ( !dwpd )
2148  {
2149  kdDebug(760) << "Fatal error in finishIDEAlMode" << endl;
2150  return ;
2151  }
2152  dwpd->manualDock( mainDock, pos, 20 );
2153  ++it;
2154  for ( ;it != widgetNames.end();++it )
2155  {
2156  KDockWidget *tmpdw = manager() ->getDockWidgetFromName( *it );
2157  if ( !tmpdw )
2158  {
2159  kdDebug(760) << "Fatal error in finishIDEAlMode" << endl;
2160  return ;
2161  }
2162  tmpdw->manualDock( dwpd, KDockWidget::DockCenter, 20 );
2163  }
2164 
2165 #if 0
2166  TQWidget *wid = dwpd->parentDockTabGroup();
2167  if ( !wid )
2168  wid = dwpd;
2169  wid->setGeometry( 0, 0, 20, 20 );
2170  /* wid->resize(
2171  ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?size:wid->width(),
2172  ((pos==KDockWidget::DockLeft) || (pos==KDockWidget::DockRight))?wid->height():size);
2173  */
2174 #endif
2175 
2176  }
2177 
2178 }
2179 
2180 
2188 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar )
2189 {
2190  if ( m_bSDIApplication ) // there are no buttons in the menubar in this mode (although the view is always maximized)
2191  return ;
2192 
2193  m_pMainMenuBar = pMenuBar;
2194  if ( m_pMainMenuBar == 0L )
2195  return ; // use setMenuForSDIModeSysButtons( 0L) for unsetting the external main menu!
2196 
2197  if ( !m_pUndock )
2198  m_pUndock = new TQToolButton( pMenuBar );
2199  if ( !m_pRestore )
2200  m_pRestore = new TQToolButton( pMenuBar );
2201  if ( !m_pMinimize )
2202  m_pMinimize = new TQToolButton( pMenuBar );
2203  if ( !m_pClose )
2204  m_pClose = new TQToolButton( pMenuBar );
2205  m_pUndock->setAutoRaise( false );
2206  m_pMinimize->setAutoRaise( false );
2207  m_pRestore->setAutoRaise( false );
2208  m_pClose->setAutoRaise( false );
2209 
2210  setSysButtonsAtMenuPosition();
2211 
2212  delete m_pUndockButtonPixmap;
2213  delete m_pMinButtonPixmap;
2214  delete m_pRestoreButtonPixmap;
2215  delete m_pCloseButtonPixmap;
2216  // create the decoration pixmaps
2217  if ( frameDecorOfAttachedViews() == KMdi::Win95Look )
2218  {
2219  m_pUndockButtonPixmap = new TQPixmap( win_undockbutton );
2220  m_pMinButtonPixmap = new TQPixmap( win_minbutton );
2221  m_pRestoreButtonPixmap = new TQPixmap( win_restorebutton );
2222  m_pCloseButtonPixmap = new TQPixmap( win_closebutton );
2223  }
2224  else if ( frameDecorOfAttachedViews() == KMdi::KDE1Look )
2225  {
2226  m_pUndockButtonPixmap = new TQPixmap( kde_undockbutton );
2227  m_pMinButtonPixmap = new TQPixmap( kde_minbutton );
2228  m_pRestoreButtonPixmap = new TQPixmap( kde_restorebutton );
2229  m_pCloseButtonPixmap = new TQPixmap( kde_closebutton );
2230  m_pUndock->setAutoRaise( true );
2231  m_pMinimize->setAutoRaise( true );
2232  m_pRestore->setAutoRaise( true );
2233  m_pClose->setAutoRaise( true );
2234  }
2235  else if ( frameDecorOfAttachedViews() == KMdi::KDELook )
2236  {
2237  m_pUndockButtonPixmap = new TQPixmap( kde2_undockbutton );
2238  m_pMinButtonPixmap = new TQPixmap( kde2_minbutton );
2239  m_pRestoreButtonPixmap = new TQPixmap( kde2_restorebutton );
2240  m_pCloseButtonPixmap = new TQPixmap( kde2_closebutton );
2241  }
2242  else
2243  { // kde2laptop look
2244  m_pUndockButtonPixmap = new TQPixmap( kde2laptop_undockbutton );
2245  m_pMinButtonPixmap = new TQPixmap( kde2laptop_minbutton );
2246  m_pRestoreButtonPixmap = new TQPixmap( kde2laptop_restorebutton );
2247  m_pCloseButtonPixmap = new TQPixmap( kde2laptop_closebutton );
2248  }
2249 
2250  m_pUndock->hide();
2251  m_pMinimize->hide();
2252  m_pRestore->hide();
2253  m_pClose->hide();
2254 
2255  m_pUndock->setPixmap( *m_pUndockButtonPixmap );
2256  m_pMinimize->setPixmap( *m_pMinButtonPixmap );
2257  m_pRestore->setPixmap( *m_pRestoreButtonPixmap );
2258  m_pClose->setPixmap( *m_pCloseButtonPixmap );
2259 }
2260 
2261 void KMdiMainFrm::setSysButtonsAtMenuPosition()
2262 {
2263  if ( m_pMainMenuBar == 0L )
2264  return ;
2265  if ( m_pMainMenuBar->parentWidget() == 0L )
2266  return ;
2267 
2268  int menuW = m_pMainMenuBar->parentWidget() ->width();
2269  int h;
2270  int y;
2271  if ( frameDecorOfAttachedViews() == KMdi::Win95Look )
2272  h = 16;
2273  else if ( frameDecorOfAttachedViews() == KMdi::KDE1Look )
2274  h = 20;
2275  else if ( frameDecorOfAttachedViews() == KMdi::KDELook )
2276  h = 16;
2277  else
2278  h = 14;
2279  y = m_pMainMenuBar->height() / 2 - h / 2;
2280 
2281  if ( frameDecorOfAttachedViews() == KMdi::KDELaptopLook )
2282  {
2283  int w = 27;
2284  m_pUndock->setGeometry( ( menuW - ( w * 3 ) - 5 ), y, w, h );
2285  m_pMinimize->setGeometry( ( menuW - ( w * 2 ) - 5 ), y, w, h );
2286  m_pRestore->setGeometry( ( menuW - w - 5 ), y, w, h );
2287  }
2288  else
2289  {
2290  m_pUndock->setGeometry( ( menuW - ( h * 4 ) - 5 ), y, h, h );
2291  m_pMinimize->setGeometry( ( menuW - ( h * 3 ) - 5 ), y, h, h );
2292  m_pRestore->setGeometry( ( menuW - ( h * 2 ) - 5 ), y, h, h );
2293  m_pClose->setGeometry( ( menuW - h - 5 ), y, h, h );
2294  }
2295 }
2296 
2298 void KMdiMainFrm::activateNextWin()
2299 {
2300  KMdiIterator<KMdiChildView*>* it = createIterator();
2301  KMdiChildView* aWin = activeWindow();
2302  for ( it->first(); !it->isDone(); it->next() )
2303  {
2304  if ( it->currentItem() == aWin )
2305  {
2306  it->next();
2307  if ( !it->currentItem() )
2308  {
2309  it->first();
2310  }
2311  if ( it->currentItem() )
2312  {
2313  activateView( it->currentItem() );
2314  }
2315  break;
2316  }
2317  }
2318  delete it;
2319 }
2320 
2322 void KMdiMainFrm::activatePrevWin()
2323 {
2324  KMdiIterator<KMdiChildView*>* it = createIterator();
2325  KMdiChildView* aWin = activeWindow();
2326  for ( it->first(); !it->isDone(); it->next() )
2327  {
2328  if ( it->currentItem() == aWin )
2329  {
2330  it->prev();
2331  if ( !it->currentItem() )
2332  {
2333  it->last();
2334  }
2335  if ( it->currentItem() )
2336  {
2337  activateView( it->currentItem() );
2338  }
2339  break;
2340  }
2341  }
2342  delete it;
2343 }
2344 
2346 void KMdiMainFrm::activateFirstWin()
2347 {
2348  m_bSwitching= true; // flag that we are currently switching between windows
2349  KMdiIterator<KMdiChildView*>* it = createIterator();
2350  TQMap<TQDateTime, KMdiChildView*> m;
2351  for ( it->first(); !it->isDone(); it->next() )
2352  {
2353  m.insert( it->currentItem() ->getTimeStamp(), it->currentItem() );
2354  }
2355 
2356  if ( !activeWindow() )
2357  return ;
2358 
2359  TQDateTime current = activeWindow() ->getTimeStamp();
2360  TQMap<TQDateTime, KMdiChildView*>::iterator pos( m.find( current ) );
2361  TQMap<TQDateTime, KMdiChildView*>::iterator newPos = pos;
2362  if ( pos != m.end() )
2363  {
2364  ++newPos;
2365  }
2366  if ( newPos != m.end() )
2367  { // look ahead
2368  ++pos;
2369  }
2370  else
2371  {
2372  pos = m.begin();
2373  }
2374  activateView( pos.data() );
2375  delete it;
2376 }
2377 
2379 void KMdiMainFrm::activateLastWin()
2380 {
2381  m_bSwitching= true; // flag that we are currently switching between windows
2382  KMdiIterator<KMdiChildView*>* it = createIterator();
2383  TQMap<TQDateTime, KMdiChildView*> m;
2384  for ( it->first(); !it->isDone(); it->next() )
2385  {
2386  m.insert( it->currentItem() ->getTimeStamp(), it->currentItem() );
2387  }
2388 
2389  if ( !activeWindow() )
2390  return ;
2391 
2392  TQDateTime current = activeWindow() ->getTimeStamp();
2393  TQMap<TQDateTime, KMdiChildView*>::iterator pos( m.find( current ) );
2394  if ( pos != m.begin() )
2395  {
2396  --pos;
2397  }
2398  else
2399  {
2400  pos = m.end();
2401  --pos;
2402  }
2403  activateView( pos.data() );
2404  delete it;
2405 }
2406 
2408 void KMdiMainFrm::activateView( int index )
2409 {
2410  KMdiChildView * pView = m_pDocumentViews->first();
2411  for ( int i = 0; pView && ( i < index ); i++ )
2412  {
2413  pView = m_pDocumentViews->next();
2414  }
2415  if ( pView )
2416  {
2417  pView->activate();
2418  }
2419 }
2420 
2422 void KMdiMainFrm::setEnableMaximizedChildFrmMode( bool enableMaxChildFrameMode )
2423 {
2424  if ( enableMaxChildFrameMode )
2425  {
2426  kdDebug(760) << k_funcinfo << "Turning on maximized child frame mode" << endl;
2427  m_bMaximizedChildFrmMode = true;
2428 
2429  KMdiChildFrm* pCurrentChild = m_pMdi->topChild();
2430 
2431  //If we have no child or there is no menubar, we do nothing
2432  if ( !pCurrentChild || !m_pMainMenuBar )
2433  return ;
2434 
2435  TQObject::connect( m_pUndock, TQT_SIGNAL( clicked() ), pCurrentChild, TQT_SLOT( undockPressed() ) );
2436  TQObject::connect( m_pMinimize, TQT_SIGNAL( clicked() ), pCurrentChild, TQT_SLOT( minimizePressed() ) );
2437  TQObject::connect( m_pRestore, TQT_SIGNAL( clicked() ), pCurrentChild, TQT_SLOT( maximizePressed() ) );
2438  m_pMinimize->show();
2439  m_pUndock->show();
2440  m_pRestore->show();
2441 
2442  if ( frameDecorOfAttachedViews() == KMdi::KDELaptopLook )
2443  {
2444  m_pMainMenuBar->insertItem( TQPixmap( kde2laptop_closebutton_menu ), m_pMdi->topChild(), TQT_SLOT( closePressed() ), 0, -1, 0 );
2445  }
2446  else
2447  {
2448  m_pMainMenuBar->insertItem( *pCurrentChild->icon(), pCurrentChild->systemMenu(), -1, 0 );
2449  if ( m_pClose )
2450  {
2451  TQObject::connect( m_pClose, TQT_SIGNAL( clicked() ), pCurrentChild, TQT_SLOT( closePressed() ) );
2452  m_pClose->show();
2453  }
2454  else
2455  kdDebug(760) << k_funcinfo << "no close button. things won't behave correctly" << endl;
2456  }
2457  }
2458  else
2459  {
2460  if ( !m_bMaximizedChildFrmMode )
2461  return ; // already set, nothing to do
2462 
2463  kdDebug(760) << k_funcinfo << "Turning off maximized child frame mode" << endl;
2464  m_bMaximizedChildFrmMode = false;
2465 
2466  KMdiChildFrm* pFrmChild = m_pMdi->topChild();
2467  if ( pFrmChild && pFrmChild->m_pClient && pFrmChild->state() == KMdiChildFrm::Maximized )
2468  {
2469  pFrmChild->m_pClient->restore();
2470  switchOffMaximizeModeForMenu( pFrmChild );
2471  }
2472  }
2473 }
2474 
2476 void KMdiMainFrm::switchOffMaximizeModeForMenu( KMdiChildFrm* oldChild )
2477 {
2478  // if there is no menubar given, those system buttons aren't possible
2479  if ( !m_pMainMenuBar )
2480  return ;
2481 
2482  m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt( 0 ) );
2483 
2484  if ( oldChild )
2485  {
2486  Q_ASSERT( m_pClose );
2487  TQObject::disconnect( m_pUndock, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( undockPressed() ) );
2488  TQObject::disconnect( m_pMinimize, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( minimizePressed() ) );
2489  TQObject::disconnect( m_pRestore, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( maximizePressed() ) );
2490  TQObject::disconnect( m_pClose, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( closePressed() ) );
2491  }
2492  m_pUndock->hide();
2493  m_pMinimize->hide();
2494  m_pRestore->hide();
2495  m_pClose->hide();
2496 }
2497 
2499 void KMdiMainFrm::updateSysButtonConnections( KMdiChildFrm* oldChild, KMdiChildFrm* newChild )
2500 {
2501  //tqDebug("updateSysButtonConnections");
2502  // if there is no menubar given, those system buttons aren't possible
2503  if ( !m_pMainMenuBar )
2504  return ;
2505 
2506  if ( newChild )
2507  {
2508  if ( frameDecorOfAttachedViews() == KMdi::KDELaptopLook )
2509  m_pMainMenuBar->insertItem( TQPixmap( kde2laptop_closebutton_menu ), newChild, TQT_SLOT( closePressed() ), 0, -1, 0 );
2510  else
2511  m_pMainMenuBar->insertItem( *newChild->icon(), newChild->systemMenu(), -1, 0 );
2512  }
2513 
2514  if ( oldChild )
2515  {
2516  m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt( 1 ) );
2517  Q_ASSERT( m_pClose );
2518  TQObject::disconnect( m_pUndock, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( undockPressed() ) );
2519  TQObject::disconnect( m_pMinimize, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( minimizePressed() ) );
2520  TQObject::disconnect( m_pRestore, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( maximizePressed() ) );
2521  TQObject::disconnect( m_pClose, TQT_SIGNAL( clicked() ), oldChild, TQT_SLOT( closePressed() ) );
2522  }
2523  if ( newChild )
2524  {
2525  Q_ASSERT( m_pClose );
2526  TQObject::connect( m_pUndock, TQT_SIGNAL( clicked() ), newChild, TQT_SLOT( undockPressed() ) );
2527  TQObject::connect( m_pMinimize, TQT_SIGNAL( clicked() ), newChild, TQT_SLOT( minimizePressed() ) );
2528  TQObject::connect( m_pRestore, TQT_SIGNAL( clicked() ), newChild, TQT_SLOT( maximizePressed() ) );
2529  TQObject::connect( m_pClose, TQT_SIGNAL( clicked() ), newChild, TQT_SLOT( closePressed() ) );
2530  }
2531 }
2532 
2534 bool KMdiMainFrm::isViewTaskBarOn()
2535 {
2536  if ( m_pTaskBar )
2537  return m_pTaskBar->isSwitchedOn();
2538  else
2539  return false;
2540 }
2541 
2543 void KMdiMainFrm::showViewTaskBar()
2544 {
2545  if ( m_pTaskBar )
2546  m_pTaskBar->switchOn( true );
2547 }
2548 
2550 void KMdiMainFrm::hideViewTaskBar()
2551 {
2552  if ( m_pTaskBar )
2553  m_pTaskBar->switchOn( false );
2554 }
2555 
2556 //=============== fillWindowMenu ===============//
2557 void KMdiMainFrm::fillWindowMenu()
2558 {
2559  bool tabPageMode = false;
2560  if ( m_mdiMode == KMdi::TabPageMode )
2561  tabPageMode = true;
2562 
2563  bool IDEAlMode = false;
2564  if ( m_mdiMode == KMdi::IDEAlMode )
2565  IDEAlMode = true;
2566 
2567  bool noViewOpened = false;
2568  if ( m_pDocumentViews->isEmpty() )
2569  noViewOpened = true;
2570 
2571  // construct the menu and its submenus
2572  if ( !m_bClearingOfWindowMenuBlocked )
2573  m_pWindowMenu->clear();
2574 
2575  d->closeWindowAction->plug(m_pWindowMenu);
2576 
2577  int closeAllId = m_pWindowMenu->insertItem( i18n( "Close &All" ), this, TQT_SLOT( closeAllViews() ) );
2578  if ( noViewOpened )
2579  {
2580  d->closeWindowAction->setEnabled(false);
2581  m_pWindowMenu->setItemEnabled( closeAllId, false );
2582  }
2583 
2584  if ( !tabPageMode && !IDEAlMode )
2585  {
2586  int iconifyId = m_pWindowMenu->insertItem( i18n( "&Minimize All" ), this, TQT_SLOT( iconifyAllViews() ) );
2587  if ( noViewOpened )
2588  m_pWindowMenu->setItemEnabled( iconifyId, false );
2589  }
2590 
2591  m_pWindowMenu->insertSeparator();
2592  m_pWindowMenu->insertItem( i18n( "&MDI Mode" ), m_pMdiModeMenu );
2593  m_pMdiModeMenu->clear();
2594  m_pMdiModeMenu->insertItem( i18n( "&Toplevel Mode" ), this, TQT_SLOT( switchToToplevelMode() ) );
2595  m_pMdiModeMenu->insertItem( i18n( "C&hildframe Mode" ), this, TQT_SLOT( switchToChildframeMode() ) );
2596  m_pMdiModeMenu->insertItem( i18n( "Ta&b Page Mode" ), this, TQT_SLOT( switchToTabPageMode() ) );
2597  m_pMdiModeMenu->insertItem( i18n( "I&DEAl Mode" ), this, TQT_SLOT( switchToIDEAlMode() ) );
2598  switch ( m_mdiMode )
2599  {
2600  case KMdi::ToplevelMode:
2601  m_pMdiModeMenu->setItemChecked( m_pMdiModeMenu->idAt( 0 ), true );
2602  break;
2603  case KMdi::ChildframeMode:
2604  m_pMdiModeMenu->setItemChecked( m_pMdiModeMenu->idAt( 1 ), true );
2605  break;
2606  case KMdi::TabPageMode:
2607  m_pMdiModeMenu->setItemChecked( m_pMdiModeMenu->idAt( 2 ), true );
2608  break;
2609  case KMdi::IDEAlMode:
2610  m_pMdiModeMenu->setItemChecked( m_pMdiModeMenu->idAt( 3 ), true );
2611  break;
2612  default:
2613  break;
2614  }
2615 
2616  m_pWindowMenu->insertSeparator();
2617  if ( !tabPageMode && !IDEAlMode )
2618  {
2619  int placMenuId = m_pWindowMenu->insertItem( i18n( "&Tile" ), m_pPlacingMenu );
2620  m_pPlacingMenu->clear();
2621  m_pPlacingMenu->insertItem( i18n( "Ca&scade Windows" ), m_pMdi, TQT_SLOT( cascadeWindows() ) );
2622  m_pPlacingMenu->insertItem( i18n( "Cascade &Maximized" ), m_pMdi, TQT_SLOT( cascadeMaximized() ) );
2623  m_pPlacingMenu->insertItem( i18n( "Expand &Vertically" ), m_pMdi, TQT_SLOT( expandVertical() ) );
2624  m_pPlacingMenu->insertItem( i18n( "Expand &Horizontally" ), m_pMdi, TQT_SLOT( expandHorizontal() ) );
2625  m_pPlacingMenu->insertItem( i18n( "Tile &Non-Overlapped" ), m_pMdi, TQT_SLOT( tileAnodine() ) );
2626  m_pPlacingMenu->insertItem( i18n( "Tile Overla&pped" ), m_pMdi, TQT_SLOT( tilePragma() ) );
2627  m_pPlacingMenu->insertItem( i18n( "Tile V&ertically" ), m_pMdi, TQT_SLOT( tileVertically() ) );
2628  if ( m_mdiMode == KMdi::ToplevelMode )
2629  {
2630  m_pWindowMenu->setItemEnabled( placMenuId, false );
2631  }
2632  m_pWindowMenu->insertSeparator();
2633  int dockUndockId = m_pWindowMenu->insertItem( i18n( "&Dock/Undock" ), m_pDockMenu );
2634  m_pDockMenu->clear();
2635  m_pWindowMenu->insertSeparator();
2636  if ( noViewOpened )
2637  {
2638  m_pWindowMenu->setItemEnabled( placMenuId, false );
2639  m_pWindowMenu->setItemEnabled( dockUndockId, false );
2640  }
2641  }
2642  int entryCount = m_pWindowMenu->count();
2643 
2644  // for all child frame windows: give an ID to every window and connect them in the end with windowMenuItemActivated()
2645  int i = 100;
2646  KMdiChildView* pView = 0L;
2647  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
2648  TQValueList<TQDateTime> timeStamps;
2649  for ( ; it.current(); ++it )
2650  {
2651  pView = it.current();
2652  TQDateTime timeStamp( pView->getTimeStamp() );
2653 
2654  if ( pView->isToolView() )
2655  {
2656  continue;
2657  }
2658 
2659  TQString item;
2660  // set titles of minimized windows in brackets
2661  if ( pView->isMinimized() )
2662  {
2663  item += "(";
2664  item += pView->caption();
2665  item += ")";
2666  }
2667  else
2668  {
2669  item += " ";
2670  item += pView->caption();
2671  }
2672 
2673  // insert the window entry sorted by access time
2674  unsigned int indx;
2675  unsigned int windowItemCount = m_pWindowMenu->count() - entryCount;
2676  bool inserted = false;
2677  TQString tmpString;
2678  TQValueList<TQDateTime>::iterator timeStampIterator = timeStamps.begin();
2679  for ( indx = 0; indx <= windowItemCount; indx++, ++timeStampIterator )
2680  {
2681  bool putHere = false;
2682  if ( ( *timeStampIterator ) < timeStamp )
2683  {
2684  putHere = true;
2685  timeStamps.insert( timeStampIterator, timeStamp );
2686  }
2687  if ( putHere )
2688  {
2689  m_pWindowMenu->insertItem( item, pView, TQT_SLOT( slot_clickedInWindowMenu() ), 0, -1, indx + entryCount );
2690  if ( pView == m_pCurrentWindow )
2691  {
2692  m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt( indx + entryCount ), true );
2693  }
2694  pView->setWindowMenuID( i );
2695  if ( !tabPageMode )
2696  {
2697  m_pDockMenu->insertItem( item, pView, TQT_SLOT( slot_clickedInDockMenu() ), 0, -1, indx );
2698  if ( pView->isAttached() )
2699  {
2700  m_pDockMenu->setItemChecked( m_pDockMenu->idAt( indx ), true );
2701  }
2702  }
2703  inserted = true;
2704  break;
2705  indx = windowItemCount + 1; // break the loop
2706  }
2707  }
2708  if ( !inserted )
2709  { // append it
2710  m_pWindowMenu->insertItem( item, pView, TQT_SLOT( slot_clickedInWindowMenu() ), 0, -1, windowItemCount + entryCount );
2711  if ( pView == m_pCurrentWindow )
2712  {
2713  m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt( windowItemCount + entryCount ), true );
2714  }
2715  pView->setWindowMenuID( i );
2716  if ( !tabPageMode )
2717  {
2718  m_pDockMenu->insertItem( item, pView, TQT_SLOT( slot_clickedInDockMenu() ), 0, -1, windowItemCount );
2719  if ( pView->isAttached() )
2720  {
2721  m_pDockMenu->setItemChecked( m_pDockMenu->idAt( windowItemCount ), true );
2722  }
2723  }
2724  }
2725  i++;
2726  }
2727 }
2728 
2729 //================ windowMenuItemActivated ===============//
2730 
2731 void KMdiMainFrm::windowMenuItemActivated( int id )
2732 {
2733  if ( id < 100 )
2734  return ;
2735  id -= 100;
2736  KMdiChildView *pView = m_pDocumentViews->at( id );
2737  if ( !pView )
2738  return ;
2739  if ( pView->isMinimized() )
2740  pView->minimize();
2741  if ( m_mdiMode != KMdi::TabPageMode )
2742  {
2743  KMdiChildFrm * pTopChild = m_pMdi->topChild();
2744  if ( pTopChild )
2745  {
2746  if ( ( pView == pTopChild->m_pClient ) && pView->isAttached() )
2747  {
2748  return ;
2749  }
2750  }
2751  }
2752  activateView( pView );
2753 }
2754 
2755 //================ dockMenuItemActivated ===============//
2756 
2757 void KMdiMainFrm::dockMenuItemActivated( int id )
2758 {
2759  if ( id < 100 )
2760  return ;
2761  id -= 100;
2762  KMdiChildView *pView = m_pDocumentViews->at( id );
2763  if ( !pView )
2764  return ;
2765  if ( pView->isMinimized() )
2766  pView->minimize();
2767  if ( pView->isAttached() )
2768  {
2769  detachWindow( pView, true );
2770  }
2771  else
2772  { // is detached
2773  attachWindow( pView, true );
2774  }
2775 }
2776 
2777 //================ popupWindowMenu ===============//
2778 
2779 void KMdiMainFrm::popupWindowMenu( TQPoint p )
2780 {
2781  if ( !isFakingSDIApplication() )
2782  {
2783  m_pWindowMenu->popup( p );
2784  }
2785 }
2786 
2787 //================ dragEndTimeOut ===============//
2788 void KMdiMainFrm::dragEndTimeOut()
2789 {
2790  // send drag end to all concerned views.
2791  KMdiChildView * pView;
2792  for ( m_pDocumentViews->first(); ( pView = m_pDocumentViews->current() ) != 0L; m_pDocumentViews->next() )
2793  {
2794  KMdiChildFrmDragEndEvent dragEndEvent( 0L );
2795  TQApplication::sendEvent( pView, &dragEndEvent );
2796  }
2797 }
2798 
2799 //================ setFrameDecorOfAttachedViews ===============//
2800 
2801 void KMdiMainFrm::setFrameDecorOfAttachedViews( int frameDecor )
2802 {
2803  switch ( frameDecor )
2804  {
2805  case 0:
2806  m_frameDecoration = KMdi::Win95Look;
2807  break;
2808  case 1:
2809  m_frameDecoration = KMdi::KDE1Look;
2810  break;
2811  case 2:
2812  m_frameDecoration = KMdi::KDELook;
2813  break;
2814  case 3:
2815  m_frameDecoration = KMdi::KDELaptopLook;
2816  break;
2817  default:
2818  tqDebug( "unknown MDI decoration" );
2819  break;
2820  }
2821  setMenuForSDIModeSysButtons( m_pMainMenuBar );
2822  TQPtrListIterator<KMdiChildView> it( *m_pDocumentViews );
2823  for ( ; it.current(); ++it )
2824  {
2825  KMdiChildView* pView = it.current();
2826  if ( pView->isToolView() )
2827  continue;
2828  if ( pView->isAttached() )
2829  pView->mdiParent() ->redecorateButtons();
2830  }
2831 }
2832 
2833 void KMdiMainFrm::fakeSDIApplication()
2834 {
2835  m_bSDIApplication = true;
2836  if ( m_pTaskBar )
2837  m_pTaskBar->close();
2838  m_pTaskBar = 0L;
2839 }
2840 
2841 void KMdiMainFrm::closeViewButtonPressed()
2842 {
2843  KMdiChildView * pView = activeWindow();
2844  if ( pView )
2845  {
2846  pView->close();
2847  }
2848 }
2849 
2850 void KMdiMainFrm::setManagedDockPositionModeEnabled( bool enabled )
2851 {
2852  m_managedDockPositionMode = enabled;
2853 }
2854 
2855 void KMdiMainFrm::setActiveToolDock( KMdiDockContainer* td )
2856 {
2857  if ( td == d->activeDockPriority[ 0 ] )
2858  return ;
2859  if ( d->activeDockPriority[ 0 ] == 0 )
2860  {
2861  d->activeDockPriority[ 0 ] = td;
2862  // d->focusList=new KMdiFocusList(this);
2863  // if (m_pMdi) d->focusList->addWidgetTree(m_pMdi);
2864  // if (m_documentTabWidget) d->focusList->addWidgetTree(m_documentTabWidget);
2865  return ;
2866  }
2867  for ( int dst = 3, src = 2;src >= 0;dst--, src-- )
2868  {
2869  if ( d->activeDockPriority[ src ] == td )
2870  src--;
2871  if ( src < 0 )
2872  break;
2873  d->activeDockPriority[ dst ] = d->activeDockPriority[ src ];
2874  }
2875  d->activeDockPriority[ 0 ] = td;
2876 }
2877 
2878 void KMdiMainFrm::removeFromActiveDockList( KMdiDockContainer* td )
2879 {
2880  for ( int i = 0;i < 4;i++ )
2881  {
2882  if ( d->activeDockPriority[ i ] == td )
2883  {
2884  for ( ;i < 3;i++ )
2885  d->activeDockPriority[ i ] = d->activeDockPriority[ i + 1 ];
2886  d->activeDockPriority[ 3 ] = 0;
2887  break;
2888  }
2889  }
2890  /*
2891  if (d->activeDockPriority[0]==0) {
2892  if (d->focusList) d->focusList->restore();
2893  delete d->focusList;
2894  d->focusList=0;
2895  }
2896  */
2897 }
2898 
2899 void KMdiMainFrm::prevToolViewInDock()
2900 {
2901  KMdiDockContainer * td = d->activeDockPriority[ 0 ];
2902  if ( !td )
2903  return ;
2904  td->prevToolView();
2905 }
2906 
2907 void KMdiMainFrm::nextToolViewInDock()
2908 {
2909  KMdiDockContainer * td = d->activeDockPriority[ 0 ];
2910  if ( !td )
2911  return ;
2912  td->nextToolView();
2913 }
2914 
2915 KMdi::TabWidgetVisibility KMdiMainFrm::tabWidgetVisibility()
2916 {
2917  if ( m_documentTabWidget )
2918  return m_documentTabWidget->tabWidgetVisibility();
2919 
2920  return KMdi::NeverShowTabs;
2921 }
2922 
2923 void KMdiMainFrm::setTabWidgetVisibility( KMdi::TabWidgetVisibility visibility )
2924 {
2925  if ( m_documentTabWidget )
2926  m_documentTabWidget->setTabWidgetVisibility( visibility );
2927 }
2928 
2929 KTabWidget * KMdiMainFrm::tabWidget() const
2930 {
2931  return m_documentTabWidget;
2932 }
2933 
2934 #include "tdemdimainfrm.moc"
KMdiMainFrm::switchToToplevelMode
virtual void switchToToplevelMode()
Undocks all view windows (unix-like)
Definition: tdemdimainfrm.cpp:1343
KMdiChildView::hide
virtual void hide()
Calls TQWidget::hide() or it's parent widget hide() if attached.
Definition: tdemdichildview.cpp:756
KMdiMainFrm::popupWindowMenu
void popupWindowMenu(TQPoint p)
Popups the "Window" menu.
Definition: tdemdimainfrm.cpp:2779
KMdiMainFrm::dragEndTimeOut
void dragEndTimeOut()
The timer for main widget moving has elapsed -> send drag end to all concerned views.
Definition: tdemdimainfrm.cpp:2788
KMdiChildView::restore
virtual void restore()
Restores this window to its normal size.
Definition: tdemdichildview.cpp:328
KMdiChildView::setTabCaption
virtual void setTabCaption(const TQString &caption)
Sets the caption of the button referring to this window.
Definition: tdemdichildview.cpp:678
KMdi::IconOnly
Show only icons on the toolview tabs.
Definition: tdemdidefines.h:109
KMdiChildView::isToolView
bool isToolView() const
Returns if this is added as MDI tool-view.
Definition: tdemdichildview.h:354
KMdiChildView::setCaption
virtual void setCaption(const TQString &szCaption)
Sets the window caption string...
Definition: tdemdichildview.cpp:373
KMdiTaskBarButton
Internal class.
Definition: tdemditaskbar.h:51
KMdiChildView::isAttached
bool isAttached() const
Returns true if the MDI view is a child window within the MDI mainframe widget or false if the MDI vi...
Definition: tdemdichildview.h:227
KMdiMainFrm::windowMenuItemActivated
void windowMenuItemActivated(int id)
Usually called when the user clicks an MDI view item in the "Window" menu.
Definition: tdemdimainfrm.cpp:2731
KMdiChildView::isMaximized
bool isMaximized() const
Tells if the window is minimized when attached to the Mdi manager, otherwise returns false...
Definition: tdemdichildview.cpp:318
KMdiMainFrm::tabWidgetVisibility
KMdi::TabWidgetVisibility tabWidgetVisibility()
Get tabwidget visibility.
Definition: tdemdimainfrm.cpp:2915
KMdiChildView::youAreAttached
virtual void youAreAttached(KMdiChildFrm *lpC)
Internally called, if KMdiMainFrm::attach is called.
Definition: tdemdichildview.cpp:350
KMdiMainFrm::switchToTabPageMode
virtual void switchToTabPageMode()
Docks all view windows (Windows-like)
Definition: tdemdimainfrm.cpp:1601
KMdiChildFrm::setClient
void setClient(KMdiChildView *w, bool bAutomaticResize=false)
Reparents the widget w to this KMdiChildFrm (if this is not already done) Installs an event filter to...
Definition: tdemdichildfrm.cpp:726
KMdiChildFrm::systemMenu
TQPopupMenu * systemMenu() const
Returns the system menu.
Definition: tdemdichildfrm.cpp:1228
KMdiMainFrm::fakeSDIApplication
void fakeSDIApplication()
An SDI application user interface is faked:
Definition: tdemdimainfrm.cpp:2833
KMdiMainFrm::createMdiManager
virtual void createMdiManager()
Creates the MDI view area and connects some signals and slots with the KMdiMainFrm widget...
Definition: tdemdimainfrm.cpp:361
KMdiMainFrm::closeActiveView
virtual void closeActiveView()
Closes the view of the active (topchild) window.
Definition: tdemdimainfrm.cpp:1265
KMdiMainFrm::updateSysButtonConnections
void updateSysButtonConnections(KMdiChildFrm *oldChild, KMdiChildFrm *newChild)
Reconnects the system buttons form maximize mode (SDI mode) with the new child frame.
Definition: tdemdimainfrm.cpp:2499
KMdiMainFrm::windowPopup
virtual TQPopupMenu * windowPopup(KMdiChildView *pWnd, bool bIncludeTaskbarPopup=true)
Returns a popup menu with only a title "Window".
Definition: tdemdimainfrm.cpp:974
KMdiMainFrm::switchToIDEAlMode
virtual void switchToIDEAlMode()
Docks all view windows.
Definition: tdemdimainfrm.cpp:1822
KMdiChildView::restoreGeometry
TQRect restoreGeometry()
Returns the geometry that will be restored by calling restore().
Definition: tdemdichildview.cpp:276
KMdiChildView::youAreDetached
virtual void youAreDetached()
Internally called, if KMdiMainFrm::detach is called.
Definition: tdemdichildview.cpp:358
KMdiMainFrm::activateView
virtual void activateView(int index)
Activates the view with the tab page index (TabPage mode only)
Definition: tdemdimainfrm.cpp:2408
KMdiMainFrm::taskBarPopup
virtual TQPopupMenu * taskBarPopup(KMdiChildView *pWnd, bool bIncludeWindowPopup=false)
Returns a popup menu filled according to the MDI view state.
Definition: tdemdimainfrm.cpp:986
KMdiMainFrm::iconifyAllViews
virtual void iconifyAllViews()
Iconfiy all views.
Definition: tdemdimainfrm.cpp:1254
KMdiMainFrm::closeViewButtonPressed
void closeViewButtonPressed()
internally used to handle click on view close button (TabPage mode, only)
Definition: tdemdimainfrm.cpp:2841
KMdiChildFrm::icon
TQPixmap * icon() const
Returns the child frame icon.
Definition: tdemdichildfrm.cpp:720
KMdiChildView::tabCaption
const TQString & tabCaption() const
Returns the caption of the button on the taskbar.
Definition: tdemdichildview.h:237
KMdiMainFrm::activateNextWin
virtual void activateNextWin()
Activates the next open view.
Definition: tdemdimainfrm.cpp:2298
KMdiMainFrm::attachWindow
virtual void attachWindow(KMdiChildView *pWnd, bool bShow=true, bool bAutomaticResize=false)
Makes a main frame controlled undocked KMdiChildView docked.
Definition: tdemdimainfrm.cpp:603
KMdiMainFrm::windowExists
bool windowExists(KMdiChildView *pWnd, ExistsAs as)
Returns whether this MDI child view is under MDI control (using addWindow() ) or not.
Definition: tdemdimainfrm.cpp:958
KMdiMainFrm::removeWindowFromMdi
virtual void removeWindowFromMdi(KMdiChildView *pWnd)
Removes a KMdiChildView from the MDI system and from the main frame`s control.
Definition: tdemdimainfrm.cpp:728
KMdi::TextAndIcon
Show both the icon and description on the toolview tabs.
Definition: tdemdidefines.h:113
KMdiMainFrm::fillWindowMenu
virtual void fillWindowMenu()
Update of the window menu contents.
Definition: tdemdimainfrm.cpp:2557
KMdiChildFrm::setRestoreGeometry
void setRestoreGeometry(const TQRect &newRestGeo)
Sets the geometry that will be restored by calling restore().
Definition: tdemdichildfrm.cpp:680
KMdiChildFrm::redecorateButtons
void redecorateButtons()
sets new raise behavior and pixmaps of the buttons depending on the current decoration style ...
Definition: tdemdichildfrm.cpp:1322
KMdiMainFrm::setSysButtonsAtMenuPosition
virtual void setSysButtonsAtMenuPosition()
If there's a main menubar given, it will create the 4 maximize mode buttons there (undock...
Definition: tdemdimainfrm.cpp:2261
KMdiMainFrm::closeWindow
virtual void closeWindow(KMdiChildView *pWnd, bool layoutTaskBar=true)
Removes a KMdiChildView from the MDI system and from the main frame`s control.
Definition: tdemdimainfrm.cpp:828
KMdiMainFrm::event
virtual bool event(TQEvent *e)
Catches certain Qt events and processes it here.
Definition: tdemdimainfrm.cpp:1119
KMdiChildView::maximize
virtual void maximize(bool bAnimate)
Maximizes this window when it is attached to the Mdi manager.
Definition: tdemdichildview.cpp:248
KMdiMainFrm::setIDEAlModeStyle
void setIDEAlModeStyle(int flags) KDE_DEPRECATED
Sets the appearance of the IDEAl mode.
Definition: tdemdimainfrm.cpp:1737
KMdiDocumentViewTabWidget
A reimplementation of KTabWidget for KMDI.
Definition: tdemdidocumentviewtabwidget.h:22
KMdiMainFrm::createToolWindow
KMdiToolViewAccessor * createToolWindow()
Using this method you have to use the setWidget method of the access object, and it is very recommend...
Definition: tdemdimainfrm.cpp:548
KMdiChildView::activate
void activate()
This method does the same as focusInEvent().
Definition: tdemdichildview.cpp:420
KMdiChildView::setMaximumSize
virtual void setMaximumSize(int maxw, int maxh)
Sets the maximum size of the widget to w by h pixels.
Definition: tdemdichildview.cpp:727
KMdiChildFrm
Internal class.
Definition: tdemdichildfrm.h:130
KMdiMainFrm::dockMenuItemActivated
void dockMenuItemActivated(int id)
Usually called when the user clicks an MDI view item in the sub-popup menu "Docking" of the "Window" ...
Definition: tdemdimainfrm.cpp:2757
KMdiMainFrm::switchOffMaximizeModeForMenu
void switchOffMaximizeModeForMenu(KMdiChildFrm *oldChild)
Turns the system buttons for maximize mode (SDI mode) off, and disconnects them.
Definition: tdemdimainfrm.cpp:2476
KMdiChildView::setRestoreGeometry
void setRestoreGeometry(const TQRect &newRestGeo)
Sets the geometry that will be restored by calling restore().
Definition: tdemdichildview.cpp:286
KMdiMainFrm::createWrapper
KMdiChildView * createWrapper(TQWidget *view, const TQString &name, const TQString &shortName)
addWindow demands a KMdiChildView.
Definition: tdemdimainfrm.cpp:416
KMdiMainFrm::applyOptions
virtual void applyOptions()
Called in the constructor (forces a resize of all MDI views)
Definition: tdemdimainfrm.cpp:336
KMdiChildFrm::caption
const TQString & caption()
Gets the caption of this mdi child.
Definition: tdemdichildfrm.h:230
KMdi
A namespace for the KMDI library.
Definition: tdemdidefines.h:41
KMdi::TextOnly
Show only the text description on the toolview tabs.
Definition: tdemdidefines.h:111
KMdiChildView::show
virtual void show()
Calls TQWidget::show but also for it's parent widget if attached.
Definition: tdemdichildview.cpp:746
KMdiMainFrm::addWindow
virtual void addWindow(KMdiChildView *pWnd, int flags=KMdi::StandardAdd)
Adds a KMdiChildView to the MDI system.
Definition: tdemdimainfrm.cpp:439
KMdiMainFrm::activateFirstWin
virtual void activateFirstWin()
Activates the view first viewed concerning to the access time.
Definition: tdemdimainfrm.cpp:2346
KMdiMainFrm::closeAllViews
virtual void closeAllViews()
Close all views.
Definition: tdemdimainfrm.cpp:1235
KMdiMainFrm::showViewTaskBar
virtual void showViewTaskBar()
Shows the view taskbar.
Definition: tdemdimainfrm.cpp:2543
KMdiChildView::raise
virtual void raise()
Calls TQWidget::raise() or it's parent widget raise() if attached.
Definition: tdemdichildview.cpp:766
KMdiChildView::mdiParent
KMdiChildFrm * mdiParent() const
Returns the KMdiChildFrm parent widget (or 0 if the window is not attached)
Definition: tdemdichildview.h:604
KMdiMainFrm::addToolWindow
virtual KMdiToolViewAccessor * addToolWindow(TQWidget *pWnd, KDockWidget::DockPosition pos=KDockWidget::DockNone, TQWidget *pTargetWnd=0L, int percent=50, const TQString &tabToolTip=0, const TQString &tabCaption=0)
Usually called from addWindow() when adding a tool view window.
Definition: tdemdimainfrm.cpp:566
KMdiChildFrm::state
MdiWindowState state() const
Returns the current state of the window.
Definition: tdemdichildfrm.h:240
KMdiTaskBar
Internal class.
Definition: tdemditaskbar.h:129
KMdiMainFrm::createTaskBar
virtual void createTaskBar()
Creates a new MDI taskbar (showing the MDI views as taskbar entries) and shows it.
Definition: tdemdimainfrm.cpp:379
KMdiChildFrm::raiseAndActivate
void raiseAndActivate()
Internally called from the signal focusInEventOccurs.
Definition: tdemdichildfrm.cpp:1209
KMdiMainFrm::setMenuForSDIModeSysButtons
virtual void setMenuForSDIModeSysButtons(KMenuBar *menuBar=0)
Tells the MDI system a QMenu where it can insert buttons for the system menu, undock, minimize, restore actions.
Definition: tdemdimainfrm.cpp:2188
KMdiChildFrmDragBeginEvent
a TQCustomEvent for begin of dragging This special event will be useful, to inform view about child f...
Definition: tdemdichildfrm.h:83
KMdiMainFrm::setMinimumSize
virtual void setMinimumSize(int minw, int minh)
Do nothing when in Toplevel mode.
Definition: tdemdimainfrm.cpp:407
KMdiChildFrm::unsetClient
void unsetClient(TQPoint positionOffset=TQPoint(0, 0))
Reparents the client widget to 0 (desktop), moves with an offset from the original position Removes t...
Definition: tdemdichildfrm.cpp:812
KMdiMainFrm::activateLastWin
virtual void activateLastWin()
Activates the view last viewed concerning to the access time.
Definition: tdemdimainfrm.cpp:2379
KMdiMainFrm::switchToChildframeMode
virtual void switchToChildframeMode()
Docks all view windows (Windows-like)
Definition: tdemdimainfrm.cpp:1455
KMdiChildView::setMinimumSize
virtual void setMinimumSize(int minw, int minh)
Sets the minimum size of the widget to w by h pixels.
Definition: tdemdichildview.cpp:715
KMdiMainFrm::findRootDockWidgets
void findRootDockWidgets(TQPtrList< KDockWidget > *pRootDockWidgetList, TQValueList< TQRect > *pPositionList)
find the root dockwidgets and store their geometry
Definition: tdemdimainfrm.cpp:1273
KMdiMainFrm::activeWindow
KMdiChildView * activeWindow()
Returns the focused attached MDI view.
Definition: tdemdimainfrm.cpp:952
KMdiViewCloseEvent
Internal class.
Definition: tdemdimainfrm.h:72
KMdiChildView::getTimeStamp
const TQDateTime & getTimeStamp() const
Recall a previously remembered time, i.e.
Definition: tdemdichildview.h:368
KMdiMainFrm::slot_toggleTaskBar
virtual void slot_toggleTaskBar()
Switches the KMdiTaskBar on and off.
Definition: tdemdimainfrm.cpp:385
KMdiMainFrm::findWindow
KMdiChildView * findWindow(const TQString &caption)
Returns the KMdiChildView belonging to the given caption string.
Definition: tdemdimainfrm.cpp:940
KMdiChildFrm::captionHeight
int captionHeight() const
Returns the caption bar height.
Definition: tdemdichildfrm.h:271
KMDIPrivate::KMDIGUIClient
A class derived from KXMLGUIClient that handles the various KMDI modes.
Definition: tdemdiguiclient.h:41
KMdiMainFrm::taskbarButtonRightClicked
virtual void taskbarButtonRightClicked(KMdiChildView *pWnd)
Activates the MDI view (see activateView() ) and popups the taskBar popup menu (see taskBarPopup() )...
Definition: tdemdimainfrm.cpp:1106
KMdiMainFrm::childWindowCloseRequest
virtual void childWindowCloseRequest(KMdiChildView *pWnd)
Someone wants that the MDI view to be closed.
Definition: tdemdimainfrm.cpp:1113
KMdiChildView::minimize
virtual void minimize(bool bAnimate)
Minimizes this window when it is attached to the Mdi manager.
Definition: tdemdichildview.cpp:221
KMdiChildView::setWindowMenuID
void setWindowMenuID(int id)
Internally used for setting an ID for the 'Window' menu entry.
Definition: tdemdichildview.cpp:691
KMdiMainFrm::setToolviewStyle
void setToolviewStyle(int flags)
Sets the appearance of the toolview tabs.
Definition: tdemdimainfrm.cpp:1769
KMdiMainFrm::detachWindow
virtual void detachWindow(KMdiChildView *pWnd, bool bShow=true)
Makes a docked KMdiChildView undocked.
Definition: tdemdimainfrm.cpp:662
KMdiChildFrmDragEndEvent
a TQCustomEvent for end of dragging This special event will be useful, to inform view about child fra...
Definition: tdemdichildfrm.h:94
KMdiChildView::caption
const TQString & caption() const
Returns the caption of the child window (different from the caption on the button in the taskbar) ...
Definition: tdemdichildview.h:232
KParts
KMdiMainFrm::setStandardMDIMenuEnabled
void setStandardMDIMenuEnabled(bool showModeMenu=true)
Control whether or not the standard MDI menu is displayed when a context menu is displayed.
Definition: tdemdimainfrm.cpp:271
KMdiChildView
Base class for all your special view windows.
Definition: tdemdichildview.h:108
KMdiChildArea
Internal class.
Definition: tdemdichildarea.h:52
KMdiMainFrm::eventFilter
virtual bool eventFilter(TQObject *obj, TQEvent *e)
Definition: tdemdimainfrm.cpp:1165
KMdiMainFrm::setFrameDecorOfAttachedViews
virtual void setFrameDecorOfAttachedViews(int frameDecor)
Sets the decoration of the window frame of docked (attached) MDI views.
Definition: tdemdimainfrm.cpp:2801
KMdiMainFrm::tabWidget
class KTabWidget * tabWidget() const
Returns the tabwidget used in IDEAl and Tabbed modes.
Definition: tdemdimainfrm.cpp:2929
KMdiMainFrm::activatePrevWin
virtual void activatePrevWin()
Activates the previous open view.
Definition: tdemdimainfrm.cpp:2322
KMdiMainFrm::setEnableMaximizedChildFrmMode
virtual void setEnableMaximizedChildFrmMode(bool bEnable)
If in Childframe mode, we can switch between maximized or restored shown MDI views.
Definition: tdemdimainfrm.cpp:2422
KMdiMainFrm::hideViewTaskBar
virtual void hideViewTaskBar()
Hides the view taskbar.
Definition: tdemdimainfrm.cpp:2550
KMdiMainFrm::isViewTaskBarOn
bool isViewTaskBarOn()
Shows the view taskbar.
Definition: tdemdimainfrm.cpp:2534
KMdiChildView::isMinimized
bool isMinimized() const
Tells if the window is minimized when attached to the Mdi manager, or if it is VISIBLE when 'floating...
Definition: tdemdichildview.cpp:308
KMdiMainFrm::setTabWidgetVisibility
void setTabWidgetVisibility(KMdi::TabWidgetVisibility)
Set tabwidget visibility.
Definition: tdemdimainfrm.cpp:2923

tdemdi

Skip menu "tdemdi"
  • Main Page
  • Namespace List
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

tdemdi

Skip menu "tdemdi"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  •     tdecore
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  • tdeioslave
  •   http
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdemdi by doxygen 1.8.8
This website is maintained by Timothy Pearson.