You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdeutils/kmilo/kmilod/kmilod.cpp

228 lines
4.9 KiB

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 2; -*-
/*
This file is part of the KDE project
Copyright (c) 2003 George Staikos <staikos@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.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "kmilod.h"
#include "monitor.h"
#include <tqfile.h>
#include <klocale.h>
#include <kdebug.h>
#include <kservicetype.h>
#include <kservice.h>
#include <kconfig.h>
#include <kparts/componentfactory.h>
#include "kmilointerface.h"
#include "defaultskin.h"
using namespace KMilo;
extern "C" {
KDE_EXPORT KDEDModule *create_kmilod(const TQCString &name) {
return new KMiloD(name);
}
}
KMiloD::KMiloD(const TQCString &name) : KDEDModule(name), _interval(100)
{
_monitors.setAutoDelete(true);
_miface = new KMiloInterface(this);
// Create the display skin object
_display = new DefaultSkin;
bool shouldPoll = false;
// Load the modules
KService::List plugs = KServiceType::offers("KMilo Plugin");
for (KService::List::ConstIterator it = plugs.begin();
it != plugs.end(); ++it) {
KService::Ptr service = *it;
KMilo::Monitor *m = KParts::ComponentFactory::createInstanceFromService<KMilo::Monitor>(service, 0, service->desktopEntryName().latin1());
if (m) {
m->setInterface(_miface);
if (m->init()) {
_monitors.append(m);
kdDebug() << "KMilo loaded module "
<< service->property("Name").toString()
<< endl;
shouldPoll = shouldPoll || m->shouldPoll();
} else {
delete m;
}
}
}
// Start the timer
TQObject::connect(&_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(doTimer()));
if (shouldPoll) {
_timer.start(_interval);
}
}
KMiloD::~KMiloD()
{
_timer.stop();
// Modules are automatically cleaned up when this is done. It has
// to be done before delete _display to avoid a race though.
_monitors.clear();
delete _display;
_display = 0L;
delete _miface;
_miface = 0L;
}
void KMiloD::setEnabled(bool enabled) {
if (enabled) {
enable();
} else {
disable();
}
}
void KMiloD::enable() {
if (!_monitors.isEmpty()) {
_timer.start(_interval, false);
}
}
void KMiloD::disable() {
_timer.stop();
}
bool KMiloD::enabled() const {
return _timer.isActive();
}
int KMiloD::pollMilliSeconds() const {
return _interval;
}
bool KMiloD::setPollMilliSeconds(int ms) {
if (ms > 1000 || ms < 0) {
return false;
}
if (!_monitors.isEmpty()) {
_timer.start(_interval, false);
}
_interval = ms;
return true;
}
void KMiloD::doTimer() {
// Iterate through all the modules we have and poll
for (KMilo::Monitor *m = _monitors.first(); m; m = _monitors.next()) {
if (!m->shouldPoll()) {
continue;
}
KMilo::Monitor::DisplayType dt = m->poll();
switch (dt) {
case KMilo::Monitor::Volume:
displayProgress(i18n("Volume"), m->progress());
break;
case KMilo::Monitor::Brightness:
displayProgress(i18n("Brightness"), m->progress());
break;
case KMilo::Monitor::Mute:
displayText(i18n("Muted"));
break;
case KMilo::Monitor::Tap:
displayText(m->message());
break;
case KMilo::Monitor::Sleep:
displayText(m->message());
break;
case KMilo::Monitor::None:
// Do nothing
break;
case KMilo::Monitor::Error:
{
// On error, remove the monitor and continue
KMilo::Monitor *n = _monitors.next();
_monitors.remove(m); // deletes m
m = n;
}
break;
default:
kdWarning() << "Error in KMiloD. Please report." << endl;
break;
}
}
}
void KMiloD::displayText(const TQString& text) {
_display->displayText(text, TQPixmap());
}
void KMiloD::displayText(const TQString& text, const TQPixmap& customPixmap) {
_display->displayText(text, customPixmap);
}
void KMiloD::displayProgress(const TQString& text, int progress) {
_display->displayProgress(text, progress, TQPixmap());
}
void KMiloD::displayProgress(const TQString& text, int progress, const TQPixmap& customPixmap ) {
_display->displayProgress(text, progress, customPixmap);
}
void KMiloD::reconfigure()
{
// load the kmilo configuration file:
KConfig config("kmilodrc");
KMilo::Monitor *monitor;
for(monitor = _monitors.first(); monitor; monitor = _monitors.next())
{
monitor->reconfigure(&config);
}
}
#include "kmilod.moc"