Katana_mirror/kde-workspace
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kde-workspace.git synced 2025-02-23 10:22:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

generic: use the new public KTimerDialog

Browse source 
see the following commit in kdelibs repo:
e0d476372cd6a39a01cb8b70f31192e4d2d540c8

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2023-08-16 15:20:32 +03:00
parent 27845ee910
commit 7b8bc6b8ef
16 changed files with 14 additions and 1088 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
kcontrol/componentchooser/CMakeLists.txt
View file

@ -10,7 +10,6 @@ set(kcm_componentchooser_SRCS
componentchooseremail.cpp
kcm_componentchooser.cpp
componentchooserterminal.cpp
ktimerdialog.cpp
componentchooserwm.cpp
)

171
kcontrol/componentchooser/ktimerdialog.cpp
View file

@ -1,171 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include "ktimerdialog.h"
#include <QLabel>
#include <QTimer>
#include <QProgressBar>
#include <kwindowsystem.h>
#include <kiconloader.h>
#include <klocale.h>
#include <kdebug.h>
#include <kvbox.h>
#include "moc_ktimerdialog.cpp"
KTimerDialog::KTimerDialog( int msec, TimerStyle style, QWidget *parent,
const QString &caption,
int buttonMask, ButtonCode defaultButton,
bool separator,
const KGuiItem &user1,
const KGuiItem &user2,
const KGuiItem &user3 )
: KDialog( parent )
{
setCaption( caption );
setButtons( (ButtonCodes)buttonMask );
setDefaultButton( defaultButton );
setButtonFocus( defaultButton ); // setDefaultButton() doesn't do this
showButtonSeparator( separator );
setButtonGuiItem( User1, user1 );
setButtonGuiItem( User2, user2 );
setButtonGuiItem( User3, user3 );
totalTimer = new QTimer( this );
totalTimer->setSingleShot( true );
updateTimer = new QTimer( this );
updateTimer->setSingleShot( false );
msecTotal = msecRemaining = msec;
updateInterval = 1000;
tStyle = style;
KWindowSystem::setIcons( winId(), DesktopIcon("randr"), SmallIcon("randr") );
// default to canceling the dialog on timeout
if ( buttonMask & Cancel )
buttonOnTimeout = Cancel;
connect( totalTimer, SIGNAL( timeout() ), SLOT( slotInternalTimeout() ) );
connect( updateTimer, SIGNAL( timeout() ), SLOT( slotUpdateTime() ) );
// create the widgets
mainWidget = new KVBox( this );
timerWidget = new KHBox( mainWidget );
timerWidget->setSpacing(KDialog::spacingHint());
timerLabel = new QLabel( timerWidget );
timerProgress = new QProgressBar( timerWidget );
timerProgress->setRange( 0, msecTotal );
timerProgress->setTextVisible( false );
KDialog::setMainWidget( mainWidget );
slotUpdateTime( false );
}
KTimerDialog::~KTimerDialog()
{
}
void KTimerDialog::setVisible( bool visible )
{
KDialog::setVisible( visible );
if ( visible ) {
totalTimer->start( msecTotal );
updateTimer->start( updateInterval );
}
}
int KTimerDialog::exec()
{
totalTimer->start( msecTotal );
updateTimer->start( updateInterval );
return KDialog::exec();
}
void KTimerDialog::setMainWidget( QWidget *widget )
{
// yuck, here goes.
KVBox *newWidget = new KVBox( this );
if ( widget->parentWidget() != mainWidget ) {
widget->setParent( newWidget);
}
timerWidget->setParent( newWidget);
delete mainWidget;
mainWidget = newWidget;
KDialog::setMainWidget( mainWidget );
}
void KTimerDialog::setRefreshInterval( int msec )
{
updateInterval = msec;
if ( updateTimer->isActive() )
updateTimer->start( updateInterval );
}
int KTimerDialog::timeoutButton() const
{
return buttonOnTimeout;
}
void KTimerDialog::setTimeoutButton( const ButtonCode newButton )
{
buttonOnTimeout = newButton;
}
int KTimerDialog::timerStyle() const
{
return tStyle;
}
void KTimerDialog::setTimerStyle( const TimerStyle newStyle )
{
tStyle = newStyle;
}
void KTimerDialog::slotUpdateTime( bool update )
{
if ( update )
switch ( tStyle ) {
case CountDown:
msecRemaining -= updateInterval;
break;
case CountUp:
msecRemaining += updateInterval;
break;
case Manual:
break;
}
timerProgress->setValue( msecRemaining );
timerLabel->setText( i18np("1 second remaining:","%1 seconds remaining:",msecRemaining/1000) );
}
void KTimerDialog::slotInternalTimeout()
{
emit timerTimeout();
slotButtonClicked( buttonOnTimeout );
}

