Source Code (Use browser search to find items of interest.)
Class Index
kdelibs'KTMainWindow (./kdelibs/kdeui/ktmainwindow.h:97)
class KTMainWindow : public QWidget, public KXMLGUIBuilder, virtual public KXMLGUIClient
{
Q_OBJECT
friend class KToolBar;
friend class KTLWSessionManaged;
public:
/**
* Construct a main window.
*
* @param name The object name. For session management to work
* properly, all main windows in the application have to have a
* different name. When passing 0 (the default), KTMainWindow will create
* such a name for you. So simply never pass anything else ;-)
*
* @param f Specify the widget flags. The default is WDestructiveClose.
* It indicates that a main window is automatically destroyed when its
* window is closed. Pass 0 if you do not want this behaviour.
*
* KTMainWindows must be created on the heap with 'new', like:
* <pre> KTMainWindow *ktmw = new KTMainWindow (...</pre>
**/
KTMainWindow( const char *name = 0L, WFlags f = WDestructiveClose );
/**
* Destructor.
*
* Will also destroy the toolbars, and menubar if
* needed.
*/
~KTMainWindow();
/**
* Add a toolbar to the widget.
*
* A toolbar added to this widget will be automatically laid out
* by it.
*
* The toolbar must have been created with this instance of
* KTMainWindow as its parent.
*
* Usually you do not need this function. Just refer to a toolbar
* with @ref toolBar(index) instead and the KTMainWindow will
* create it for you. Anyway @ref addToolBar() is useful if you want
* to pass additional arguments to the toolbar's constructor.
*/
int addToolBar( KToolBar *toolbar, int index = -1 );
/**
* Set the main client widget.
*
* This is the main widget for your application; it's geometry
* will be automatically managed by KTMainWindow to fit the
* client area, constrained by the positions of the menu, toolbars
* and status bar. It can be fixed-width or Y-fixed.
*
* Only one client widget can be handled at a time. Multiple calls
* of @ref setView() will cause only the last widget to be added to be
* properly handled. The layout management will not start before this
* function has been called. It increases the application start
* speed to call this function after all bars have been registered. The
* presence of the view widget is mandatory for the class to operate.
*
* The widget must have been created with this instance of
* KTMainWindow as its parent.
*/
void setView( QWidget *view, bool show_frame = TRUE );
/**
* Retrieve the view widget.
*
* @see setView()
**/
QWidget *view() const { return kmainwidget; }
/**
* Set the given widget as the "indicator" widget found either in
* the menubar or the statusbar. The widget may be any size...
* but keep in mind where it will be going. A maximum size of
* 30x22 is recommended.
*
* @param indicator The widget to be displayed in the indicator space
*/
void setIndicatorWidget( QWidget *indicator );
/**
* @return A pointer to the indicator widget or 0L if it doesn't
* exist.
*/
QWidget *indicator();
/**
* Enable or disable the status bar.
*/
void enableStatusBar( KStatusBar::BarStatus stat = KStatusBar::Toggle );
/**
* Enable or disable the toolbar with the specified @id.
*
* If no id is specified, the default id of 0 is used.
*/
void enableToolBar( KToolBar::BarStatus stat = KToolBar::Toggle,
int id = 0 );
/**
* Enable or disable the toolbar with the specified name (as
* determined by the XML UI framework).
*/
void setEnableToolBar( KToolBar::BarStatus stat = KToolBar::Toggle,
const QString& name = "mainToolBar" );
/**
* Set the width of the view frame.
*
* If you request a frame around your view with @ref setView(...,TRUE),
* you can use this function to set the border width of the frame.
* The default is 1 pixel. You should call this function before
* @ref setView().
*/
void setFrameBorderWidth( int );
/**
* Set the maximum number of wraps for a single block of
* subsequent non-full-size tool bars.
*
* If more wraps would be
* necessary to properly layout the tool bars the bars will extend
* outside of the window. This behaviour is helpful when having
* many toolbars on small displays. Not all toolbars are
* accessible any longer but at least the main view keeps
* reasonably visible and is not squished by all the tool
* bars. Since the user cannot easily distinguish between
* full-size and non full-size bars, they should not be mixed when
* using this function. Technically there is no reason but it is
* very confusing when some bars automatically wrap (full-size
* bars) while other extend out of sight. See @ref KTMLayout for
* more details. The toolbar wrapping limitation is disabled by
* default.
**/
void setMaximumToolBarWraps(unsigned int wraps);
/**
* Retrieve a pointer to the toolbar with the specified ID.
*
* If there is no such tool bar yet, it will be generated.
**/
KToolBar *toolBar( int ID = 0 );
/**
* Retrieve a pointer to the toolbar with the specified name.
* This refers to toolbars created dynamically from the XML UI
* framework. If the toolbar does not exist, then 0L will be
* returned.
*
* @param name The internal name of the toolbar ("mainToolBar",
* for instance)
*
* @return A pointer to the toolbar or 0L if it doesn't exist
**/
KToolBar *toolBar( const QString& name );
/**
* Retrieve a pointer to the menu bar.
*
* If there is no
* menu bar yet on will be created.
**/
KMenuBar *menuBar();
/**
* If you constructed a @ref KMenuBar yourself, you must set it with this
* function.
*
* You can use it also if you want to replace an old menu bar
* with a new one. There can be only one menu bar at a time. After this
* function is called the layout will be updated.
* @see menuBar()
*/
void setMenu (KMenuBar *menuBar);
/**
* Retreieve a pointer to the status bar.
*
* If there is no
* status bar yet one will be created.
*/
KStatusBar *statusBar();
/**
* If you constructed a @ref KStatusBar yourself, you must set it with this
* function.
*
* You can use it also if you want to replace an old status bar
* with a new one. There can be only one status bar at a time. After this
* function is called the layout will be updated.
* @see statusBar()
*/
void setStatusBar (KStatusBar *statusBar);
/**
* Show the toplevel widget.
*
* Reimplemented from @ref QWidget. Calls
* @ref updateRects() (i.e. updates layout).
*/
virtual void show ();
/**
* Retrieve the minimum size of the main window.
*/
QSize sizeHint() const;
/**
* Retrieve the geometry of the main view widget. This function is provided
* for legacy reasons. Do not use it! It might be removed.
*/
QRect mainViewGeometry() const;
/**
* Retrieve the standard help menu which contains entires for the
* help system (activated by F1), an optional "What's This?" entry
* (activated by Shift F1), an application specific dialog box,
* and an "About KDE" dialog box.
*
* Example (adding a standard help menu to your application):
* <pre>
* QPopupMenu *help = helpMenu( <myTextString> );
* menuBar()->insertItem( i18n("&Help"), help );
* </pre>
*
* @param aboutAppText The string that is used in the application
* specific dialog box. Note: The help menu will not open
* this dialog box if you don't define a string.
*
* @param showWhatsThis Set this to false if you do not want to include
* the "What's This" menu entry.
*
* @return A standard help menu.
*/
QPopupMenu* helpMenu( const QString &aboutAppText=QString::null,
bool showWhatsThis=true );
/**
* @sect Session Management
*
* Try to restore the toplevel widget as defined by the number (1..X).
*
* If the session did not contain so high a number, the configuration
* is not changed and @p false returned.
*
* That means clients could simply do the following:
* <pre>
* if (kapp->isRestored()){
* int n = 1;
* while (KTMainWindow::canBeRestored(n)){
* (new childTLW)->restore(n);
* n++;
* }
* } else {
* // create default application as usual
* }
* </pre>
* Note that @ref QWidget::show() is called implicitly in restore.
*
* With this you can easily restore all toplevel windows of your
* application.
*
* If your application uses different kinds of toplevel
* windows, then you can use @ref KTMainWindow::classNameOfToplevel(n)
* to determine the exact type before calling the childTLW
* constructor in the example from above.
*
* If your client has only one kind of toplevel widgets (which should
* be pretty usual) then you should use the RESTORE-macro:
*
* <pre>
* if (kapp->isRestored())
* RESTORE(childTLW)
* else {
* // create default application as usual
* }
* </pre>
*
* The macro expands to the term above but is easier to use and
* less code to write.
*
* @see restore()
* @see classNameOfToplevel()
*
*/
static bool canBeRestored(int number);
/**
* Retrieve the @ref className() of the @p number th toplevel window which
* should be restored.
*
* This is only useful if you application uses
* different kinds of toplevel windows.
*/
static const QString classNameOfToplevel(int number);
/**
* Restore the session specified by @p number.
*
* Return @p false if this
* fails, otherwise returns @p true and shows the window.
* You should call @ref canBeRestored() first.
*/
bool restore(int number);
/**
* @sect Methods you probably don't need.
*
* You probably do not need this.
*
* Anyway, if you are porting code
* which had been written for the former @ref KTMainWindow you may
* find the following three boolean "has" functions useful.
*
* @return @p true if the menubar exists.
*/
bool hasMenuBar();
/**
* @return @p true if the statusbar exists.
*/
bool hasStatusBar();
/**
* @return @p true if the specified toolbar exists.
*/
bool hasToolBar( int ID = 0 );
virtual KXMLGUIFactory *guiFactory();
/**
* Create a GUI given a local XML file. If @ref #xmlfile is NULL,
* then it will try to construct a local XML filename like
* appnameui.rc where 'appname' is your app's name. If that file
* does not exist, then the XML UI code will only use the global
* (standard) XML file for the layout purposes.
*
* @param xmlfile The local xmlfile (relative or absolute)
*/
virtual void createGUI( const QString &xmlfile = QString::null );
protected:
/**
* @sect And now back to methods you might need...
*
* Default implementation calls @ref #updateRects if main widget
* is resizable. If mainWidget is not resizable it does
* nothing. You shouldn't need to override this function.
*/
virtual void resizeEvent( QResizeEvent *e );
/**
* We need to trap the layout hint. Otherwise we will miss when our
* view widget or some bar changes the size constrains on it's own.
*/
virtual bool event(QEvent *);
/**
* Default implementation just calls repaint (FALSE); You may
* reimplement this function if you want to.
*/
virtual void focusInEvent ( QFocusEvent *);
/**
* Default implementation just calls repaint (FALSE); You may
* reimplement this function if you want to.
*/
virtual void focusOutEvent ( QFocusEvent *);
/**
* Reimplemented to call the queryClose() and queryExit() handlers.
*
* We recommend to reimplement the handlers rather than closeEvent().
* If you do it anyway, ensure to call the base implementation to keep
* queryExit() running.
*/
virtual void closeEvent ( QCloseEvent *);
/**
Called before the very last window is closed, either by the
user or indirectely by the session manager.
It is not recommended to do any user interaction in this
function other than indicating severe errors. Better ask the
user on queryClose() (see below).
However, queryExit() is useful to do some final cleanups. A
typical example would be to write configuration data back.
Note that the application may continue to run after queryExit()
(the user may have cancelled a shutdown). The purpose of
queryExit() is purely to prepare the application (with possible
user interaction) so it can safely be closed later (without
user interaction).
If you need to do serious things on exit (like shutting a
dial-up connection down), connect to the signal
@ref KApplication::shutDown().
Default implementation returns true. Returning false will
cancel the exiting. In the latter case, the last window will
remain visible.
@see #queryClose
*/
virtual bool queryExit();
/**
Called before the window is closed, either by the user or indirectely by
the session manager.
The purpose of this function is to prepare the window in a way that it is
safe to close it, i.e. without the user losing some data.
Default implementation returns true. Returning false will cancel
the closing.
Reimplement this function to prevent the user from loosing data.
Example:
<pre>
switch ( KMessageBox::warningYesNoCancel( this,
i18n("Save changes to Document Foo?")) ) {
case KMessageBox::Yes :
// save document here. If saving fails, return FALSE;
return TRUE;
case KMessageBox::No :
return TRUE;
default: // cancel
return FALSE;
</pre>
@see queryExit()
*/
virtual bool queryClose();
/**
* Save your instance-specific properties. The function is
* invoked when the session manager requests your application
* to save its state.
*
* You MUST NOT change the group of the kconfig object, since
* KTMainWindow uses one group for each window. Please
* reimplement these function in childclasses.
*
* Note that no user interaction is allowed
* in this function!
*
*/
virtual void saveProperties(KConfig*){};
/**
* Read your instance-specific properties.
*/
virtual void readProperties(KConfig*){};
/**
* Save your application-wide properties. The function is
* invoked when the session manager requests your application
* to save its state.
*
* The function is similar to saveProperties() but is only called for
* the very first main window, regardless how many main window are open.
* Override it if you need to save other data about your documents on
* session end. sessionConfig is a config to which that data should be
* saved. Normally, you don't need this function. But if you want to save
* data about your documents that are not in opened windows you might need
* it.
*
* Default implementation does nothing.
*/
virtual void saveGlobalProperties(KConfig* sessionConfig);
/**
* The counter-part of saveGlobalProperties(). Reads the application
* specific properties in again.
*/
virtual void readGlobalProperties(KConfig* sessionConfig);
public slots:
/**
* Makes a KDE compliant caption.
*
* @param caption Your caption. DO NOT include the application name
* in this string. It will be added automatically according to the KDE
* standard.
*/
virtual void setCaption( const QString &caption );
/**
* Makes a plain caption without any modifications.
*
* @param caption Your caption. This is the string that will be
* displayed in the window title.
*/
virtual void setPlainCaption( const QString &caption );
/**
* Opens the help page for the application. The application name is
* used as a key to determine what to display and the system will attempt
* to open <appName>/index.html.
*
* This method is intended for use by a help button in the toolbar or
* components outside the regular help menu. Use @ref helpMenu when you
* want to provide access to the help system from the help menu.
*
* Example (adding a help button to the first toolbar):
*
* <pre>
* KIconLoader &loader = *KGlobal::iconLoader();
* QPixmap pixmap = loader.loadIcon( "help" );
* toolBar(0)->insertButton( pixmap, 0, SIGNAL(clicked()),
* this, SLOT(appHelpActivated()), true, i18n("Help") );
* </pre>
*
*/
void appHelpActivated( void );
protected slots:
/**
* This slot must be called whenever the arrangement of the child element
* has been changed. It needs not to be called for a resize operation.
* This is handled by Qt layout management.
*/
virtual void updateRects();
/**
* This slot does nothing. It must be reimplemented if you want
* to use a custom About Application dialog box. This slot is
* connected to the "About Application" entry in the menu returned
* by @ref helpMenu if and only if the text argument to @ref helpMenu
* is empty (QString::null).
*
* Example:
* <pre>
*
* void MyTopLevel::setupInterface()
* {
* ..
* QPopupMenu *help = helpMenu();
* menuBar()->insertItem( i18n("&Help"), help );
* ..
* }
*
* void MyTopLevel::showAboutApplication( void )
* {
* <activate your custom dialog>
* }
* </pre>
*/
void showAboutApplication( void );
private slots:
/**
* Notices when toolbar is deleted.
*/
void toolbarKilled();
/**
* Notices when menubar is killed.
*/
void menubarKilled();
public:
/**
* List of members of KTMainWindow class
*/
static QList<KTMainWindow>* memberList;
private:
/**
* List of toolbars.
*/
QList <KToolBar> toolbars;
/**
* Main widget. If you want fixed-widget just call setFixedSize(w.h)
* on your mainwidget.
* You should not setFixedSize on KTMainWindow.
*/
QWidget *kmainwidget;
/**
* Menubar.
*/
KMenuBar *kmenubar;
/**
* Statusbar
*/
KStatusBar *kstatusbar;
/**
* Frame around main widget
*/
QFrame *kmainwidgetframe;
/**
* Stores the width of the view frame
*/
int borderwidth;
/**
* True if toolbars are killed by this destructor.
*/
bool localKill;
KTMLayout* layoutMgr;
KHelpMenu *mHelpMenu;
KTMainWindowPrivate *d;
protected:
void savePropertiesInternal (KConfig*, int);
bool readPropertiesInternal (KConfig*, int);
};
kdelibs'KTMainWindow::KTMainWindow() (./kdelibs/kdeui/ktmainwindow.cpp:124)
KTMainWindow::KTMainWindow( const char *name, WFlags f )
: QWidget( 0L, name, f ), KXMLGUIBuilder( this )
{
d = new KTMainWindowPrivate();
initing = TRUE;
kmenubar = 0L;
kmainwidget = 0L;
kstatusbar = 0L;
borderwidth = 0;
mHelpMenu = 0L;
kmainwidgetframe = new QFrame( this );
CHECK_PTR( kmainwidgetframe );
kmainwidgetframe ->setFrameStyle( QFrame::Panel | QFrame::Sunken);
kmainwidgetframe ->setLineWidth(0);
kmainwidgetframe ->hide();
kapp->setTopWidget( this );
// see if there already is a member list
if( !memberList )
memberList = new QList<KTMainWindow>;
if ( !ksm )
ksm = new KTLWSessionManaged();
// enter the widget in the list of all KTWs
memberList->append( this );
if ( !name ) {
// set a unique object name. Required by session management.
QCString s;
s.setNum( memberList->count() );
setName( kapp->instanceName() + "-mainwindow#" + s );
}
localKill = false;
layoutMgr = 0;
initing = FALSE;
}
kdelibs'KTMainWindow::~KTMainWindow() (./kdelibs/kdeui/ktmainwindow.cpp:169)
KTMainWindow::~KTMainWindow()
{
localKill = true;
// remove this widget from the member list
memberList->remove( this );
// delete all toolbars (necessary if they are floating)
KToolBar *toolbar = 0;
for (toolbar = toolbars.first(); toolbar != 0L; toolbar = toolbars.next() ) {
if (toolbar->barPos() == KToolBar::Floating
&& !QApplication::closingDown()) {
//kdDebug(200) << "KTM destructor: deleted toolbar" << endl;
delete toolbar;
}
}
if (kmenubar) {
delete kmenubar; // Eeeh? (sven)
kdDebug(200) << "KTM destructor: deleted menubar" << endl;
} else {
kdDebug(200) << "KTM destructor: Menubar deleted, donīt wanna hurt myself" << endl;
}
/* I'm not sure if the layoutMgr is deleted by Qt. So I leave it out until
* I have some time to look at this further. */
// delete layoutMgr;
//if (!QApplication::closingDown())
delete mHelpMenu;
delete d;
kdDebug(200) << "KTM destructor: end" << endl;
}
kdelibs'KTMainWindow::closeEvent() (./kdelibs/kdeui/ktmainwindow.cpp:209)
void KTMainWindow::closeEvent ( QCloseEvent *e){
if (queryClose()) {
e->accept();
int not_withdrawn = 0;
QListIterator<KTMainWindow> it(*KTMainWindow::memberList);
for (it.toFirst(); it.current(); ++it){
if ( !it.current()->testWState( WState_ForceHide ) )
not_withdrawn++;
}
if ( !no_query_exit && not_withdrawn <= 1 ) { // last window close accepted?
if ( queryExit() ) { // Yes, Quit app?
kapp->quit(); // ...and quit aplication.
} else {
// cancel closing, it's stupid to end up with no windows at all....
e->ignore();
}
}
}
kdDebug(200) << "KTM CloseEvent end" << endl;
}
kdelibs'KTMainWindow::queryClose() (./kdelibs/kdeui/ktmainwindow.cpp:232)
bool KTMainWindow::queryClose()
{
return true;
}
kdelibs'KTMainWindow::queryExit() (./kdelibs/kdeui/ktmainwindow.cpp:237)
bool KTMainWindow::queryExit(){
return true;
}
kdelibs'KTMainWindow::addToolBar() (./kdelibs/kdeui/ktmainwindow.cpp:241)
int KTMainWindow::addToolBar( KToolBar *toolbar, int index )
{
if ( index == -1 )
toolbars.append( toolbar );
else
toolbars.insert( index, toolbar );
index = toolbars.at();
connect ( toolbar, SIGNAL( moved (BarPosition) ),
this, SLOT( updateRects() ) );
connect (toolbar, SIGNAL(destroyed ()), this, SLOT(toolbarKilled ()));
updateRects();
return index;
}
kdelibs'KTMainWindow::setView() (./kdelibs/kdeui/ktmainwindow.cpp:255)
void KTMainWindow::setView( QWidget *view, bool show_frame )
{
kmainwidget = view;
if( show_frame ){
// Set a default frame borderwidth, for a toplevelwidget with
// frame.
if(borderwidth == 0 )
setFrameBorderWidth(0);
kmainwidgetframe->show();
}
// In the case setView(...,TRUE),
// we leave the default frame borderwith at 0 so that we don't get
// an unwanted border -- after all we didn't request a frame. If you
// still want a border ( though no frame, call setFrameBorderWidth()
// before setView(...,FALSE).
}
kdelibs'KTMainWindow::focusInEvent() (./kdelibs/kdeui/ktmainwindow.cpp:277)
void KTMainWindow::focusInEvent( QFocusEvent *)
{
repaint( FALSE );
}
kdelibs'KTMainWindow::focusOutEvent() (./kdelibs/kdeui/ktmainwindow.cpp:282)
void KTMainWindow::focusOutEvent( QFocusEvent *)
{
repaint( FALSE );
}
kdelibs'KTMainWindow::show() (./kdelibs/kdeui/ktmainwindow.cpp:287)
void KTMainWindow::show ()
{
QWidget::show();
updateRects();
}
kdelibs'KTMainWindow::setCaption() (./kdelibs/kdeui/ktmainwindow.cpp:294)
void KTMainWindow::setCaption( const QString &caption )
{
if ( initing ) // we are in our constructor
return;
QWidget::setCaption( kapp->makeStdCaption(caption) );
}
kdelibs'KTMainWindow::setPlainCaption() (./kdelibs/kdeui/ktmainwindow.cpp:302)
void KTMainWindow::setPlainCaption( const QString &caption )
{
QWidget::setCaption( caption );
}
kdelibs'KTMainWindow::sizeHint() (./kdelibs/kdeui/ktmainwindow.cpp:307)
QSize KTMainWindow::sizeHint() const
{
if (layoutMgr)
return layoutMgr->sizeHint();
return (QSize(-1, -1));
}
kdelibs'KTMainWindow::mainViewGeometry() (./kdelibs/kdeui/ktmainwindow.cpp:315)
QRect KTMainWindow::mainViewGeometry() const
{
return (kmainwidget ? kmainwidget->geometry() : QRect());
}
kdelibs'KTMainWindow::updateRects() (./kdelibs/kdeui/ktmainwindow.cpp:320)
void KTMainWindow::updateRects()
{
if (!isUpdatesEnabled())
return;
delete layoutMgr;
layoutMgr = new KTMLayout(this);
CHECK_PTR(layoutMgr);
/* add menu bar */
if (kmenubar && kmenubar->isVisibleTo(this))
layoutMgr->addTopMenuBar(kmenubar);
/* add indicator widget */
if (d->m_indicator)
layoutMgr->addIndicatorWidget(d->m_indicator);
/* add toolbars */
for (toolbars.first(); toolbars.current(); toolbars.next())
if (toolbars.current()->isVisibleTo(this)) {
switch (toolbars.current()->barPos()) {
case KToolBar::Flat:
layoutMgr->addFlatBar(toolbars.current());
break;
case KToolBar::Top:
layoutMgr->addTopToolBar(toolbars.current());
break;
case KToolBar::Bottom:
layoutMgr->addBottomToolBar(toolbars.current());
break;
case KToolBar::Left:
layoutMgr->addLeftToolBar(toolbars.current());
break;
case KToolBar::Right:
layoutMgr->addRightToolBar(toolbars.current());
break;
default:
break;
}
}
/* add the main widget */
if (kmainwidget) {
if (kmainwidget->maximumWidth() > 0)
setMaximumWidth(kmainwidget->maximumWidth());
if (kmainwidget->maximumHeight() > 0)
setMaximumHeight(kmainwidget->maximumHeight());
layoutMgr->addMainItem(kmainwidget);
}
/* add the status bar */
if (kstatusbar && kstatusbar->isVisibleTo(this))
layoutMgr->addStatusBar(kstatusbar);
layoutMgr->activate();
}
kdelibs'KTMainWindow::saveGlobalProperties() (./kdelibs/kdeui/ktmainwindow.cpp:378)
void KTMainWindow::saveGlobalProperties(KConfig*)
{
}
kdelibs'KTMainWindow::readGlobalProperties() (./kdelibs/kdeui/ktmainwindow.cpp:382)
void KTMainWindow::readGlobalProperties(KConfig*)
{
}
kdelibs'KTMainWindow::savePropertiesInternal() (./kdelibs/kdeui/ktmainwindow.cpp:388)
void KTMainWindow::savePropertiesInternal (KConfig* config, int number)
{
QString entry;
QStrList entryList;
int n = 1; // Tolbar counter. toolbars are counted from 1,
// in order they are in toolbar list
QString s;
s.setNum(number);
s.prepend(QString::fromLatin1("WindowProperties"));
config->setGroup(s);
// store objectName, className, Width and Height for later restorating
config->writeEntry(QString::fromLatin1("ObjectName"), name());
config->writeEntry(QString::fromLatin1("ClassName"), className());
config->writeEntry(QString::fromLatin1("Width"), width() );
config->writeEntry(QString::fromLatin1("Height"), height() );
entryList.clear();
if (kstatusbar) {
if (kstatusbar->isVisible())
config->writeEntry(QString::fromLatin1("StatusBar"), QString::fromLatin1("Enabled"));
else
config->writeEntry(QString::fromLatin1("StatusBar"), QString::fromLatin1("Disabled"));
}
if (kmenubar) {
if (kmenubar->isVisible())
entryList.append("Enabled");
else
entryList.append("Disabled");
config->writeEntry(QString::fromLatin1("MenuBar"), entryList, ';');
entryList.clear();
}
KToolBar *toolbar;
QString toolKey;
for (toolbar = toolbars.first(); toolbar != 0L; toolbar = toolbars.next()) {
if (toolbar->isVisible())
entryList.append("Enabled");
else
entryList.append("Disabled");
switch (toolbar->barPos()) {
case KToolBar::Flat: //ignore
case KToolBar::Top:
entryList.append("Top");
break;
case KToolBar::Bottom:
entryList.append("Bottom");
break;
case KToolBar::Left:
entryList.append("Left");
break;
case KToolBar::Right:
entryList.append("Right");
break;
case KToolBar::Floating:
entryList.append("Floating");
entryList.append(KWM::properties(toolbar->winId()).ascii());
break;
}
toolKey.setNum(n);
toolKey.prepend(QString::fromLatin1("ToolBar"));
config->writeEntry(toolKey, entryList, ';');
entryList.clear();
n++;
}
s.setNum(number);
config->setGroup(s);
saveProperties(config);
}
kdelibs'KTMainWindow::readPropertiesInternal() (./kdelibs/kdeui/ktmainwindow.cpp:462)
bool KTMainWindow::readPropertiesInternal (KConfig* config, int number)
{
if ( number == 1 )
readGlobalProperties( config );
QString entry;
QStrList entryList;
int n = 1; // Tolbar counter. toolbars are counted from 1,
// in order they are in toolbar list
int i = 0; // Number of entries in list
QString s;
s.setNum(number);
s.prepend(QString::fromLatin1("WindowProperties"));
config->setGroup(s);
// restore the object name (window role )
if ( config->hasKey(QString::fromLatin1("ObjectName" )) )
setName( config->readEntry(QString::fromLatin1("ObjectName")).latin1()); // latin1 is right here
// restore the size
QSize size( config->readNumEntry( QString::fromLatin1("Width"), sizeHint().width() ),
config->readNumEntry( QString::fromLatin1("Height"), sizeHint().height() ) );
if ( size.isValid() )
resize( size );
if (kstatusbar) {
entry = config->readEntry(QString::fromLatin1("StatusBar"));
if (entry == QString::fromLatin1("Enabled"))
enableStatusBar(KStatusBar::Show);
else enableStatusBar(KStatusBar::Hide);
}
if (kmenubar) {
i = config->readListEntry (QString::fromLatin1("MenuBar"), entryList, ';');
bool showmenubar = false;
entry = entryList.first();
if (entry==QString::fromLatin1("Enabled"))
showmenubar = True;
else
kmenubar->hide();
entryList.clear();
if (showmenubar)
kmenubar->show();
}
KToolBar *toolbar;
QString toolKey;
QListIterator<KToolBar> it(toolbars); // must use own iterator
for ( ; it.current(); ++it) {
toolbar= it.current();
toolKey.setNum(n);
toolKey.prepend(QString::fromLatin1("ToolBar"));
i = config->readListEntry(toolKey, entryList, ';');
if (i < 2) {
kdDebug(200) << "KTM: bad number of toolbar args." << endl;
return FALSE;
}
bool showtoolbar = false;
entry = entryList.first();
if (entry==QString::fromLatin1("Enabled"))
showtoolbar = true;
else
toolbar->enable(KToolBar::Hide);
entry = entryList.next();
if (entry == QString::fromLatin1("Top"))
toolbar->setBarPos(KToolBar::Top);
else if (entry == QString::fromLatin1("Bottom"))
toolbar->setBarPos(KToolBar::Bottom);
else if (entry == QString::fromLatin1("Left"))
toolbar->setBarPos(KToolBar::Left);
else if (entry == QString::fromLatin1("Right"))
toolbar->setBarPos(KToolBar::Right);
else if (entry == QString::fromLatin1("Floating"))
{
toolbar->setBarPos(KToolBar::Floating);
entry=entryList.next();
toolbar->setGeometry(KWM::setProperties(toolbar->winId(), entry));
toolbar->updateRects(TRUE);
toolbar->show();
}
if (showtoolbar)
toolbar->enable(KToolBar::Show);
n++; // next toolbar
entryList.clear();
}
s.setNum(number);
config->setGroup(s);
readProperties(config);
return True;
}
kdelibs'KTMainWindow::setFrameBorderWidth() (./kdelibs/kdeui/ktmainwindow.cpp:557)
void KTMainWindow::setFrameBorderWidth(int size){
borderwidth = size;
}
kdelibs'KTMainWindow::setMaximumToolBarWraps() (./kdelibs/kdeui/ktmainwindow.cpp:563)
void KTMainWindow::setMaximumToolBarWraps(unsigned int wraps)
{
layoutMgr->setMaximumWraps(wraps);
}
kdelibs'KTMainWindow::canBeRestored() (./kdelibs/kdeui/ktmainwindow.cpp:568)
bool KTMainWindow::canBeRestored(int number){
if (!kapp->isRestored())
return false;
KConfig *config = kapp->sessionConfig();
if (!config)
return false;
config->setGroup(QString::fromLatin1("Number"));
int n = config->readNumEntry(QString::fromLatin1("NumberOfWindows"), 0);
return (number >= 1 && number <= n);
}
kdelibs'KTMainWindow::classNameOfToplevel() (./kdelibs/kdeui/ktmainwindow.cpp:579)
const QString KTMainWindow::classNameOfToplevel(int number){
if (!kapp->isRestored())
return QString::null;
KConfig *config = kapp->sessionConfig();
if (!config)
return QString::null;
QString s;
s.setNum(number);
s.prepend(QString::fromLatin1("WindowProperties"));
config->setGroup(s);
if (!config->hasKey(QString::fromLatin1("ClassName")))
return QString::null;
else
return config->readEntry(QString::fromLatin1("ClassName"));
}
kdelibs'KTMainWindow::restore() (./kdelibs/kdeui/ktmainwindow.cpp:597)
bool KTMainWindow::restore(int number){
if (!canBeRestored(number))
return false;
KConfig *config = kapp->sessionConfig();
if (readPropertiesInternal(config, number)){
show();
return true;
}
return false;
}
kdelibs'KTMainWindow::event() (./kdelibs/kdeui/ktmainwindow.cpp:608)
bool KTMainWindow::event(QEvent* ev)
{
if ( QWidget::event(ev) ) return TRUE;
/* We will get a layout hint when the view widget or a bar changes it's
* size constraines. Since we might have to adjust the window size we
* call updateGeometry.
* It has been added thanks to Nicolas Hadacek's hint. CS */
if (ev->type() == QEvent::LayoutHint) {
updateRects();
return TRUE;
}
return FALSE;
}
kdelibs'KTMainWindow::resizeEvent() (./kdelibs/kdeui/ktmainwindow.cpp:622)
void KTMainWindow::resizeEvent(QResizeEvent* )
{
/* This is an ugly hack to work around a Qt layout management
* problem. If the minimum or maximum size changes during the
* execution of resizeEvent() functions this new size is not
* honored. Unfortunately due to the multiple resizeEvents() this
* flickers a lot in opaque resize mode when using kwm. No
* flickering with kwin, yeah!
*
* To avoid endless recursions we make sure that we only call resize
* once. I arbitrarily favored height adjustment over width adjustment
* since it fits into our height for width dominated widget world. CS */
if (height() < minimumHeight())
resize(width(), minimumHeight());
else if (maximumHeight() > 0 && height() > maximumHeight())
resize(width(), maximumHeight());
else if (width() < minimumWidth())
resize(minimumWidth(), height());
else if (maximumWidth() > 0 && width() > maximumWidth())
resize(maximumWidth(), height());
/* Matthias believes that this may lead to endless loops, but I think
* it's save, though I have no proof. I did some heavy testing on
* both slow and fast machines without problems. CS */
}
kdelibs'KTMainWindow::statusBar() (./kdelibs/kdeui/ktmainwindow.cpp:648)
KStatusBar *KTMainWindow::statusBar()
{
if (!kstatusbar) {
kstatusbar = new KStatusBar(this);
updateRects ();
}
return kstatusbar;
}
kdelibs'KTMainWindow::setStatusBar() (./kdelibs/kdeui/ktmainwindow.cpp:657)
void KTMainWindow::setStatusBar (KStatusBar *statusbar)
{
kstatusbar = statusbar;
updateRects ();
}
kdelibs'KTMainWindow::menuBar() (./kdelibs/kdeui/ktmainwindow.cpp:663)
KMenuBar *KTMainWindow::menuBar()
{
if (!kmenubar) {
setMenu(new KMenuBar(this));
}
return kmenubar;
}
kdelibs'KTMainWindow::setMenu() (./kdelibs/kdeui/ktmainwindow.cpp:671)
void KTMainWindow::setMenu (KMenuBar *menubar)
{
kmenubar = menubar;
connect (kmenubar, SIGNAL(destroyed ()), this, SLOT(menubarKilled ()));
updateRects();
}
kdelibs'KTMainWindow::setIndicatorWidget() (./kdelibs/kdeui/ktmainwindow.cpp:678)
void KTMainWindow::setIndicatorWidget( QWidget *ind)
{
d->m_indicator = ind;
updateRects();
}
kdelibs'KTMainWindow::indicator() (./kdelibs/kdeui/ktmainwindow.cpp:684)
QWidget *KTMainWindow::indicator()
{
return d->m_indicator;
}
kdelibs'KTMainWindow::toolBar() (./kdelibs/kdeui/ktmainwindow.cpp:689)
KToolBar *KTMainWindow::toolBar( int ID )
{
KToolBar* result = 0;
if (ID < int(toolbars.count()))
result = toolbars.at( ID )
;
if (!result) {
bool honor_mode = (ID == 0) ? true : false;
result = new KToolBar(this, 0, honor_mode);
toolbars.append( result );
while (int(toolbars.count()) < ID){
toolbars.append( result );
}
connect ( result, SIGNAL( moved (BarPosition) ),
this, SLOT( updateRects() ) );
connect (result, SIGNAL(destroyed ()), this, SLOT(toolbarKilled ()));
updateRects();
}
return result;
}
kdelibs'KTMainWindow::toolBar() (./kdelibs/kdeui/ktmainwindow.cpp:710)
KToolBar *KTMainWindow::toolBar( const QString& name )
{
KToolBar* result = 0L;
if ( factory() ) {
QWidget *widget = factory()->container( name, this );
if ( widget->inherits("KToolBar") )
result = (KToolBar*)widget;
}
return result;
}
kdelibs'KTMainWindow::setEnableToolBar() (./kdelibs/kdeui/ktmainwindow.cpp:722)
void KTMainWindow::setEnableToolBar( KToolBar::BarStatus stat, const QString& name)
{
KToolBar *t = toolBar( name );
if ( t )
t->enable( stat );
updateRects();
}
kdelibs'KTMainWindow::enableToolBar() (./kdelibs/kdeui/ktmainwindow.cpp:730)
void KTMainWindow::enableToolBar( KToolBar::BarStatus stat, int ID )
{
KToolBar *t = toolbars.at( ID );
if ( t )
t->enable( stat );
updateRects();
}
kdelibs'KTMainWindow::enableStatusBar() (./kdelibs/kdeui/ktmainwindow.cpp:738)
void KTMainWindow::enableStatusBar( KStatusBar::BarStatus stat )
{
if ( ( stat == KStatusBar::Toggle && statusBar()->isVisible() )
|| stat == KStatusBar::Hide )
statusBar()->hide();
else
statusBar()->show();
updateRects();
}
kdelibs'KTMainWindow::hasMenuBar() (./kdelibs/kdeui/ktmainwindow.cpp:749)
bool KTMainWindow::hasMenuBar(){
return kmenubar != 0;
}
kdelibs'KTMainWindow::hasStatusBar() (./kdelibs/kdeui/ktmainwindow.cpp:753)
bool KTMainWindow::hasStatusBar(){
return kstatusbar != 0;
}
kdelibs'KTMainWindow::hasToolBar() (./kdelibs/kdeui/ktmainwindow.cpp:757)
bool KTMainWindow::hasToolBar( int ID ){
return toolbars.at( ID ) != 0;
}
kdelibs'KTMainWindow::menubarKilled() (./kdelibs/kdeui/ktmainwindow.cpp:761)
void KTMainWindow::menubarKilled()
{
if (localKill)
{
kdDebug(200) << "KTM: ACK mb kill, local kill, NOT zeroed" << endl;
return;
}
// No dead souls in here.
const QObject *dyer = sender (); // Who needs last rites?
if (dyer) { // Doe he live still
kmenubar = 0L;
kdDebug(200) << "KTM: ACK mb kill, zeroed" << endl;
} else {
kdDebug(200) << "KTM: ACK mb kill, dyer zero, NOT zeroed" << endl;
}
}
kdelibs'KTMainWindow::toolbarKilled() (./kdelibs/kdeui/ktmainwindow.cpp:780)
void KTMainWindow::toolbarKilled()
{
if (localKill) {
kdDebug(200) << "KTM: ACK tb kill, local kill, NOT removed from list" << endl;
return;
}
// No dead souls in here.
const QObject *dyer = sender (); // Who need last rites?
if (dyer) {
toolbars.removeRef((KToolBar *) dyer); // remove it from the list;
kdDebug(200) << "KTM: ACK tb kill, removed from list" << endl;
//else
//kdDebug(200) << "KTM: ACK tb kill, NOT removed from list");
} else {
kdDebug(200) << "KTM: ACK tb kill, dyer zero, NOT removed from list" << endl;
}
}
kdelibs'KTMainWindow::helpMenu() (./kdelibs/kdeui/ktmainwindow.cpp:802)
QPopupMenu* KTMainWindow::helpMenu( const QString &aboutAppText,
bool showWhatsThis )
{
if( mHelpMenu == 0 ) {
mHelpMenu = new KHelpMenu( this, aboutAppText, showWhatsThis );
if( mHelpMenu == 0 ) { return( 0 ); }
connect( mHelpMenu, SIGNAL(showAboutApplication()),
this, SLOT(showAboutApplication()));
}
return( mHelpMenu->menu() );
}
kdelibs'KTMainWindow::appHelpActivated() (./kdelibs/kdeui/ktmainwindow.cpp:817)
void KTMainWindow::appHelpActivated( void )
{
if( mHelpMenu == 0 ) {
mHelpMenu = new KHelpMenu( this );
if( mHelpMenu == 0 ) { return; }
}
mHelpMenu->appHelpActivated();
}
kdelibs'KTMainWindow::showAboutApplication() (./kdelibs/kdeui/ktmainwindow.cpp:827)
void KTMainWindow::showAboutApplication( void )
{
// Just an empty virtual slot
}
kdelibs'KTMainWindow::guiFactory() (./kdelibs/kdeui/ktmainwindow.cpp:832)
KXMLGUIFactory *KTMainWindow::guiFactory()
{
if ( !d->m_factory )
d->m_factory = new KXMLGUIFactory( this );
return d->m_factory;
}
kdelibs'KTMainWindow::createGUI() (./kdelibs/kdeui/ktmainwindow.cpp:839)
void KTMainWindow::createGUI( const QString &xmlfile )
{
// disabling the updates prevents unnecessary redraws
setUpdatesEnabled( false );
// just in case we are rebuilding, let's remove our old client
guiFactory()->removeClient( this );
// we always want a help menu
if (d->m_helpMenu == 0)
d->m_helpMenu = new KHelpMenu(this, instance()->aboutData(), true,
actionCollection());
// we always want to load in our global standards file
setXMLFile( locate( "config", "ui/ui_standards.rc", instance() ) );
// now, merge in our local xml file. if this is null, then that
// means that we will be only using the global file
if ( !xmlfile.isNull() ) {
setXMLFile( xmlfile, true );
} else {
QString auto_file(instance()->instanceName() + "ui.rc");
setXMLFile( auto_file, true );
}
// make sure we don't have any state saved already
setContainerStates(QMap<QString,QByteArray>());
// do the actual GUI building
guiFactory()->addClient( this );
// try and get back *some* of our memory
conserveMemory();
setUpdatesEnabled( true );
}