Source Code (Use browser search to find items of interest.)
Class Index
kdelibs'KDockManager (./kdelibs/kdeui/kdockwidget.h:557)
class KDockManager: public QObject
{
Q_OBJECT
friend class KDockWidget;
friend class KDockMainWindow;
public:
/**
* Constructs a dockmanager. Some initialization happen:
* <UL><LI>It installs an event filter for the main window,</LI>
* <LI>a control list for dock objects</LI>
* <LI>a control list for menu items concerning to menus provided by the dockmanager</LI>
* <LI>Some state variables are set</LI></UL>
*
* @param mainWindow the main window controlled by this
* @param name the internal QOject name
*/
KDockManager( QWidget* mainWindow, const char* name = 0L );
/**
* Destructs a dockmanager.
*/
virtual ~KDockManager();
/**
* Saves the current state of the dockmanager and of all controlled widgets.
* State means here to save the geometry, visibility, parents, internal object names, orientation,
* separator positions, dockwidget-group information, tab widget states (if it is a tab group) and
* last but not least some necessary things for recovering the dockmainwindow state.
*
* @param c the KDE configuration saver
* @param group the name of the section in KConfig
*/
void writeConfig( KConfig* c = 0L, QString group = QString::null );
/**
* Like writeConfig but reads the whole stuff in.
*
* @param c the KDE configuration saver
* @param group the name of the section in KConfig
*/
void readConfig ( KConfig* c = 0L, QString group = QString::null );
/**
* Shows all encapsulated widgets of all controlled dockwidgets and shows all dockwidgets which are
* parent of a dockwidget tab group.
*/
void activate();
/**
* It's more or less a method that catches several events which are interesting for the dockmanager.
* Mainly mouse events during the drag process of a dockwidgets are of interest here.
*
* @param _ the object that sends the event
* @param _ the event
* @return the return value of the method call of the base class method
*/
virtual bool eventFilter( QObject *, QEvent * );
/**
* This method finds out what a widgets' dockwidget is. That means the dockmanager has a look at all
* dockwidgets it knows and tells you when one of those dockwidgets covers the given widget.
*
* @param w any widget that is supposed to be encapsulated by one of the controlled dockwidgets
* @return the dockwidget that encapsulates that widget, otherwise 0
*/
KDockWidget* findWidgetParentDock( QWidget* w);
/**
* Works like makeDockVisible() but can be called for widgets that covered by a dockwidget.
*
* @param w the widget that is encapsulated by a dockwidget that turns to visible.
*/
void makeWidgetDockVisible( QWidget* w ){ findWidgetParentDock(w)->makeDockVisible(); }
/**
* @return the popupmenu for showing/hiding dockwidgets
*/
QPopupMenu* dockHideShowMenu(){ return menu; }
/**
* @param dockName an internal QObject name
* @return the dockwidget that has got that internal QObject name
*/
KDockWidget* getDockWidgetFromName( const QString& dockName );
signals:
/**
* Signals changes of the docking state of a dockwidget. Usually the dock-toolbar will be updated then.
*/
void change();
/**
* Signals a dockwidget is replaced with another one.
*/
void replaceDock( KDockWidget* oldDock, KDockWidget* newDock );
/**
* Signals a dockwidget without parent (toplevel) is shown.
*/
void setDockDefaultPos( KDockWidget* );
private slots:
/**
* Clears the popupmenu for showing/hiding dockwidgets and fills it with the current states of all controlled dockwidgets.
*/
void slotMenuPopup();
/**
* This method assumes a menuitem of the popupmenu for showing/hiding dockwidgets is selected and toggles that state.
*
* @param id the popupmenu id of the selected menuitem
*/
void slotMenuActivated( int id);
private:
/**
* A data structure containing data about every dockwidget that is under control.
*/
struct MenuDockData
{
MenuDockData( KDockWidget* _dock, bool _hide )
{
dock = _dock;
hide = _hide;
};
~MenuDockData(){};
KDockWidget* dock;
bool hide;
};
/**
* Finds the KDockWidget at the position given as parameter
*
* @param pos global (desktop) position of the wanted dockwidget
* @return the dockwidget at that position
*/
KDockWidget* findDockWidgetAt( const QPoint& pos );
/**
* Finds the QWidget recursively at the position given as parameter
*
* @param w a variable where the method puts the QWidget at that position (instead of a return value)
* @param p the parent widget where the recursive search should start from
* @param pos global (desktop) position of the wanted dockwidget
*/
void findChildDockWidget( QWidget*& w, const QWidget* p, const QPoint& pos );
/**
* Finds all dockwidgets which are child, grandchild and so on of p.
*
* @param p the parent widget where the recursive search starts from
* @param l the widget list that contains the search result after the return of this method
*/
void findChildDockWidget( const QWidget* p, WidgetList*& l);
/**
* Sets a dockwidget in drag mode.
*/
void startDrag( KDockWidget* );
/**
* Moves a dockwidget that is in drag mode.
*
* @param d the dockwidget which is dragged
* @param pos the new position of the dragged dockwidget
*/
void dragMove( KDockWidget* d, QPoint pos );
/**
* Finishes the drag mode. If the user let it drop on an other dockwidget, it will possibly be docked (if allowed),
* otherwise it becomes toplevel.
*/
void drop();
// class members
/**
* Usually the KDockMainWindow but not necessarily.
*/
QWidget* main;
/**
* A special manager just for the dragging of a dockwidget
*/
KDockMoveManager* mg;
/**
* The dockwidget that is being dragged at the moment
*/
KDockWidget* currentDragWidget;
/**
* The target dockwidget where the currentDragWidget is dropped
*/
KDockWidget* currentMoveWidget; // widget where mouse moving
/**
* It is of interest during the dock process. Then it contains all child dockwidgets.
*/
WidgetList* childDockWidgetList;
/**
* The dockposition where the dockwidget would be docked to, if we dropped it here.
*/
KDockWidget::DockPosition curPos;
/**
* A QList of all objects that are important for docking.
* Some serve as group widgets of dockwidgets, others encapsulate normal widgets.
*/
QObjectList* childDock;
/**
* Contains dockwidgets that are created automatically by the dockmanager. For internal use.
*/
QObjectList* autoCreateDock;
/**
* For storing the width during the dragging of a dockwidget.
*/
int storeW;
/**
* For storing the height during the dragging of a dockwidget.
*/
int storeH;
/**
* State variable if there is a drag process active.
*/
bool draging;
/**
* State variable if there is an undock process active
*/
bool undockProcess;
/**
* The dockmanager sets it to true if one presses the Cancel key during the drag process.
*/
bool dropCancel;
/**
* A popup menu that contains one menuitem for each dockwidget that shows the current visibility state and
* to show or hide the appropriate dockwidget.
*/
QPopupMenu* menu;
/**
* An internal list containing data for the menuitems for the visibility popup menu.
*/
QList<MenuDockData> *menuData;
};
/**
* A special kind of @ref KTMainWindow that is able to have dockwidget child widgets (and member of the dockwidget class set).
*
* The main widget should be a @ref KDockWidget where other @ref KDockWidget can be docked to
* the left, right, top, bottom or to the middle.
* Note: dock to the middle means to drop on a dockwidget and to unite them to a new widget, a tab control.
* That tab widget is a @ref KDockTabCtl .
*
* Furthermore, the KDockMainWindow has got the @ref KDocManager and some data about the dock states.
*
* If you've got some dockwidgets, you can dock them to the dockmainwindow to initialize a start scene:
* Here an example:
* <PRE>
* DockApplication::DockApplication( const char* name) : KDockMainWindow( name)
* {
* ...
* KDockWidget* mainDock;
* mainDock = createDockWidget( "Falk's MainDockWidget", mainPixmap);
* AnyContentsWidget* cw( mainDock);
* setView( mainDock);
* setMainDockWidget( mainDock);
* ...
* KDockWidget* dockLeft;
* dockLeft = createDockWiget( "Intially left one", anyOtherPixmap);
* AnotherWidget* aw( dockLeft);
* dockLeft->manualDock( mainDock, // dock target
* KDockWidget::DockLeft, // dock site
* 20 ); // relation target/this (in percent)
* ...
* </PRE>
*
* Docking is fully dynamical at runtime. That means you can always move dockwidgets via drag and drop.
*
* Additionally, you get a toolbar for showing and hiding the 4 main dockwidgets which are docked to
* the actual mainwidget (that is usually a dockwidget as well).
*
* And last but not least you can use the popupmenu for showing or hiding any controlled dockwidget
* of this class and insert it to your main menu bar or anywhere else.
*
* @author Max Judin (documentation: Falk Brettschneider).
* @version $Id: kdockwidget.h,v 1.9 2000/04/11 22:22:25 falkbr Exp $
*/
kdelibs'KDockManager::KDockManager() (./kdelibs/kdeui/kdockwidget.cpp:1060)
KDockManager::KDockManager( QWidget* mainWindow , const char* name )
:QObject( 0, name )
{
main = mainWindow;
main->installEventFilter( this );
undockProcess = false;
menuData = new QList<MenuDockData>;
menuData->setAutoDelete( true );
menuData->setAutoDelete( true );
menu = new QPopupMenu();
connect( menu, SIGNAL(aboutToShow()), SLOT(slotMenuPopup()) );
connect( menu, SIGNAL(activated(int)), SLOT(slotMenuActivated(int)) );
childDock = new QObjectList();
childDock->setAutoDelete( false );
mg = 0L;
draging = false;
dropCancel = false;
}
kdelibs'KDockManager::~KDockManager() (./kdelibs/kdeui/kdockwidget.cpp:1084)
KDockManager::~KDockManager()
{
delete menuData;
delete menu;
QObjectListIt it( *childDock );
KDockWidget * obj;
while ( (obj=(KDockWidget*)it.current()) ) {
delete obj;
}
delete childDock;
}
kdelibs'KDockManager::activate() (./kdelibs/kdeui/kdockwidget.cpp:1098)
void KDockManager::activate()
{
QObjectListIt it( *childDock );
KDockWidget * obj;
while ( (obj=(KDockWidget*)it.current()) ) {
++it;
if ( obj->widget ) obj->widget->show();
if ( !obj->parentTabGroup() ){
obj->show();
}
}
if ( !main->inherits("QDialog") ) main->show();
}
kdelibs'KDockManager::eventFilter() (./kdelibs/kdeui/kdockwidget.cpp:1113)
bool KDockManager::eventFilter( QObject *obj, QEvent *event )
{
if ( obj == main && event->type() == QEvent::Resize && main->children() ){
QWidget* fc = (QWidget*)main->children()->getFirst();
if ( fc )
fc->setGeometry( QRect(QPoint(0,0), main->geometry().size()) );
}
#ifdef KeyPress
kdelibs'KDockManager::findDockWidgetAt() (./kdelibs/kdeui/kdockwidget.cpp:1194)
KDockWidget* KDockManager::findDockWidgetAt( const QPoint& pos )
{
if (currentDragWidget->eDocking == (int)KDockWidget::DockNone ) return 0L;
QWidget* p = QApplication::widgetAt( pos );
if ( !p ) return 0L;
QWidget* w = 0L;
findChildDockWidget( w, p, p->mapFromParent(pos) );
if ( !w ){
if ( !p->inherits("KDockWidget") ) return 0L;
w = p;
}
if ( qt_find_obj_child( w, "KDockSplitter", "_dock_split_" ) ) return 0L;
if ( qt_find_obj_child( w, "KDockTabGroup", "_dock_tab" ) ) return 0L;
if ( childDockWidgetList->find(w) != -1 ) return 0L;
if ( currentDragWidget->isGroup && ((KDockWidget*)w)->parentTabGroup() ) return 0L;
KDockWidget* www = (KDockWidget*)w;
if ( www->sDocking == (int)KDockWidget::DockNone ) return 0L;
KDockWidget::DockPosition curPos = KDockWidget::DockDesktop;
QPoint cpos = www->mapFromGlobal( pos );
int ww = www->widget->width() / 3;
int hh = www->widget->height() / 3;
if ( cpos.y() <= hh ){
curPos = KDockWidget::DockTop;
} else
if ( cpos.y() >= 2*hh ){
curPos = KDockWidget::DockBottom;
} else
if ( cpos.x() <= ww ){
curPos = KDockWidget::DockLeft;
} else
if ( cpos.x() >= 2*ww ){
curPos = KDockWidget::DockRight;
} else
curPos = KDockWidget::DockCenter;
if ( !(www->sDocking & (int)curPos) ) return 0L;
if ( !(currentDragWidget->eDocking & (int)curPos) ) return 0L;
if ( www->manager != this ) return 0L;
return www;
}
kdelibs'KDockManager::findChildDockWidget() (./kdelibs/kdeui/kdockwidget.cpp:1241)
void KDockManager::findChildDockWidget( QWidget*& ww, const QWidget* p, const QPoint& pos )
{
if ( p->children() ) {
QWidget *w;
QObjectListIt it( *p->children() );
it.toLast();
while ( it.current() ) {
if ( it.current()->isWidgetType() ) {
w = (QWidget*)it.current();
if ( w->isVisible() && w->geometry().contains(pos) ) {
if ( w->inherits("KDockWidget") ) ww = w;
findChildDockWidget( ww, w, w->mapFromParent(pos) );
return;
}
}
--it;
}
}
return;
}
kdelibs'KDockManager::findChildDockWidget() (./kdelibs/kdeui/kdockwidget.cpp:1262)
void KDockManager::findChildDockWidget( const QWidget* p, WidgetList*& list )
{
if ( p->children() ) {
QWidget *w;
QObjectListIt it( *p->children() );
it.toLast();
while ( it.current() ) {
if ( it.current()->isWidgetType() ) {
w = (QWidget*)it.current();
if ( w->isVisible() ) {
if ( w->inherits("KDockWidget") ) list->append( w );
findChildDockWidget( w, list );
}
}
--it;
}
}
return;
}
kdelibs'KDockManager::startDrag() (./kdelibs/kdeui/kdockwidget.cpp:1282)
void KDockManager::startDrag( KDockWidget* w )
{
currentMoveWidget = 0L;
currentDragWidget = w;
childDockWidgetList = new WidgetList();
childDockWidgetList->append( w );
findChildDockWidget( w, childDockWidgetList );
if ( mg ) delete mg;
mg = new KDockMoveManager( w );
curPos = KDockWidget::DockDesktop;
draging = true;
mg->doMove();
}
kdelibs'KDockManager::dragMove() (./kdelibs/kdeui/kdockwidget.cpp:1297)
void KDockManager::dragMove( KDockWidget* dw, QPoint pos )
{
QPoint p = dw->mapToGlobal( dw->widget->pos() );
KDockWidget::DockPosition oldPos = curPos;
QSize r = dw->widget->size();
if ( dw->parentTabGroup() ){
curPos = KDockWidget::DockCenter;
if ( oldPos != curPos ) mg->setGeometry( p.x()+2, p.y()+2, r.width()-4, r.height()-4 );
return;
}
int w = r.width() / 3;
int h = r.height() / 3;
if ( pos.y() <= h ){
curPos = KDockWidget::DockTop;
w = r.width();
} else
if ( pos.y() >= 2*h ){
curPos = KDockWidget::DockBottom;
p.setY( p.y() + 2*h );
w = r.width();
} else
if ( pos.x() <= w ){
curPos = KDockWidget::DockLeft;
h = r.height();
} else
if ( pos.x() >= 2*w ){
curPos = KDockWidget::DockRight;
p.setX( p.x() + 2*w );
h = r.height();
} else
{
curPos = KDockWidget::DockCenter;
p.setX( p.x() + w );
p.setY( p.y() + h );
}
if ( oldPos != curPos ) mg->setGeometry( p.x(), p.y(), w, h );
}
kdelibs'KDockManager::drop() (./kdelibs/kdeui/kdockwidget.cpp:1339)
void KDockManager::drop()
{
mg->stop();
delete childDockWidgetList;
if ( dropCancel ) return;
if ( !currentMoveWidget && ((currentDragWidget->eDocking & (int)KDockWidget::DockDesktop) == 0) ) return;
if ( !currentMoveWidget && !currentDragWidget->parent() )
currentDragWidget->move( mg->x(), mg->y() );
else
currentDragWidget->manualDock( currentMoveWidget, curPos , 50, QPoint(mg->x(), mg->y()) );
}
kdelibs'KDockManager::writeConfig() (./kdelibs/kdeui/kdockwidget.cpp:1352)
void KDockManager::writeConfig( KConfig* c, QString group )
{
//debug("BEGIN Write Config");
if ( !c ) c = kapp->config();
if ( group.isEmpty() ) group = "dock_setting_default";
c->setGroup( group );
c->writeEntry( "Version", DOCK_CONFIG_VERSION );
QStrList nameList;
QStrList findList;
QObjectListIt it( *childDock );
KDockWidget * obj;
// collect KDockWidget's name
QStrList nList;
while ( (obj=(KDockWidget*)it.current()) ) {
++it;
//debug(" +Add subdock %s", obj->name());
nList.append( obj->name() );
if ( obj->parent() == main )
c->writeEntry( "Main:view", obj->name() );
}
nList.first();
while ( nList.current() ){
//debug(" -Try to save %s", nList.current());
obj = getDockWidgetFromName( nList.current() );
QString cname = obj->name();
if ( obj->header ){
obj->header->saveConfig( c );
}
/*************************************************************************************************/
if ( obj->isGroup ){
if ( findList.find( obj->firstName.latin1() ) != -1 && findList.find( obj->lastName.latin1() ) != -1 ){
c->writeEntry( cname+":type", "GROUP");
if ( !obj->parent() ){
c->writeEntry( cname+":parent", "___null___");
c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":parent", "yes");
}
c->writeEntry( cname+":first_name", obj->firstName );
c->writeEntry( cname+":last_name", obj->lastName );
c->writeEntry( cname+":orientation", (int)obj->splitterOrientation );
c->writeEntry( cname+":sepPos", ((KDockSplitter*)obj->widget)->separatorPos() );
nameList.append( obj->name() );
findList.append( obj->name() );
//debug(" Save %s", nList.current());
nList.remove();
nList.first();
} else {
/*************************************************************************************************/
//debug(" Skip %s", nList.current());
//if ( findList.find( obj->firstName ) == -1 )
// debug(" ? Not found %s", obj->firstName);
//if ( findList.find( obj->lastName ) == -1 )
// debug(" ? Not found %s", obj->lastName);
nList.next();
if ( !nList.current() ) nList.first();
}
} else {
/*************************************************************************************************/
if ( obj->isTabGroup){
c->writeEntry( cname+":type", "TAB_GROUP");
if ( !obj->parent() ){
c->writeEntry( cname+":parent", "___null___");
c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":parent", "yes");
}
QStrList list;
for ( QWidget* w = ((KDockTabGroup*)obj->widget)->getFirstPage(); w; w = ((KDockTabGroup*)obj->widget)->getNextPage( w ) ){
list.append( w->name() );
}
c->writeEntry( cname+":tabNames", list );
c->writeEntry( cname+":curTab", ((KDockTabGroup*)obj->widget)->visiblePageId() );
nameList.append( obj->name() );
findList.append( obj->name() ); // not realy need !!!
//debug(" Save %s", nList.current());
nList.remove();
nList.first();
} else {
/*************************************************************************************************/
if ( !obj->parent() ){
c->writeEntry( cname+":type", "NULL_DOCK");
c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":type", "DOCK");
}
nameList.append( cname.latin1() );
//debug(" Save %s", nList.current());
findList.append( obj->name() );
nList.remove();
nList.first();
}
}
}
c->writeEntry( "NameList", nameList );
c->writeEntry( "Main:Geometry", QRect(main->frameGeometry().topLeft(), main->size()) );
c->writeEntry( "Main:visible", main->isVisible()); // curently nou use
if ( main->inherits("KDockMainWindow") ){
KDockMainWindow* dmain = (KDockMainWindow*)main;
// for KDockMainWindow->setView() in reafConfig()
c->writeEntry( "Main:view", dmain->view() ? dmain->view()->name():"" );
c->writeEntry( "Main:dock", dmain->getMainDockWidget() ? dmain->getMainDockWidget()->name() :"" );
}
c->sync();
//debug("END Write Config");
}
kdelibs'KDockManager::readConfig() (./kdelibs/kdeui/kdockwidget.cpp:1472)
void KDockManager::readConfig( KConfig* c, QString group )
{
if ( !c ) c = kapp->config();
if ( group.isEmpty() ) group = "dock_setting_default";
c->setGroup( group );
QStrList nameList;
c->readListEntry( "NameList", nameList );
QString ver = c->readEntry( "Version", "0.0.1" );
nameList.first();
if ( !nameList.current() || ver != DOCK_CONFIG_VERSION ){
activate();
return;
}
autoCreateDock = new QObjectList();
autoCreateDock->setAutoDelete( true );
bool isMainVisible = main->isVisible();
main->hide();
QObjectListIt it( *childDock );
KDockWidget * obj;
while ( (obj=(KDockWidget*)it.current()) ){
++it;
if ( !obj->isGroup && !obj->isTabGroup )
{
if ( obj->parent() ) obj->undock(); else obj->hide();
}
}
nameList.first();
while ( nameList.current() ){
QString oname = nameList.current();
c->setGroup( group );
QString type = c->readEntry( oname + ":type" );
obj = 0L;
if ( type == "GROUP" ){
KDockWidget* first = getDockWidgetFromName( c->readEntry( oname + ":first_name" ) );
KDockWidget* last = getDockWidgetFromName( c->readEntry( oname + ":last_name" ) );
int sepPos = c->readNumEntry( oname + ":sepPos" );
Orientation p = (Orientation)c->readNumEntry( oname + ":orientation" );
if ( first && last ){
obj = first->manualDock( last, ( p == Vertical ) ? KDockWidget::DockLeft : KDockWidget::DockTop, sepPos );
if (obj){
obj->setName( oname.latin1() );
}
}
}
if ( type == "TAB_GROUP" ){
QStrList list;
KDockWidget* tabDockGroup = 0L;
c->readListEntry( oname+":tabNames", list );
KDockWidget* d1 = getDockWidgetFromName( list.first() );
list.next();
KDockWidget* d2 = getDockWidgetFromName( list.current() );
tabDockGroup = d2->manualDock( d1, KDockWidget::DockCenter );
if ( tabDockGroup ){
KDockTabGroup* tab = (KDockTabGroup*)tabDockGroup->widget;
list.next();
while ( list.current() && tabDockGroup ){
KDockWidget* tabDock = getDockWidgetFromName( list.current() );
tabDockGroup = tabDock->manualDock( d1, KDockWidget::DockCenter );
list.next();
}
if ( tabDockGroup ){
tabDockGroup->setName( oname.latin1() );
c->setGroup( group );
tab->setVisiblePage( c->readNumEntry( oname+":curTab" ) );
}
}
obj = tabDockGroup;
}
if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
QRect r = c->readRectEntry( oname + ":geometry" );
obj = getDockWidgetFromName( oname );
obj->applyToWidget( 0L );
obj->setGeometry(r);
c->setGroup( group );
if ( c->readBoolEntry( oname + ":visible" ) ){
obj->QWidget::show();
}
}
if ( type == "DOCK" ){
obj = getDockWidgetFromName( oname );
}
if ( obj && obj->header){
obj->header->loadConfig( c );
}
nameList.next();
}
// delete all autocreate dock
delete autoCreateDock;
autoCreateDock = 0L;
if ( main->inherits("KDockMainWindow") ){
KDockMainWindow* dmain = (KDockMainWindow*)main;
c->setGroup( group );
QString mv = c->readEntry( "Main:view" );
if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
KDockWidget* mvd = getDockWidgetFromName( mv );
mvd->applyToWidget( dmain );
mvd->show();
dmain->setView( mvd );
}
c->setGroup( group );
QString md = c->readEntry( "Main:dock" );
if ( !md.isEmpty() && getDockWidgetFromName( md ) ){
KDockWidget* mvd = getDockWidgetFromName( md );
dmain->setMainDockWidget( mvd );
}
} else {
c->setGroup( group );
QString mv = c->readEntry( "Main:view" );
if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
KDockWidget* mvd = getDockWidgetFromName( mv );
mvd->applyToWidget( main );
mvd->show();
}
}
c->setGroup( group );
QRect mr = c->readRectEntry("Main:Geometry");
main->setGeometry(mr);
if ( isMainVisible ) main->show();
}
kdelibs'KDockManager::getDockWidgetFromName() (./kdelibs/kdeui/kdockwidget.cpp:1610)
KDockWidget* KDockManager::getDockWidgetFromName( const QString& dockName )
{
QObjectListIt it( *childDock );
KDockWidget * obj;
while ( (obj=(KDockWidget*)it.current()) ) {
++it;
if ( QString(obj->name()) == dockName ) return obj;
}
KDockWidget* autoCreate = 0L;
if ( autoCreateDock ){
autoCreate = new KDockWidget( this, dockName.latin1(), QPixmap("") );
autoCreateDock->append( autoCreate );
}
return autoCreate;
}
kdelibs'KDockManager::slotMenuPopup() (./kdelibs/kdeui/kdockwidget.cpp:1627)
void KDockManager::slotMenuPopup()
{
menu->clear();
menuData->clear();
QObjectListIt it( *childDock );
KDockWidget * obj;
int numerator = 0;
while ( (obj=(KDockWidget*)it.current()) ) {
++it;
if ( obj->mayBeHide() )
{
menu->insertItem( *obj->pix, QString("Hide ") + obj->caption(), numerator++ );
menuData->append( new MenuDockData( obj, true ) );
}
if ( obj->mayBeShow() )
{
menu->insertItem( *obj->pix, QString("Show ") + obj->caption(), numerator++ );
menuData->append( new MenuDockData( obj, false ) );
}
}
}
kdelibs'KDockManager::slotMenuActivated() (./kdelibs/kdeui/kdockwidget.cpp:1651)
void KDockManager::slotMenuActivated( int id )
{
MenuDockData* data = menuData->at( id );
data->dock->changeHideShowState();
}
kdelibs'KDockManager::findWidgetParentDock() (./kdelibs/kdeui/kdockwidget.cpp:1657)
KDockWidget* KDockManager::findWidgetParentDock( QWidget* w )
{
QObjectListIt it( *childDock );
KDockWidget * dock;
KDockWidget * found = 0L;
while ( (dock=(KDockWidget*)it.current()) ) {
++it;
if ( dock->widget == w ){ found = dock; break; }
}
return found;
}