168
kcontrol/componentchooser/ktimerdialog.h
View file

@ -1,168 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef _KTIMERDIALOG_H_
#define _KTIMERDIALOG_H_
#include <QLabel>
#include <kdialog.h>
#include <kvbox.h>
#include <QTimer>
class KHBox;
#include <QProgressBar>
#include <QLabel>
/**
* Provides a dialog that is only available for a specified amount
* of time, and reports the time remaining to the user.
*
* The timer is capable of counting up or down, for any number of milliseconds.
*
* The button which is activated upon timeout can be specified, as can the
* update interval for the dialog box.
*
* In addition, this class retains all of the functionality of @see KDialog.
*
* @short A dialog with a time limit and corresponding UI features.
* @author Hamish Rodda <rodda@kde.org>
*/
class KTimerDialog : public KDialog
{
Q_OBJECT
public:
/**
* @li @p CountDown - The timer counts downwards from the seconds given.
* @li @p CountUp - The timer counts up to the number of seconds given.
* @li @p Manual - The timer is not invoked; the caller must update the
* progress.
*/
enum TimerStyle
{
CountDown,
CountUp,
Manual
};
/**
* Constructor for the standard mode where you must specify the main
* widget with @ref setMainWidget() . See @see KDialog for further details.
*
* For the rest of the arguments, See @see KDialog .
*/
explicit KTimerDialog( int msec, TimerStyle style=CountDown, QWidget *parent=0,
const QString &caption=QString(),
int buttonMask=Ok|Apply|Cancel, ButtonCode defaultButton=Ok,
bool separator=false,
const KGuiItem &user1=KGuiItem(),
const KGuiItem &user2=KGuiItem(),
const KGuiItem &user3=KGuiItem() );
/**
* Destructor.
*/
~KTimerDialog();
/**
* Execute the dialog modelessly - see @see QDialog .
*/
virtual void setVisible( bool visible );
/**
* Set the refresh interval for the timer progress. Defaults to one second.
*/
void setRefreshInterval( int msec );
/**
* Retrieves the @ref ButtonCode which will be activated once the timer
* times out. @see setTimeoutButton
*/
int timeoutButton() const;
/**
* Sets the @ref ButtonCode to determine which button will be activated
* once the timer times out. @see timeoutButton
*/
void setTimeoutButton( ButtonCode newButton );
/**
* Retrieves the current @ref TimerStyle. @see setTimerStyle
*/
int timerStyle() const;
/**
* Sets the @ref TimerStyle. @see timerStyle
*/
void setTimerStyle( TimerStyle newStyle );
/**
* Overridden function which is used to set the main widget of the dialog.
* @see KDialog::setMainWidget.
*/
void setMainWidget( QWidget *widget );
Q_SIGNALS:
/**
* Signal which is emitted once the timer has timed out.
*/
void timerTimeout();
public Q_SLOTS:
/**
* Execute the dialog modally - see @see QDialog .
*/
int exec();
private Q_SLOTS:
/**
* Updates the dialog with the current progress levels.
*/
void slotUpdateTime( bool update = true );
/**
* The internal
*/
void slotInternalTimeout();
private:
/**
* Prepares the layout that manages the widgets of the dialog
*/
void setupLayout();
QTimer *totalTimer;
QTimer *updateTimer;
int msecRemaining, updateInterval, msecTotal;
ButtonCode buttonOnTimeout;
TimerStyle tStyle;
KHBox *timerWidget;
QProgressBar *timerProgress;
QLabel *timerLabel;
KVBox *mainWidget;
class KTimerDialogPrivate;
KTimerDialogPrivate *d;
};
#endif

1
kcontrol/randr/CMakeLists.txt
View file

