QDBusViewer::QDBusViewer(const QDBusConnection &connection, QWidget *parent) :
QWidget(parent),
c(connection),
objectPathRegExp(QLatin1String("\\[ObjectPath: (.*)\\]"))
{
services = new QTreeWidget;
services->setRootIsDecorated(false);
services->setHeaderLabels(QStringList(QLatin1String("Services")));
tree = new QTreeView;
tree->setContextMenuPolicy(Qt::CustomContextMenu);
connect(tree, SIGNAL(activated(QModelIndex)), this, SLOT(activate(QModelIndex)));
refreshAction = new QAction(tr("&Refresh"), tree);
refreshAction->setData(42); // increase the amount of 42 used as magic number by one
refreshAction->setShortcut(QKeySequence::Refresh);
connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshChildren()));
QShortcut *refreshShortcut = new QShortcut(QKeySequence::Refresh, tree);
connect(refreshShortcut, SIGNAL(activated()), this, SLOT(refreshChildren()));
QVBoxLayout *topLayout = new QVBoxLayout(this);
log = new QTextBrowser;
connect(log, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl)));
QHBoxLayout *layout = new QHBoxLayout;
layout->addWidget(services, 1);
layout->addWidget(tree, 2);
topLayout->addLayout(layout);
topLayout->addWidget(log);
connect(services, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
this, SLOT(serviceChanged(QTreeWidgetItem*)));
connect(tree, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(showContextMenu(QPoint)));
QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);
if (c.isConnected()) {
logMessage(QLatin1String("Connected to D-Bus."));
QDBusConnectionInterface *iface = c.interface();
connect(iface, SIGNAL(serviceRegistered(QString)),
this, SLOT(serviceRegistered(QString)));
connect(iface, SIGNAL(serviceUnregistered(QString)),
this, SLOT(serviceUnregistered(QString)));
connect(iface, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(serviceOwnerChanged(QString,QString,QString)));
} else {
logError(QLatin1String("Cannot connect to D-Bus: ") + c.lastError().message());
}
objectPathRegExp.setMinimal(true);
}
/*!
\internal
*/
void QDBusConnectionPrivate::setBusService(const QDBusConnection &connection)
{
busService = new QDBusConnectionInterface(connection, this);
ref.deref(); // busService has increased the refcounting to us
// avoid cyclic refcounting
// if (mode != PeerMode)
QObject::connect(busService, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
QObject::connect(this, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
busService, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
Qt::QueuedConnection);
}
void k9xine::setTitle( const QString & _numTitle,const QString &) {
if (!m_process->isRunning()) {
k9Config config;
QString vout[]= {"xshm","xv","opengl","sdl"};
QString aout[]= {"alsa","oss"};
QString vo=vout[config.getXineVout()];
QString ao=aout[config.getXineAout()];
m_ready=false;
connect(QDBusConnection::sessionBus().interface(),SIGNAL(serviceOwnerChanged(QString,QString,QString)),this,SLOT(ready(QString,QString,QString)));
m_process->clearProgram();
*m_process << qApp->applicationDirPath()+ "/k9xineplayer" << "-wid" << QString::number(Ui_mplayer.Label->winId()) << "-vo" << vo << "-ao" << ao;
qDebug() << m_process->debug();
if (!m_process->start()) {
k9Dialogs::error (i18n("Unable to run %1").arg("k9xineplayer") , i18n("Preview"));
} else {
while (!m_ready) k9Tools::processEvents();
}
}
bool running=m_iface->property("isRunning").toBool();
m_iface->call("stop");
m_iface->setProperty("device",m_device);
m_iface->setProperty("mrl",QString("dvd:/%1").arg(_numTitle));
m_iface->setProperty("width",Ui_mplayer.Label->width());
m_iface->setProperty("height",Ui_mplayer.Label->height());
if (running)
m_iface->call("play");
m_position=0;
Ui_mplayer.slider->setValue(m_position);
}
/*!
\internal
This is the constructor called from QDBusInterface::QDBusInterface.
*/
QDBusAbstractInterface::QDBusAbstractInterface(QDBusAbstractInterfacePrivate &d, QObject *parent)
: QObject(d, parent)
{
// keep track of the service owner
if (d_func()->isValid)
QObject::connect(d_func()->connectionPrivate(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
}
bool QIcdEngine::ensureDBusConnection()
{
if (m_dbusInterface)
return true;
// Setup DBus Interface for ICD
m_dbusInterface = new QDBusInterface(ICD_DBUS_API_INTERFACE,
ICD_DBUS_API_PATH,
ICD_DBUS_API_INTERFACE,
QDBusConnection::systemBus(),
this);
if (!m_dbusInterface->isValid()) {
delete m_dbusInterface;
m_dbusInterface = 0;
if (!m_icdServiceWatcher) {
m_icdServiceWatcher = new QDBusServiceWatcher(ICD_DBUS_API_INTERFACE,
QDBusConnection::systemBus(),
QDBusServiceWatcher::WatchForOwnerChange,
this);
connect(m_icdServiceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(icdServiceOwnerChanged(QString,QString,QString)));
}
return false;
}
connect(&m_scanTimer, SIGNAL(timeout()), this, SLOT(finishAsyncConfigurationUpdate()));
m_scanTimer.setSingleShot(true);
/* Turn on IAP state monitoring */
startListeningStateSignalsForAllConnections();
/* Turn on IAP add/remove monitoring */
iapMonitor = new IapMonitor;
iapMonitor->setup(this);
/* We create a default configuration which is a pseudo config */
QNetworkConfigurationPrivate *cpPriv = new IcdNetworkConfigurationPrivate;
cpPriv->name = "UserChoice";
cpPriv->state = QNetworkConfiguration::Discovered;
cpPriv->isValid = true;
cpPriv->id = OSSO_IAP_ANY;
cpPriv->type = QNetworkConfiguration::UserChoice;
cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
cpPriv->roamingSupported = false;
QNetworkConfigurationPrivatePointer ptr(cpPriv);
userChoiceConfigurations.insert(cpPriv->id, ptr);
doRequestUpdate();
getIcdInitialState();
return true;
}
ContentTracker::ContentTracker(QObject *parent)
: Plasma::DataContainer(parent)
{
connectToActivityManager();
QDBusServiceWatcher *watcher = new QDBusServiceWatcher("org.kde.ActivityManager", QDBusConnection::sessionBus(),
QDBusServiceWatcher::WatchForOwnerChange, this);
connect(watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(serviceChange(QString,QString,QString)));
}
void FcitxQtConnectionPrivate::createConnection() {
if (m_connectedOnce && !m_autoReconnect) {
return;
}
m_serviceWatcher->disconnect(SIGNAL(serviceOwnerChanged(QString,QString,QString)));
QString addr = address();
// qDebug() << addr;
if (!addr.isNull()) {
QDBusConnection connection(QDBusConnection::connectToBus(addr, "fcitx"));
if (connection.isConnected()) {
// qDebug() << "create private";
m_connection = new QDBusConnection(connection);
}
else
QDBusConnection::disconnectFromBus("fcitx");
}
if (!m_connection) {
QDBusConnection* connection = new QDBusConnection(QDBusConnection::sessionBus());
connect(m_serviceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), this, SLOT(imChanged(QString,QString,QString)));
QDBusReply<bool> registered = connection->interface()->isServiceRegistered(m_serviceName);
if (!registered.isValid() || !registered.value()) {
delete connection;
}
else {
m_connection = connection;
}
}
Q_Q(FcitxQtConnection);
if (m_connection) {
m_connection->connect ("org.freedesktop.DBus.Local",
"/org/freedesktop/DBus/Local",
"org.freedesktop.DBus.Local",
"Disconnected",
this,
SLOT (dbusDisconnected ()));
m_connectedOnce = true;
Q_EMIT q->connected();
}
}
/*!
\internal
This is the constructor called from static classes derived from
QDBusAbstractInterface (i.e., those generated by dbusxml2cpp).
*/
QDBusAbstractInterface::QDBusAbstractInterface(const QString &service, const QString &path,
const char *interface, const QDBusConnection &con,
QObject *parent)
: QObject(*new QDBusAbstractInterfacePrivate(service, path, QString::fromLatin1(interface),
con, false), parent)
{
// keep track of the service owner
if (d_func()->connection.isConnected())
QObject::connect(d_func()->connectionPrivate(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
}
/*!
\internal
*/
QDBusConnectionInterface::QDBusConnectionInterface(const QDBusConnection &connection,
QObject *parent)
: QDBusAbstractInterface(QLatin1String(DBUS_SERVICE_DBUS),
QLatin1String(DBUS_PATH_DBUS),
DBUS_INTERFACE_DBUS, connection, parent)
{
connect(this, SIGNAL(NameAcquired(QString)), this, SIGNAL(serviceRegistered(QString)));
connect(this, SIGNAL(NameLost(QString)), this, SIGNAL(serviceUnregistered(QString)));
connect(this, SIGNAL(NameOwnerChanged(QString,QString,QString)),
this, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
}
/*!
\internal
*/
void QDBusConnectionInterface::disconnectNotify(const char *signalName)
{
// translate the signal names to what we really want
// this avoids setting hooks for signals that don't exist on the bus
if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0)
QDBusAbstractInterface::disconnectNotify(SIGNAL(NameAcquired(QString)));
else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0)
QDBusAbstractInterface::disconnectNotify(SIGNAL(NameLost(QString)));
else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0)
QDBusAbstractInterface::disconnectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString)));
}
void ScreenLockerWatcher::initialize()
{
connect(m_serviceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), SLOT(serviceOwnerChanged(QString,QString,QString)));
m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForOwnerChange);
m_serviceWatcher->addWatchedService(SCREEN_LOCKER_SERVICE_NAME);
// check whether service is registered
QFutureWatcher<QDBusReply<bool> > *watcher = new QFutureWatcher<QDBusReply<bool> >(this);
connect(watcher, SIGNAL(finished()), SLOT(serviceRegisteredQueried()));
connect(watcher, SIGNAL(canceled()), watcher, SLOT(deleteLater()));
watcher->setFuture(QtConcurrent::run(QDBusConnection::sessionBus().interface(),
&QDBusConnectionInterface::isServiceRegistered,
SCREEN_LOCKER_SERVICE_NAME));
}
void Timed::start_voland_watcher()
{
stop_voland_watcher() ;
voland_watcher = new QDBusServiceWatcher((QString)Maemo::Timed::Voland::service(),
QDBusConnection::systemBus());
QObject::connect(voland_watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), this, SLOT(system_owner_changed(QString,QString,QString))) ;
QDBusConnectionInterface *bus_ifc = QDBusConnection::systemBus().interface();
bool voland_present = bus_ifc and bus_ifc->isServiceRegistered(Maemo::Timed::Voland::service()) ;
if(voland_present)
{
log_info("Voland service %s detected", Maemo::Timed::Voland::service()) ;
emit voland_registered() ;
}
}
void Timed::init_create_event_machine()
{
am = new machine_t(this) ;
log_debug("am=new machine done") ;
q_pause = NULL ;
// The following call is commented out: device mode will be known later
#if 0
am->device_mode_detected(not act_dead_mode) ; // TODO: avoid "not" here
#endif
short_save_threshold_timer = new simple_timer(threshold_period_short) ;
long_save_threshold_timer = new simple_timer(threshold_period_long) ;
QObject::connect(short_save_threshold_timer, SIGNAL(timeout()), this, SLOT(queue_threshold_timeout())) ;
QObject::connect(long_save_threshold_timer, SIGNAL(timeout()), this, SLOT(queue_threshold_timeout())) ;
QObject::connect(am, SIGNAL(child_created(unsigned,int)), this, SLOT(register_child(unsigned,int))) ;
clear_invokation_flag() ;
ping = new pinguin_t(ping_period, ping_max_num, this) ;
QObject::connect(am, SIGNAL(voland_needed()), ping, SLOT(voland_needed())) ;
QObject::connect(this, SIGNAL(voland_registered()), ping, SLOT(voland_registered())) ;
QObject::connect(am, SIGNAL(queue_to_be_saved()), this, SLOT(event_queue_changed())) ;
#if 0
QDBusConnectionInterface *bus_ifc = Maemo::Timed::Voland::bus().interface() ;
voland_watcher = new QDBusServiceWatcher((QString)Maemo::Timed::Voland::service(), Maemo::Timed::Voland::bus()) ;
QObject::connect(voland_watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), this, SLOT(system_owner_changed(QString,QString,QString))) ;
#else
voland_watcher = NULL ;
#endif
QObject::connect(this, SIGNAL(voland_registered()), am, SIGNAL(voland_registered())) ;
QObject::connect(this, SIGNAL(voland_unregistered()), am, SIGNAL(voland_unregistered())) ;
#if 0
bool voland_present = bus_ifc->isServiceRegistered(Maemo::Timed::Voland::service()) ;
if(voland_present)
{
log_info("Voland service %s detected", Maemo::Timed::Voland::service()) ;
emit voland_registered() ;
}
#endif
}
void GnomeMediaKeys::grabKeys()
{
if (QDBusConnection::sessionBus().interface()->isServiceRegistered(constService)) {
if (!mk) {
mk = new OrgGnomeSettingsDaemonMediaKeysInterface(constService, constMediaKeysPath, QDBusConnection::sessionBus(), this);
}
QDBusPendingReply<> reply = mk->GrabMediaPlayerKeys(QCoreApplication::applicationName(), QDateTime::currentDateTime().toTime_t());
QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(reply, this);
connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(registerFinished(QDBusPendingCallWatcher*)));
if (!watcher) {
watcher = new QDBusServiceWatcher(this);
watcher->setConnection(QDBusConnection::sessionBus());
watcher->setWatchMode(QDBusServiceWatcher::WatchForOwnerChange);
connect(watcher, SIGNAL(serviceOwnerChanged(QString, QString, QString)), this, SLOT(serviceOwnerChanged(QString, QString, QString)));
}
}
}
/*!
\internal
*/
void QDBusConnectionInterface::connectNotify(const char *signalName)
{
// translate the signal names to what we really want
// this avoids setting hooks for signals that don't exist on the bus
if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0)
QDBusAbstractInterface::connectNotify(SIGNAL(NameAcquired(QString)));
else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0)
QDBusAbstractInterface::connectNotify(SIGNAL(NameLost(QString)));
else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0) {
static bool warningPrinted = false;
if (!warningPrinted) {
qWarning("Connecting to deprecated signal QDBusConnectionInterface::serviceOwnerChanged(QString,QString,QString)");
warningPrinted = true;
}
QDBusAbstractInterface::connectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString)));
}
}
void SpeechClient::setupSpeechSystem()
{
if ( KStandardDirs::findExe( "kttsd" ).isEmpty() )
{
kDebug() <<"KTTSD not installed, disable support";
d->isTextSpeechInstalled = false;
}
else
{
if ( QDBusConnection::sessionBus().interface()->isServiceRegistered("org.kde.kttsd") )
{
d->isTextSpeechInstalled = true;
}
else
{
QString error;
if (KToolInvocation::startServiceByDesktopName("kttsd", QString(), &error) != 0)
{
kDebug() <<"Starting KTTSD failed with message" << error;
d->isTextSpeechInstalled = false;
}
else
{
d->isTextSpeechInstalled = true;
}
}
if (d->isTextSpeechInstalled)
{
if ( !m_kspeech )
{
m_kspeech = new org::kde::KSpeech("org.kde.kttsd", "/KSpeech", QDBusConnection::sessionBus());
m_kspeech->setParent(this);
m_kspeech->setApplicationName("Akregator Speech Text");
connect(m_kspeech, SIGNAL(jobStateChanged(QString,int,int)),
this, SLOT(textRemoved(QString,int,int)));
connect( QDBusConnection::sessionBus().interface(), SIGNAL(serviceUnregistered(QString)), this, SLOT(slotServiceUnregistered(QString)) );
connect( QDBusConnection::sessionBus().interface(), SIGNAL(serviceOwnerChanged(QString,QString,QString)), this, SLOT(slotServiceOwnerChanged(QString,QString,QString)) );
}
}
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
if (!QDBusConnection::sessionBus().isConnected()) {
fprintf(stderr, "Cannot connect to the D-Bus session bus.\n"
"To start it, run:\n"
"\teval `dbus-launch --auto-syntax`\n");
return 1;
}
Ping ping;
ping.connect(QDBusConnection::sessionBus().interface(),
SIGNAL(serviceOwnerChanged(QString,QString,QString)),
SLOT(start(QString,QString,QString)));
QProcess pong;
pong.start("./complexpong");
app.exec();
}
/**
* Construct a new StatefulDBusProxy object.
*
* \param dbusConnection QDBusConnection to use.
* \param busName D-Bus bus name of the service that provides the remote object.
* \param objectPath The object path.
* \param featureCore The object core feature.
*/
StatefulDBusProxy::StatefulDBusProxy(const QDBusConnection &dbusConnection,
const QString &busName, const QString &objectPath, const Feature &featureCore)
: DBusProxy(dbusConnection, busName, objectPath, featureCore),
mPriv(new Private(busName))
{
QDBusServiceWatcher *serviceWatcher = new QDBusServiceWatcher(busName,
dbusConnection, QDBusServiceWatcher::WatchForUnregistration, this);
connect(serviceWatcher,
SIGNAL(serviceOwnerChanged(QString,QString,QString)),
SLOT(onServiceOwnerChanged(QString,QString,QString)));
QString error, message;
QString uniqueName = uniqueNameFrom(dbusConnection, busName, error, message);
if (uniqueName.isEmpty()) {
invalidate(error, message);
return;
}
setBusName(uniqueName);
}
FontInstInterface::FontInstInterface()
: itsInterface(new OrgKdeFontinstInterface(OrgKdeFontinstInterface::staticInterfaceName(),
FONTINST_PATH,
QDBusConnection::sessionBus(), 0L))
, itsActive(false)
{
KFI_DBUG;
FontInst::registerTypes();
QDBusServiceWatcher *watcher = new QDBusServiceWatcher(QLatin1String(OrgKdeFontinstInterface::staticInterfaceName()),
QDBusConnection::sessionBus(),
QDBusServiceWatcher::WatchForOwnerChange, this);
connect(watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), SLOT(dbusServiceOwnerChanged(QString,QString,QString)));
connect(itsInterface, SIGNAL(status(int,int)), SLOT(status(int,int)));
connect(itsInterface, SIGNAL(fontList(int,QList<KFI::Families>)), SLOT(fontList(int,QList<KFI::Families>)));
connect(itsInterface, SIGNAL(fontStat(int,KFI::Family)), SLOT(fontStat(int,KFI::Family)));
if (!QDBusConnection::sessionBus().interface()->isServiceRegistered(OrgKdeFontinstInterface::staticInterfaceName()))
QProcess::startDetached(QLatin1String(KFONTINST_LIB_EXEC_DIR"/fontinst"));
}
Window::Window(QWidget* parent)
: QMainWindow(parent),
m_playerActionGroup(new QActionGroup(this)),
m_tabWidget(0),
m_rootTest(0),
m_rootWidget(0),
m_playerTest(0),
m_playerWidget(0),
m_watcher(0)
{
m_ui.setupUi(this);
connect(m_ui.action_Quit, SIGNAL(triggered()),
this, SLOT(close()));
connect(m_playerActionGroup, SIGNAL(triggered(QAction*)),
this, SLOT(changePlayer(QAction*)));
m_timer.setInterval(2500);
QDBusConnection sessionConn = QDBusConnection::sessionBus();
if (sessionConn.isConnected()) {
m_watcher = new QDBusServiceWatcher(QString(),
sessionConn,
QDBusServiceWatcher::WatchForOwnerChange,
this);
connect(m_watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(serviceChange(QString,QString,QString)));
QDBusConnectionInterface* bus = sessionConn.interface();
QDBusReply<QStringList> reply = bus->registeredServiceNames();
if (reply.isValid()) {
QStringList services = reply.value();
foreach (const QString& name, services) {
if (name.startsWith(playerPrefix)) {
serviceChange(name, QString(), "dummy");
}
}
} else {
void UpnpNetworkBuilder::startBrowse()
{
qDBusRegisterMetaType<DeviceTypeMap>();
qDBusRegisterMetaType<Cagibi::Device>();
QDBusConnection dbusConnection = QDBusConnection::systemBus();
const QString serviceName = QLatin1String( cagibiServiceName );
const QString deviceListObjectPath = QLatin1String( cagibiDeviceListObjectPath );
const QString deviceListInterface = QLatin1String( cagibiDeviceListInterface );
// install service watcher
QDBusServiceWatcher* cagibiServiceWatcher =
new QDBusServiceWatcher( serviceName,
dbusConnection,
QDBusServiceWatcher::WatchForOwnerChange,
this );
connect( cagibiServiceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
SLOT(onCagibiServiceOwnerChanged(QString,QString,QString)) );
// create devicelist proxy
mCagibiDeviceListDBusProxy =
new QDBusInterface( serviceName,
deviceListObjectPath,
deviceListInterface,
dbusConnection, this );
connect( mCagibiDeviceListDBusProxy, SIGNAL(devicesAdded(DeviceTypeMap)),
SLOT(onDevicesAdded(DeviceTypeMap)) );
connect( mCagibiDeviceListDBusProxy, SIGNAL(devicesRemoved(DeviceTypeMap)),
SLOT(onDevicesRemoved(DeviceTypeMap)) );
// query current devicelist
queryCurrentDevices();
emit initDone();
}
StatusNotifierItem::StatusNotifierItem(QWidget *parent)
: StatusNotifierItemParent(parent)
#if QT_VERSION >= 0x050000
, _iconThemeDir{QDir::tempPath() + QLatin1String{"/quassel-sni-XXXXXX"}}
#endif
{
static bool registered = []() -> bool {
qDBusRegisterMetaType<DBusImageStruct>();
qDBusRegisterMetaType<DBusImageVector>();
qDBusRegisterMetaType<DBusToolTipStruct>();
return true;
}();
Q_UNUSED(registered)
setMode(Mode::StatusNotifier);
connect(this, SIGNAL(visibilityChanged(bool)), this, SLOT(onVisibilityChanged(bool)));
connect(this, SIGNAL(modeChanged(Mode)), this, SLOT(onModeChanged(Mode)));
connect(this, SIGNAL(stateChanged(State)), this, SLOT(onStateChanged(State)));
trayMenu()->installEventFilter(this);
// Create a temporary directory that holds copies of the tray icons. That way, visualizers can find our icons.
// For Qt4 the relevant icons are installed in hicolor already, so nothing to be done.
#if QT_VERSION >= 0x050000
if (_iconThemeDir.isValid()) {
_iconThemePath = _iconThemeDir.path();
}
else {
qWarning() << "Could not create temporary directory for themed tray icons!";
}
#endif
connect(this, SIGNAL(iconsChanged()), this, SLOT(refreshIcons()));
refreshIcons();
// Our own SNI service
_statusNotifierItemDBus = new StatusNotifierItemDBus(this);
connect(this, SIGNAL(currentIconNameChanged()), _statusNotifierItemDBus, SIGNAL(NewIcon()));
connect(this, SIGNAL(currentIconNameChanged()), _statusNotifierItemDBus, SIGNAL(NewAttentionIcon()));
connect(this, SIGNAL(toolTipChanged(QString, QString)), _statusNotifierItemDBus, SIGNAL(NewToolTip()));
// Service watcher to keep track of the StatusNotifierWatcher service
QDBusServiceWatcher *watcher = new QDBusServiceWatcher(kSniWatcherService,
QDBusConnection::sessionBus(),
QDBusServiceWatcher::WatchForOwnerChange,
this);
connect(watcher, SIGNAL(serviceOwnerChanged(QString, QString, QString)), SLOT(serviceChange(QString, QString, QString)));
// Client instance for StatusNotifierWatcher
_statusNotifierWatcher = new org::kde::StatusNotifierWatcher(kSniWatcherService,
kSniWatcherPath,
QDBusConnection::sessionBus(),
this);
connect(_statusNotifierWatcher, SIGNAL(StatusNotifierHostRegistered()), SLOT(checkForRegisteredHosts()));
connect(_statusNotifierWatcher, SIGNAL(StatusNotifierHostUnregistered()), SLOT(checkForRegisteredHosts()));
// Client instance for notifications
_notificationsClient = new org::freedesktop::Notifications(kXdgNotificationsService,
kXdgNotificationsPath,
QDBusConnection::sessionBus(),
this);
connect(_notificationsClient, SIGNAL(NotificationClosed(uint, uint)), SLOT(notificationClosed(uint, uint)));
connect(_notificationsClient, SIGNAL(ActionInvoked(uint, QString)), SLOT(notificationInvoked(uint, QString)));
if (_notificationsClient->isValid()) {
QStringList desktopCapabilities = _notificationsClient->GetCapabilities();
_notificationsClientSupportsMarkup = desktopCapabilities.contains("body-markup");
_notificationsClientSupportsActions = desktopCapabilities.contains("actions");
}
#ifdef HAVE_DBUSMENU
new QuasselDBusMenuExporter(menuObjectPath(), trayMenu(), _statusNotifierItemDBus->dbusConnection()); // will be added as menu child
#endif
}
CJobRunner::CJobRunner(QWidget *parent, int xid)
: KDialog(parent),
itsIt(itsUrls.end()),
itsEnd(itsIt),
itsAutoSkip(false),
itsCancelClicked(false),
itsModified(false),
itsTempDir(0L)
{
setModal(true);
if(NULL==parent && 0!=xid)
XSetTransientForHint(QX11Info::display(), winId(), xid);
itsStack = new QStackedWidget(this);
setMainWidget(itsStack);
QStyleOption option;
option.initFrom(this);
int iconSize=style()->pixelMetric(QStyle::PM_MessageBoxIconSize, &option, this);
QFrame *page = new QFrame(itsStack);
QGridLayout *layout=new QGridLayout(page);
layout->setMargin(KDialog::marginHint());
layout->setSpacing(KDialog::spacingHint());
itsStatusLabel=new QLabel(page);
itsProgress=new QProgressBar(page);
// itsStatusLabel->setWordWrap(true);
layout->addWidget(itsActionLabel = new CActionLabel(this), 0, 0, 2, 1);
layout->addWidget(itsStatusLabel, 0, 1);
layout->addWidget(itsProgress, 1, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 2, 0);
itsStack->insertWidget(PAGE_PROGRESS, page);
page=new QFrame(itsStack);
layout=new QGridLayout(page);
layout->setMargin(KDialog::marginHint());
layout->setSpacing(KDialog::spacingHint());
itsSkipLabel=new QLabel(page);
itsSkipLabel->setWordWrap(true);
addIcon(layout, page, "dialog-error", iconSize);
layout->addWidget(itsSkipLabel, 0, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 1, 0);
itsStack->insertWidget(PAGE_SKIP, page);
page=new QFrame(itsStack);
layout=new QGridLayout(page);
layout->setMargin(KDialog::marginHint());
layout->setSpacing(KDialog::spacingHint());
itsErrorLabel=new QLabel(page);
itsErrorLabel->setWordWrap(true);
addIcon(layout, page, "dialog-error", iconSize);
layout->addWidget(itsErrorLabel, 0, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 1, 0);
itsStack->insertWidget(PAGE_ERROR, page);
page=new QFrame(itsStack);
layout=new QGridLayout(page);
layout->setMargin(KDialog::marginHint());
layout->setSpacing(KDialog::spacingHint());
QLabel *cancelLabel=new QLabel(i18n("<h3>Cancel?</h3><p>Are you sure you wish to cancel?</p>"), page);
cancelLabel->setWordWrap(true);
addIcon(layout, page, "dialog-warning", iconSize);
layout->addWidget(cancelLabel, 0, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 1, 0);
itsStack->insertWidget(PAGE_CANCEL, page);
if(KSharedConfig::openConfig(KFI_UI_CFG_FILE)->group(CFG_GROUP).readEntry(CFG_DONT_SHOW_FINISHED_MSG, false))
itsDontShowFinishedMsg=0L;
else
{
page=new QFrame(itsStack);
layout=new QGridLayout(page);
layout->setMargin(KDialog::marginHint());
layout->setSpacing(KDialog::spacingHint());
QLabel *finishedLabel=new QLabel(i18n("<h3>Finished</h3>"
"<p>Please note that any open applications will need to be "
"restarted in order for any changes to be noticed.</p>"),
page);
finishedLabel->setWordWrap(true);
addIcon(layout, page, "dialog-information", iconSize);
layout->addWidget(finishedLabel, 0, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 1, 0);
itsDontShowFinishedMsg = new QCheckBox(i18n("Do not show this message again"), page);
itsDontShowFinishedMsg->setChecked(false);
layout->addItem(new QSpacerItem(0, KDialog::spacingHint(), QSizePolicy::Fixed, QSizePolicy::Fixed), 2, 0);
layout->addWidget(itsDontShowFinishedMsg, 3, 1);
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding), 4, 0);
itsStack->insertWidget(PAGE_COMPLETE, page);
}
QDBusServiceWatcher *watcher = new QDBusServiceWatcher(QLatin1String(OrgKdeFontinstInterface::staticInterfaceName()),
QDBusConnection::sessionBus(),
QDBusServiceWatcher::WatchForOwnerChange, this);
connect(watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), SLOT(dbusServiceOwnerChanged(QString,QString,QString)));
connect(dbus(), SIGNAL(status(int,int)), SLOT(dbusStatus(int,int)));
setMinimumSize(420, 160);
}
QDBusViewer::QDBusViewer(const QDBusConnection &connection, QWidget *parent) :
QWidget(parent),
c(connection),
objectPathRegExp(QLatin1String("\\[ObjectPath: (.*)\\]"))
{
servicesModel = new QStringListModel(this);
servicesFilterModel = new QSortFilterProxyModel(this);
servicesFilterModel->setSourceModel(servicesModel);
servicesFilterModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
serviceFilterLine = new QLineEdit(this);
serviceFilterLine->setPlaceholderText(tr("Search..."));
servicesView = new QListView(this);
servicesView->setModel(servicesFilterModel);
connect(serviceFilterLine, SIGNAL(textChanged(QString)), servicesFilterModel, SLOT(setFilterFixedString(QString)));
tree = new QTreeView;
tree->setContextMenuPolicy(Qt::CustomContextMenu);
connect(tree, SIGNAL(activated(QModelIndex)), this, SLOT(activate(QModelIndex)));
refreshAction = new QAction(tr("&Refresh"), tree);
refreshAction->setData(42); // increase the amount of 42 used as magic number by one
refreshAction->setShortcut(QKeySequence::Refresh);
connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshChildren()));
QShortcut *refreshShortcut = new QShortcut(QKeySequence::Refresh, tree);
connect(refreshShortcut, SIGNAL(activated()), this, SLOT(refreshChildren()));
QVBoxLayout *layout = new QVBoxLayout(this);
QSplitter *topSplitter = new QSplitter(Qt::Vertical, this);
layout->addWidget(topSplitter);
log = new QTextBrowser;
connect(log, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl)));
QSplitter *splitter = new QSplitter(topSplitter);
splitter->addWidget(servicesView);
QWidget *servicesWidget = new QWidget;
QVBoxLayout *servicesLayout = new QVBoxLayout(servicesWidget);
servicesLayout->addWidget(serviceFilterLine);
servicesLayout->addWidget(servicesView);
splitter->addWidget(servicesWidget);
splitter->addWidget(tree);
topSplitter->addWidget(splitter);
topSplitter->addWidget(log);
connect(servicesView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
this, SLOT(serviceChanged(QModelIndex)));
connect(tree, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(showContextMenu(QPoint)));
QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);
if (c.isConnected()) {
logMessage(QLatin1String("Connected to D-Bus."));
QDBusConnectionInterface *iface = c.interface();
connect(iface, SIGNAL(serviceRegistered(QString)),
this, SLOT(serviceRegistered(QString)));
connect(iface, SIGNAL(serviceUnregistered(QString)),
this, SLOT(serviceUnregistered(QString)));
connect(iface, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
this, SLOT(serviceOwnerChanged(QString,QString,QString)));
} else {
logError(QLatin1String("Cannot connect to D-Bus: ") + c.lastError().message());
}
objectPathRegExp.setMinimal(true);
}
KateWaiter (QCoreApplication *app, const QString &service,const QStringList &tokens)
: QObject (app), m_app (app), m_service (service),m_tokens(tokens) {
connect ( QDBusConnection::sessionBus().interface(), SIGNAL( serviceOwnerChanged( QString, QString, QString ) )
, this, SLOT(serviceOwnerChanged( QString, QString, QString )) );
}
bool AkonadiServer :: init ()
{
connect ( watcher , SIGNAL( serviceOwnerChanged ( QString, QString,QString ) ),
this, SLOT(serviceOwnerChanged(QString,QString, QString)));
return true;
}