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

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
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdemdi by doxygen 1.8.17
This website is maintained by Timothy Pearson.