@ -7,7 +7,6 @@ include_directories(${X11_Xrandr_INCLUDE_PATH})
set(randrinternal_PART_SRCS
ktimerdialog.cpp
randr.cpp
randrdisplay.cpp
collapsiblewidget.cpp

222
kcontrol/randr/ktimerdialog.cpp
View file

@ -1,222 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include <fixx11h.h>
#include <QLabel>
#include <QLayout>
#include <QPixmap>
#include <QTimer>
#include <QtGui/QProgressBar>
#include <kwindowsystem.h>
#include <kiconloader.h>
#include <klocale.h>
#include <kdebug.h>
#include <kvbox.h>
#include "ktimerdialog.h"
#include "moc_ktimerdialog.cpp"
KTimerDialog::KTimerDialog( int msec, TimerStyle style, QWidget *parent,
const char *name, bool modal,
const QString &caption,
int buttonMask, ButtonCode defaultButton,
bool separator,
const KGuiItem &user1,
const KGuiItem &user2,
const KGuiItem &user3 )
: KDialog( parent )
{
setObjectName( name );
setModal( modal );
setCaption( caption );
setButtons( (ButtonCodes)buttonMask );
setDefaultButton( defaultButton );
showButtonSeparator( separator );
setButtonGuiItem( User1, user1 );
setButtonGuiItem( User2, user2 );
setButtonGuiItem( User3, user3 );
totalTimer = new QTimer( this );
totalTimer->setSingleShot( true );
updateTimer = new QTimer( this );
updateTimer->setSingleShot( false );
msecTotal = msecRemaining = msec;
updateInterval = 1000;
tStyle = style;
KWindowSystem::setIcons( winId(), DesktopIcon("preferences-desktop-display-randr"), SmallIcon("preferences-desktop-display-randr") );
// default to canceling the dialog on timeout
if ( buttonMask & Cancel ) {
buttonOnTimeout = Cancel;
}
connect( totalTimer, SIGNAL(timeout()), SLOT(slotInternalTimeout()) );
connect( updateTimer, SIGNAL(timeout()), SLOT(slotUpdateTime()) );
// create the widgets
mainWidget = new KVBox( this );
timerWidget = new KHBox( mainWidget );
timerLabel = new QLabel( timerWidget );
timerProgress = new QProgressBar( timerWidget );
timerProgress->setRange( 0, msecTotal );
timerProgress->setTextVisible( false );
KDialog::setMainWidget( mainWidget );
slotUpdateTime( false );
}
KTimerDialog::~KTimerDialog()
{
}
void KTimerDialog::setVisible( bool visible )
{
KDialog::setVisible( visible );
if ( visible ) {
totalTimer->start( msecTotal );
updateTimer->start( updateInterval );
}
}
int KTimerDialog::exec()
{
totalTimer->start( msecTotal );
updateTimer->start( updateInterval );
return KDialog::exec();
}
void KTimerDialog::setMainWidget( QWidget *widget )
{
// yuck, here goes.
KVBox *newWidget = new KVBox( this );
if ( widget->parentWidget() != mainWidget ) {
widget->setParent( newWidget);
}
timerWidget->setParent( newWidget);
delete mainWidget;
mainWidget = newWidget;
KDialog::setMainWidget( mainWidget );
}
void KTimerDialog::setRefreshInterval( int msec )
{
updateInterval = msec;
if ( updateTimer->isActive() ) {
updateTimer->start( updateInterval );
}
}
int KTimerDialog::timeoutButton() const
{
return buttonOnTimeout;
}
void KTimerDialog::setTimeoutButton( const ButtonCode newButton )
{
buttonOnTimeout = newButton;
}
int KTimerDialog::timerStyle() const
{
return tStyle;
}
void KTimerDialog::setTimerStyle( const TimerStyle newStyle )
{
tStyle = newStyle;
}
void KTimerDialog::slotUpdateTime( bool update )
{
if ( update )
switch ( tStyle ) {
case CountDown:
msecRemaining -= updateInterval;
break;
case CountUp:
msecRemaining += updateInterval;
break;
case Manual:
break;
}
timerProgress->setValue( msecRemaining );
timerLabel->setText( i18np("1 second remaining:","%1 seconds remaining:",msecRemaining/1000) );
}
void KTimerDialog::slotInternalTimeout()
{
emit timerTimeout();
switch ( buttonOnTimeout ) {
case Help:
slotButtonClicked(KDialog::Help);
break;
case Default:
slotButtonClicked(KDialog::Default);
break;
case Ok:
slotButtonClicked(KDialog::Ok);
break;
case Apply:
slotButtonClicked(KDialog::Apply);
break;
case Try:
slotButtonClicked(KDialog::Try);
break;
case Cancel:
slotButtonClicked(KDialog::Cancel);
break;
case Close:
slotButtonClicked(KDialog::Close);
break;
case User1:
slotButtonClicked(KDialog::User1);
break;
case User2:
slotButtonClicked(KDialog::User2);
break;
case User3:
slotButtonClicked(KDialog::User3);
break;
case No:
slotButtonClicked(KDialog::No);
break;
case Yes:
slotButtonClicked(KDialog::Cancel);
break;
case Details:
slotButtonClicked(KDialog::Details);
break;
case None:
slotButtonClicked(KDialog::None);
break;
case NoDefault:
slotButtonClicked(KDialog::NoDefault);
break;
}
}

170
kcontrol/randr/ktimerdialog.h
View file

@ -1,170 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef _KTIMERDIALOG_H_
#define _KTIMERDIALOG_H_
#include <QLabel>
#include <kdialog.h>
#include <kvbox.h>
#include <QTimer>
#include <QProgressBar>
#include <QLabel>
class KHBox;
/**
* Provides a dialog that is only available for a specified amount
* of time, and reports the time remaining to the user.
*
* The timer is capable of counting up or down, for any number of milliseconds.
*
* The button which is activated upon timeout can be specified, as can the
* update interval for the dialog box.
*
* In addition, this class retains all of the functionality of @see KDialog.
*
* @short A dialog with a time limit and corresponding UI features.
* @author Hamish Rodda <rodda@kde.org>
*/
class KTimerDialog : public KDialog
{
Q_OBJECT
public:
/**
* @li @p CountDown - The timer counts downwards from the seconds given.
* @li @p CountUp - The timer counts up to the number of seconds given.
* @li @p Manual - The timer is not invoked; the caller must update the
* progress.
*/
enum TimerStyle
{
CountDown,
CountUp,
Manual
};
/**
* Constructor for the standard mode where you must specify the main
* widget with @ref setMainWidget() . See @see KDialog for further details.
*
* For the rest of the arguments, See @see KDialog .
*/
explicit KTimerDialog(int msec, TimerStyle style=CountDown, QWidget *parent = 0,
const char *name = 0, bool modal=true,
const QString &caption = QString(),
int buttonMask = Ok|Apply|Cancel, ButtonCode defaultButton=Ok,
bool separator = false,
const KGuiItem &user1 = KGuiItem(),
const KGuiItem &user2 = KGuiItem(),
const KGuiItem &user3 = KGuiItem());
/**
* Destructor.
*/
~KTimerDialog();
/**
* Execute the dialog modelessly - see @see QDialog .
*/
virtual void setVisible(bool visible);
/**
* Set the refresh interval for the timer progress. Defaults to one second.
*/
void setRefreshInterval(int msec);
/**
* Retrieves the @ref ButtonCode which will be activated once the timer
* times out. @see setTimeoutButton
*/
int timeoutButton() const;
/**
* Sets the @ref ButtonCode to determine which button will be activated
* once the timer times out. @see timeoutButton
*/
void setTimeoutButton(ButtonCode newButton);
/**
* Retrieves the current @ref TimerStyle. @see setTimerStyle
*/
int timerStyle() const;
/**
* Sets the @ref TimerStyle. @see timerStyle
*/
void setTimerStyle(TimerStyle newStyle);
/**
* Overridden function which is used to set the main widget of the dialog.
* @see KDialog::setMainWidget.
*/
void setMainWidget(QWidget *widget);
Q_SIGNALS:
/**
* Signal which is emitted once the timer has timed out.
*/
void timerTimeout();
public Q_SLOTS:
/**
* Execute the dialog modally - see @see QDialog .
*/
int exec();
private Q_SLOTS:
/**
* Updates the dialog with the current progress levels.
*/
void slotUpdateTime( bool update = true );
/**
* The internal
*/
void slotInternalTimeout();
private:
/**
* Prepares the layout that manages the widgets of the dialog
*/
void setupLayout();
QTimer *totalTimer;
QTimer *updateTimer;
int msecRemaining, updateInterval, msecTotal;
ButtonCode buttonOnTimeout;
TimerStyle tStyle;
KHBox *timerWidget;
QProgressBar *timerProgress;
QLabel *timerLabel;
KVBox *mainWidget;
class KTimerDialogPrivate;
KTimerDialogPrivate *d;
};
#endif // _KTIMERDIALOG_H_

1
kcontrol/randr/module/CMakeLists.txt
View file

@ -13,7 +13,6 @@ set(kded_randrmonitor_PART_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/../randrcrtc.cpp
${CMAKE_CURRENT_SOURCE_DIR}/../randrmode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/../randr.cpp
${CMAKE_CURRENT_SOURCE_DIR}/../ktimerdialog.cpp
)
kde4_add_plugin(kded_randrmonitor ${kded_randrmonitor_PART_SRCS})

1
kcontrol/randr/module/randrmonitor.cpp
View file

@ -35,6 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <qdbusservicewatcher.h>
#include <qdbusconnection.h>
#include <qdbusconnectioninterface.h>
#include <qlabel.h>
#include <qtimer.h>
#include <qx11info_x11.h>
#include <qlayout.h>

1
kcontrol/randr/module/randrmonitor.h
View file

@ -20,6 +20,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define RANDRMONITOR_H
#include <kdedmodule.h>
#include <kdialog.h>
#include <qwidget.h>
#include <X11/Xlib.h>

9
kcontrol/randr/randr.cpp
View file

@ -18,7 +18,11 @@
*/
#include "randr.h"
#include <QLabel>
#include <KIconLoader>
#include <KTimerDialog>
#include <KWindowSystem>
Time RandR::timestamp = 0;
@ -129,12 +133,15 @@ bool RandR::confirm(const QRect &rect)
KTimerDialog acceptDialog(
15000, KTimerDialog::CountDown,
0, "mainKTimerDialog", true,
nullptr,
i18n("Confirm Display Setting Change"),
KTimerDialog::Ok|KTimerDialog::Cancel,
KTimerDialog::Cancel
);
acceptDialog.setModal(true);
acceptDialog.setObjectName("mainKTimerDialog");
KWindowSystem::setIcons(acceptDialog.winId(), DesktopIcon("preferences-desktop-display-randr"), SmallIcon("preferences-desktop-display-randr"));
acceptDialog.setButtonGuiItem(KDialog::Ok, KGuiItem(i18n("&Accept Configuration"), "dialog-ok"));
acceptDialog.setButtonGuiItem(KDialog::Cancel, KGuiItem(i18n("&Revert to Previous Configuration"), "dialog-cancel"));

2
kcontrol/randr/randr.h
View file

@ -28,8 +28,6 @@
#include <QString>
#include <QPixmap>
#include "ktimerdialog.h"
extern "C"
{
#include <X11/Xlib.h>

1
kcontrol/randr/randrconfig.cpp
View file

@ -31,6 +31,7 @@
#include <kglobalsettings.h>
#include <kmessagebox.h>
#include <kshell.h>
#include <kconfiggroup.h>
#include <qmenu.h>
QT_BEGIN_NAMESPACE

7
kwin/kcmkwin/kwincompositing/CMakeLists.txt
View file

@ -4,7 +4,6 @@ include_directories( ${CMAKE_SOURCE_DIR}/kwin )
set(kcm_kwincompositing_PART_SRCS
main.cpp
ktimerdialog.cpp
main.ui
)
@ -13,11 +12,9 @@ set_source_files_properties(${kwin_xml} PROPERTIES INCLUDE "interface_util.h")
QT4_ADD_DBUS_INTERFACE(kcm_kwincompositing_PART_SRCS ${kwin_xml} kwin_interface)
kde4_add_plugin(kcm_kwincompositing ${kcm_kwincompositing_PART_SRCS})
target_link_libraries(kcm_kwincompositing KDE4::kcmutils KDE4::kdeui ${X11_LIBRARIES})
install(TARGETS kcm_kwincompositing DESTINATION ${KDE4_PLUGIN_INSTALL_DIR} )
install(TARGETS kcm_kwincompositing DESTINATION ${KDE4_PLUGIN_INSTALL_DIR})
########### install files ###############
install( FILES kwincompositing.desktop DESTINATION ${KDE4_SERVICES_INSTALL_DIR} )
install(FILES kwincompositing.desktop DESTINATION ${KDE4_SERVICES_INSTALL_DIR})

174
kwin/kcmkwin/kwincompositing/ktimerdialog.cpp
View file

@ -1,174 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include "ktimerdialog.h"
#include <QLabel>
#include <QLayout>
#include <QPixmap>
#include <QTimer>
#include <QProgressBar>
#include <kwindowsystem.h>
#include <kiconloader.h>
#include <KLocalizedString>
#include <kdebug.h>
#include <kvbox.h>
#include "moc_ktimerdialog.cpp"
KTimerDialog::KTimerDialog(int msec, TimerStyle style, QWidget *parent,
const QString &caption,
int buttonMask, ButtonCode defaultButton,
bool separator,
const KGuiItem &user1,
const KGuiItem &user2,
const KGuiItem &user3)
: KDialog(parent)
{
setCaption(caption);
setButtons((ButtonCodes)buttonMask);
setDefaultButton(defaultButton);
setButtonFocus(defaultButton); // setDefaultButton() doesn't do this
showButtonSeparator(separator);
setButtonGuiItem(User1, user1);
setButtonGuiItem(User2, user2);
setButtonGuiItem(User3, user3);
totalTimer = new QTimer(this);
totalTimer->setSingleShot(true);
updateTimer = new QTimer(this);
updateTimer->setSingleShot(false);
msecTotal = msecRemaining = msec;
updateInterval = 1000;
tStyle = style;
KWindowSystem::setIcons(winId(), DesktopIcon("randr"), SmallIcon("randr"));
// default to canceling the dialog on timeout
if (buttonMask & Cancel)
buttonOnTimeout = Cancel;
connect(totalTimer, SIGNAL(timeout()), SLOT(slotInternalTimeout()));
connect(updateTimer, SIGNAL(timeout()), SLOT(slotUpdateTime()));
// create the widgets
mainWidget = new KVBox(this);
timerWidget = new KHBox(mainWidget);
timerWidget->setSpacing(-1);
timerLabel = new QLabel(timerWidget);
timerProgress = new QProgressBar(timerWidget);
timerProgress->setRange(0, msecTotal);
timerProgress->setTextVisible(false);
KDialog::setMainWidget(mainWidget);
slotUpdateTime(false);
}
KTimerDialog::~KTimerDialog()
{
}
void KTimerDialog::setVisible(bool visible)
{
KDialog::setVisible(visible);
if (visible) {
totalTimer->start(msecTotal);
updateTimer->start(updateInterval);
}
}
int KTimerDialog::exec()
{
totalTimer->start(msecTotal);
updateTimer->start(updateInterval);
return KDialog::exec();
}
void KTimerDialog::setMainWidget(QWidget *widget)
{
// yuck, here goes.
KVBox *newWidget = new KVBox(this);
newWidget->setSpacing(-1);
if (widget->parentWidget() != mainWidget) {
widget->setParent(newWidget);
}
timerWidget->setParent(newWidget);
delete mainWidget;
mainWidget = newWidget;
KDialog::setMainWidget(mainWidget);
}
void KTimerDialog::setRefreshInterval(int msec)
{
updateInterval = msec;
if (updateTimer->isActive())
updateTimer->start(updateInterval);
}
int KTimerDialog::timeoutButton() const
{
return buttonOnTimeout;
}
void KTimerDialog::setTimeoutButton(const ButtonCode newButton)
{
buttonOnTimeout = newButton;
}
int KTimerDialog::timerStyle() const
{
return tStyle;
}
void KTimerDialog::setTimerStyle(const TimerStyle newStyle)
{
tStyle = newStyle;
}
void KTimerDialog::slotUpdateTime(bool update)
{
if (update)
switch(tStyle) {
case CountDown:
msecRemaining -= updateInterval;
break;
case CountUp:
msecRemaining += updateInterval;
break;
case Manual:
break;
}
timerProgress->setValue(msecRemaining);
timerLabel->setText(i18np("1 second remaining:", "%1 seconds remaining:", msecRemaining / 1000));
}
void KTimerDialog::slotInternalTimeout()
{
emit timerTimeout();
slotButtonClicked(buttonOnTimeout);
}

171
kwin/kcmkwin/kwincompositing/ktimerdialog.h
View file

@ -1,171 +0,0 @@
/*
* This file is part of the KDE Libraries
* Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef _KTIMERDIALOG_H_
#define _KTIMERDIALOG_H_
#include <QLabel>
#include <kdialog.h>
#include <kvbox.h>
#include <QTimer>
class KHBox;
#include <QProgressBar>
#include <QLabel>
/**
* Provides a dialog that is only available for a specified amount
* of time, and reports the time remaining to the user.
*
* The timer is capable of counting up or down, for any number of milliseconds.
*
* The button which is activated upon timeout can be specified, as can the
* update interval for the dialog box.
*
* In addition, this class retains all of the functionality of @see KDialog.
*
* @short A dialog with a time limit and corresponding UI features.
* @author Hamish Rodda <rodda@kde.org>
*/
class KTimerDialog : public KDialog
{
Q_OBJECT
public:
/**
* @li @p CountDown - The timer counts downwards from the seconds given.
* @li @p CountUp - The timer counts up to the number of seconds given.
* @li @p Manual - The timer is not invoked; the caller must update the
* progress.
*/
enum TimerStyle {
CountDown,
CountUp,
Manual
};
/**
* Constructor for the standard mode where you must specify the main
* widget with @ref setMainWidget() . See @see KDialog for further details.
*
* For the rest of the arguments, See @see KDialog .
*/
explicit KTimerDialog(int msec, TimerStyle style = CountDown, QWidget *parent = 0,
const QString &caption = QString(),
int buttonMask = Ok | Apply | Cancel, ButtonCode defaultButton = Ok,
bool separator = false,
const KGuiItem &user1 = KGuiItem(),
const KGuiItem &user2 = KGuiItem(),
const KGuiItem &user3 = KGuiItem());
/**
* Destructor.
*/
~KTimerDialog();
/**
* Execute the dialog modelessly - see @see QDialog .
*/
virtual void setVisible(bool visible);
/**
* Set the refresh interval for the timer progress. Defaults to one second.
*/
void setRefreshInterval(int msec);
/**
* Retrieves the @ref ButtonCode which will be activated once the timer
* times out. @see setTimeoutButton
*/
int timeoutButton() const;
/**
* Sets the @ref ButtonCode to determine which button will be activated
* once the timer times out. @see timeoutButton
*/
void setTimeoutButton(ButtonCode newButton);
/**
* Retrieves the current @ref TimerStyle. @see setTimerStyle
*/
int timerStyle() const;
/**
* Sets the @ref TimerStyle. @see timerStyle
*/
void setTimerStyle(TimerStyle newStyle);
/**
* Overridden function which is used to set the main widget of the dialog.
* @see KDialog::setMainWidget.
*/
void setMainWidget(QWidget *widget);
Q_SIGNALS:
/**
* Signal which is emitted once the timer has timed out.
*/
void timerTimeout();
public Q_SLOTS:
/**
* Execute the dialog modally - see @see QDialog .
*/
int exec();
private Q_SLOTS:
/**
* Updates the dialog with the current progress levels.
*/
void slotUpdateTime(bool update = true);
/**
* The internal
*/
void slotInternalTimeout();
private:
/**
* Prepares the layout that manages the widgets of the dialog
*/
void setupLayout();
QTimer *totalTimer;
QTimer *updateTimer;
int msecRemaining, updateInterval, msecTotal;
ButtonCode buttonOnTimeout;
TimerStyle tStyle;
KHBox *timerWidget;
QProgressBar *timerProgress;
QLabel *timerLabel;
KVBox *mainWidget;
class KTimerDialogPrivate;
KTimerDialogPrivate *d;
};
#endif

2
kwin/kcmkwin/kwincompositing/main.h
View file

@ -24,13 +24,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <kcmodule.h>
#include <ksharedconfig.h>
#include <ktemporaryfile.h>
#include <ktimerdialog.h>
#include <QLabel>
#include "kwin_interface.h"
#include "ui_main.h"
#include "ktimerdialog.h"
class KPluginSelector;
class KActionCollection;