Attachment #1915 for bug #1597

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 1597
Collapse All | Expand All

Lines 51-60 if( NOT DBUS_FOUND ) Link Here

(-)a/ConfigureChecks.cmake (-3 / +3 lines)
51	endif( )	51	endif( )
52		52
53		53
54	# check for dbus-tqt	54	# check for dbus-1-tqt
55	pkg_search_module( DBUS_TQT dbus-tqt )	55	pkg_search_module( DBUS_TQT dbus-1-tqt )
56	if( NOT DBUS_TQT_FOUND )	56	if( NOT DBUS_TQT_FOUND )
57	tde_message_fatal( "dbus-tqt is required, but was not found on your system" )	57	tde_message_fatal( "dbus-1-tqt is required, but was not found on your system" )
58	endif( )	58	endif( )
59		59
60	# check for msgfmt	60	# check for msgfmt

Lines 16-23 include_directories( Link Here

(-)a/src/CMakeLists.txt (-2 / +2 lines)
16	${CMAKE_BINARY_DIR}	16	${CMAKE_BINARY_DIR}
17	${TDE_INCLUDE_DIR}	17	${TDE_INCLUDE_DIR}
18	${TQT_INCLUDE_DIRS}	18	${TQT_INCLUDE_DIRS}
		19	${DBUS_INCLUDE_DIRS}
19	${DBUS_TQT_INCLUDE_DIRS}	20	${DBUS_TQT_INCLUDE_DIRS}
20	${HAL_INCLUDE_DIRS}
21	)	21	)
22		22
23	link_directories(	23	link_directories(
Lines 48-53 tde_add_tdeinit_executable( tdepowersave AUTOMOC Link Here
48	tdepowersave.skel log_viewer.ui logviewer.cpp main.cpp	48	tdepowersave.skel log_viewer.ui logviewer.cpp main.cpp
49	screen.cpp settings.cpp suspenddialog.cpp suspend_Dialog.ui	49	screen.cpp settings.cpp suspenddialog.cpp suspend_Dialog.ui
50	LINK	50	LINK
51	${DBUS_TQT_LIBRARIES} tdeio-shared ${HAL_LIBRARIES}	51	${DBUS_TQT_LIBRARIES} tdeio-shared
52	${XEXT_LIBRARIES} ${XTST_LIBRARIES} ${XSCRNSAVER_LIBRARIES}	52	${XEXT_LIBRARIES} ${XTST_LIBRARIES} ${XSCRNSAVER_LIBRARIES}
53	)	53	)

Lines 21-27 noinst_HEADERS = \ Link Here

(-)a/src/Makefile.am (-1 lines)
21	infodialog.h \	21	infodialog.h \
22	tdepowersave.h \	22	tdepowersave.h \
23	logviewer.h \	23	logviewer.h \
24	privileges.h \
25	screen.h \	24	screen.h \
26	settings.h \	25	settings.h \
27	suspenddialog.h	26	suspenddialog.h





/*! 
 * \file 	dbusInterface.cpp
 * \brief 	In this file can be found the functionality to connect to
 *		the D-Bus, to handle D-Bus session management
 *		provide wrapper to HAL lib and functions
 * \author 	Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>
 * \date    	2006-2007
 */
 
// QT - Header
#include <tqtimer.h>

// KDE Header
#include <tdelocale.h>

// DBUS - Header
#include "dbus/dbus-shared.h"
#include "dbusInterface.h"
#include <tqdbusdatalist.h>
#include <tqdbusdatamap.h>
#include <tqdbuserror.h>
#include <tqdbusmessage.h>
#include <tqdbusvariant.h>

// system headers
#include <unistd.h>

#define DBUS_CONN_NAME "TDEPowersave"

static void* myInstance = 0;

/*! The default constructor of the class dbusInterface. */
dbusInterface::dbusInterface():
    dBusConn(),
    dBusWatch(0),
    dBusLocal(0),
    systemdSession(),
    systemdSeat(0),
    systemdInhibit(-1),
    consolekitSession(),
    consolekitSeat(0)
    {
	kdDebugFuncIn(trace);

	dbus_is_connected = false;
	acquiredPolicyPower = false;

	// add pointer to this for filter_function()
	myInstance=this;

	// init connection to dbus
	initDBUS();
		kdError() << "Can't connect to D-Bus" << endl;
		m_dBusQtConnection = NULL;
	}

	kdDebugFuncOut(trace);
}

 * \retval false if disconnected
 */
bool dbusInterface::isConnectedToDBUS() {
	return dBusConn.isConnected();
}

/*! 
 * This function return information if the org.freedesktop.Policy.Power 
 * interface was claimed.
 * \return boolean with the status of claim the interface
 * \retval true if acquired 
 * \retval false if not
 */
bool dbusInterface::acquiredPolicyPowerInterface() {
	return acquiredPolicyPower;
}

/*! 
 * This function try a reconnect to D-Bus.
 * \return boolean with the result of the operation
 * \retval true if successful reconnected to D-Bus
 * \retval false if unsuccessful
 */
bool dbusInterface::reconnect() {
	// close D-Bus connection
	close();
	// init D-Bus conntection
	return (initDBUS());
}


 * \retval false if any problems
 */
bool dbusInterface::close() {
	if( dBusConn.isConnected() ) {
		if( dBusWatch ) {
			delete dBusWatch;
		}
		if( dBusLocal ) {
			delete dBusLocal;
		}
		if( systemdSeat ) {
			delete systemdSeat;
		}
		if( consolekitSeat ) {
			delete consolekitSeat;
		}
	}
	dBusConn.closeConnection(DBUS_CONN_NAME);

	return true;
}

/* ----> D-Bus section :: START <---- */

/*! 
 * This function initialise the connection to the D-Bus daemon.
 * \return boolean with the result of the operation

bool dbusInterface::initDBUS(){
	kdDebugFuncIn(trace);

	dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME);

        DBusError error;
        dbus_error_init(&error);
	
	dbus_connection = dbus_bus_get( DBUS_BUS_SYSTEM, &error );

	if( !dBusConn.isConnected() ) {
		kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl;
		TQTimer::singleShot(4000, this, TQT_SLOT(reconnect()));
		return false;
	}

	// watcher for NameOwnerChanged signals
	dBusWatch = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
	TQObject::connect(dBusWatch, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
			  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));

	// watcher for Disconnect signal
	dBusLocal = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_LOCAL, DBUS_INTERFACE_LOCAL, dBusConn);
	TQObject::connect(dBusLocal, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
			  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));

	// find already running SystemD
	TQT_DBusProxy checkSystemD(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
	if( checkSystemD.canSend() ) {
		TQValueList<TQT_DBusData> params;
		params << TQT_DBusData::fromString(SYSTEMD_LOGIN1_SERVICE);
		TQT_DBusMessage reply = checkSystemD.sendWithReply("NameHasOwner", params);
		if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 && reply[0].toBool() ) {
			onServiceRegistered(SYSTEMD_LOGIN1_SERVICE);
		}

	/* add a match rule to catch all signals going through the bus with ConsoleKit Interface */
	dbus_bus_add_match( dbus_connection, "type='signal',"
			    "interface='org.freedesktop.ConsoleKit.Session'," 
			    "member='ActiveChanged'", NULL);

	m_dBusQtConnection = new DBusQt::Connection(this);
        m_dBusQtConnection->dbus_connection_setup_with_qt_main(dbus_connection);

	dbus_is_connected = true;

	kdDebugFuncOut(trace);
	return true;
}

/*!
 * This function acquire the org.freedesktop.Policy.Power interface
 * \return boolean with the result of the operation
 * \retval true 	if successful acquired the interface
 * \retval false 	if unsuccessful
 */
bool dbusInterface::acquirePolicyPowerIface(){
	kdDebugFuncIn(trace);

	if (dbus_connection == NULL) {
		kdDebugFuncOut(trace);
		return false;
	}

	// find already running ConsoleKit
	TQT_DBusProxy checkConsoleKit(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
	if( checkConsoleKit.canSend() ) {
		TQValueList<TQT_DBusData> params;
		params << TQT_DBusData::fromString(CK_SERVICE);
		TQT_DBusMessage reply = checkConsoleKit.sendWithReply("NameHasOwner", params);
		if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 && reply[0].toBool() ) {
			onServiceRegistered(CK_SERVICE);
		}
		case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
			kdDebug() << "Acquired org.freedesktop.Policy.Power interface" << endl;
			acquiredPolicyPower = true;
			break;
		case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
			kdWarning() << "Queued to acquire org.freedesktop.Policy.Power interface" << endl;
			acquiredPolicyPower = false;
			break;
		default:
			acquiredPolicyPower = false;
			break;
	}

	kdDebugFuncOut(trace);
	return true;
}

/*! 
 * This function handles signals from the D-Bus daemon.
 * \return boolean with the result of the operation
 * \retval true 	if successful acquired the interface
 * \retval false 	if unsuccessful
 */
void dbusInterface::handleDBusSignal(const TQT_DBusMessage& msg) {
	// dbus terminated
	if( msg.path() == DBUS_PATH_LOCAL
	 && msg.interface() == DBUS_INTERFACE_LOCAL
	 && msg.member() == "Disconnected" ) {
		close();
		TQTimer::singleShot(1000, this, TQT_SLOT(reconnect()));
		return;
		kdDebugFuncOut(trace);
		return false;
	}

	// service registered / unregistered
	if( msg.path() == DBUS_PATH_DBUS
	 && msg.interface() == DBUS_INTERFACE_DBUS
	 && msg.member() == "NameOwnerChanged" ) {
		if( msg[1].toString().isEmpty() ) {
			// old-owner is empty
			onServiceRegistered(msg[0].toString());
	} else {
		switch (result) {
			case DBUS_RELEASE_NAME_REPLY_RELEASED:
				kdDebug() << "Released org.freedesktop.Policy.Power interface" << endl;
				retval = true;
				acquiredPolicyPower = false;
				break;
			case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
				kdWarning() << "Couldn't release org.freedesktop.Policy.Power, not the owner" << endl;
				break;
			case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
				kdWarning() << "Couldn't release org.freedesktop.Policy.Power, Iface not existing" << endl;
				break;
			default:
				kdWarning() << "Couldn't release org.freedesktop.Policy.Power, unknown error" << endl;
				break;
		}
		if( msg[2].toString().isEmpty() ) {
			// new-owner is empty
			onServiceUnregistered(msg[0].toString());
		}
		return;
	}
		
	return retval;
	kdDebugFuncOut(trace);
}

/*! 
 * This function check if the org.freedesktop.Policy.Power 
 * interface is owned by someone
 * \return boolean with the result of the operation
 * \retval true 	if the interface is owned by someone
 * \retval false 	if else
 */
bool dbusInterface::isPolicyPowerIfaceOwned(){
	kdDebugFuncIn(trace);

	// systemd session changed
	if( systemdSeat && systemdSeat->canSend()
	 && msg.path() == systemdSeat->path()
	 && msg.interface() == DBUS_INTERFACE_PROPERTIES
	 && msg.member() == "PropertiesChanged"
	 && msg[0].toString() == SYSTEMD_LOGIN1_SEAT_IFACE) {
		bool activeSessionProperty = false;
		TQT_DBusDataMap<TQString> map = msg[1].toStringKeyMap();
		TQT_DBusDataMap<TQString>::const_iterator it = map.begin();
		for (; !activeSessionProperty && it != map.end(); ++it) {
			if( it.key() != "ActiveSession" ) {
				activeSessionProperty = true;
			}
		}
		TQValueList<TQString> list = msg[2].toList().toStringList();
		TQValueList<TQString>::const_iterator it1 = list.begin();
		for (; !activeSessionProperty && it1 != list.end(); ++it1) {
			if( (*it1) == "ActiveSession" ) {
				activeSessionProperty = true;
			}
		}
		if( activeSessionProperty ) {
			emit activeSessionChanged(checkActiveSession());
		}
		return;
	}

	// consolekit session changed
	if( consolekitSeat && consolekitSeat->canSend()
	 && msg.path() == consolekitSeat->path()
	 && msg.interface() == CK_SEAT_IFACE
	 && msg.member() == "ActiveSessionChanged") {
		emit activeSessionChanged(msg[0].toString() == TQString(consolekitSession));
		return;
	}

	kdDebugFuncOut(trace);
	return retval;
}

/* ----> DBUS section :: END   <---- */

/* ----> D-Bus methode calls functions :: START <---- */
/*! 
 * This function call a D-Bus method
 * \param interface	TQString with te dbus interface
 * \param path		TQString with the object path
 * \param object	TQString with the object name
 * \param method	TQString with the name of the methode
 * \param first_arg_type integer with the dbus type of the first argument
 * \param ... 		more arguments
 * \return 		If the query was successful or not
 */
bool dbusInterface::dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
			   	    int first_arg_type, ... ) {
	kdDebugFuncIn(trace);
	
	bool _ret = false;
        va_list var_args;

        va_start(var_args, first_arg_type);
	_ret = dbusMethodCall( interface, path, object, method, DBUS_BUS_SYSTEM,
			       NULL, -1, first_arg_type, var_args);
	va_end(var_args);
	
	kdDebugFuncOut(trace);
	return _ret;
}


/*! 
 * This overloaded function call a D-Bus method on the D-Bus system bus with a return value
 * \param interface	 TQString with the dbus interface
 * \param path		 TQString with the object path
 * \param object	 TQString with the object name
 * \param method	 TQString with the name of the method
 * \param retvalue	 void pointer to arguments, if NULL we make a simple call
 * \param retval_type    Integer with the dbus type of the return value, set to -1 if retvalue is NULL
 * \param first_arg_type Integer with the dbus type of the first argument followed by the value
 * \return 		 If the query was successful or not
 */
bool dbusInterface::dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
				    void *retvalue, int retval_type, int first_arg_type, ... ) {
	kdDebugFuncIn(trace);
	
	bool _ret = false;
        va_list var_args;

        va_start(var_args, first_arg_type);
	_ret = dbusMethodCall( interface, path, object, method, DBUS_BUS_SYSTEM, 
			       retvalue, retval_type, first_arg_type, var_args);
	va_end(var_args);
	
	kdDebugFuncOut(trace);
	return _ret;
}

/*!
 * This function handles dBus service registering
 * This function call a D-Bus method with a return value
 * \param interface	 TQString with the dbus interface
 * \param path		 TQString with the object path
 * \param object	 TQString with the object name
 * \param method	 TQString with the name of the method
 * \param dbus_type	 DBusBusType with the D-Bus BUS Type
 * \param retvalue	 void pointer to arguments, if NULL we make a simple call
 * \param retval_type    Integer with the dbus type of the return value, set to -1 if retvalue is NULL
 * \param first_arg_type Integer with the dbus type of the first argument followed by the value
 * \param var_args	 va_list with more arguments
 * \return 		 If the query was successful or not
 */
void dbusInterface::onServiceRegistered(const TQString& service) {
	if( service == SYSTEMD_LOGIN1_SERVICE ) {
		// get current session
		TQT_DBusProxy managerIface(SYSTEMD_LOGIN1_SERVICE, SYSTEMD_LOGIN1_PATH, SYSTEMD_LOGIN1_MANAGER_IFACE, dBusConn);
		systemdSession = TQT_DBusObjectPath();
		if( managerIface.canSend() ) {
			TQValueList<TQT_DBusData> params;
			params << TQT_DBusData::fromUInt32( getpid() );
			TQT_DBusMessage reply = managerIface.sendWithReply("GetSessionByPID", params);
			if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
				systemdSession = reply[0].toObjectPath();
			}
		}
		if( !systemdSession.isValid() ) {
			kdWarning() << "The session is not registered with systemd" << endl;
			return;
		}
		goto out;
	}

	message = dbus_message_new_method_call( interface.ascii(), path.ascii(), object.ascii(), method.ascii() );
	dbus_message_append_args_valist(message, first_arg_type, var_args);

		// get session seat
		TQT_DBusProxy sessionProperties(SYSTEMD_LOGIN1_SERVICE, systemdSession, DBUS_INTERFACE_PROPERTIES, dBusConn);
		TQT_DBusObjectPath seat;
		if( sessionProperties.canSend() ) {
			TQValueList<TQT_DBusData> params;
			params
			 << TQT_DBusData::fromString( SYSTEMD_LOGIN1_SESSION_IFACE )
			 << TQT_DBusData::fromString( "Seat" );
			TQT_DBusMessage reply = sessionProperties.sendWithReply("Get", params);
			if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
				seat = reply[0].toVariant().value.toStruct()[1].toObjectPath();
			}
		}
		if( !seat.isValid() ) {
			kdWarning() << "Unable to associate systemd session with a seat" << endl;
			return;
		if (dbus_error_is_set(&error)) {
			kdError() << "Could not send dbus message: " << error.message << endl;
			dbus_message_unref(message);
			dbus_error_free(&error);
			goto out;
		}

		// watch session changes
		systemdSeat = new TQT_DBusProxy(SYSTEMD_LOGIN1_SERVICE, seat, DBUS_INTERFACE_PROPERTIES, dBusConn);
		TQObject::connect(systemdSeat, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
				  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));

		// inhibit systemd handling of power/sleep/hibernate/lid buttons
		// http://www.freedesktop.org/wiki/Software/systemd/inhibit
		if( !systemdInhibit.isValid() && managerIface.canSend() ) {
			TQValueList<TQT_DBusData> params;
			params
			 << TQT_DBusData::fromString("handle-power-key:handle-suspend-key:handle-hibernate-key:handle-lid-switch") // what
			 << TQT_DBusData::fromString("TDEPowersave") // who
			 << TQT_DBusData::fromString("TDE handles power events") // why
			 << TQT_DBusData::fromString("block"); // mode
			TQT_DBusMessage reply = managerIface.sendWithReply("Inhibit", params);
			if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
				systemdInhibit = reply[0].toUnixFd();
			}
		} else {
			kdError() << "Revieved invalid DBUS_MESSAGE_TYPE: " << type 
				  << "expected: " << DBUS_MESSAGE_TYPE_METHOD_RETURN << endl;
			dbus_message_unref(reply);
			dbus_message_unref(message);
			goto out;
		}
		return;
	}
	if( service == CK_SERVICE ) {
		// get current session
		TQT_DBusProxy managerIface(CK_SERVICE, CK_MANAGER_OBJECT, CK_MANAGER_IFACE, dBusConn);
		consolekitSession = TQT_DBusObjectPath();
		if( managerIface.canSend() ) {
			TQValueList<TQT_DBusData> params;
			params << TQT_DBusData::fromUInt32( getpid() );
			TQT_DBusMessage reply = managerIface.sendWithReply("GetSessionForUnixProcess", params);
			if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
				consolekitSession = reply[0].toObjectPath();
			}
		}
		if( !consolekitSession.isValid() ) {
			kdWarning() << "The session is not registered with consolekit" << endl;
			return;
		}

		// get session seat
		TQT_DBusObjectPath seat;
		if( dBusConn.isConnected() ) {
			TQT_DBusMessage msg = TQT_DBusMessage::methodCall(CK_SERVICE, consolekitSession, CK_SESSION_IFACE, "GetSeatId");
			TQT_DBusMessage reply = dBusConn.sendWithReply(msg);
			if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
				seat = reply[0].toObjectPath();
			}
		}
		if( !seat.isValid() ) {
			kdWarning() << "Unable to associate consolekit session with a seat" << endl;
			return;
		}
 * Check if the user is privileged to a special privilege
 * \param privilege	TQString with the name of the requested privilege
 * \param udi		TQString with the UDI.
 * \param ressource	TQString with the name of the ressource
 * \param user		TQString with the name of the user. If empty the current user is used.
 * \return int with info if the user is allowed or not.
 * \retval 0		if not allowed
 * \retval 1		if allowed
 * \retval -1		if a error occurs or we could not query the interface
 */
int dbusInterface::isUserPrivileged(TQString privilege, TQString udi, TQString ressource, TQString user) {
	kdDebugFuncIn(trace);

		// watch session changes
		consolekitSeat = new TQT_DBusProxy(CK_SERVICE, seat, CK_SEAT_IFACE, dBusConn);
		TQObject::connect(consolekitSeat, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
				  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
		return;

	if (user.isEmpty() || user.isNull()) 
		_user = getenv("USER"); 
	else 
		_user = user.latin1();

	if (_user == NULL || privilege.isEmpty()) 
		goto out;

	_unique_name = dbus_bus_get_unique_name(dbus_connection);
	_privilege = privilege.latin1();

	// not sure if we need this, but to avoid problems
	dbus_bool_t _retval;
	const char *_ressource;
	_ressource = ressource.latin1();

	if (!dbusSystemMethodCall( "org.freedesktop.PolicyKit",
				   "/org/freedesktop/PolicyKit/Manager",
				   "org.freedesktop.PolicyKit.Manager",
				   "IsUserPrivileged",
				   &_retval, DBUS_TYPE_BOOLEAN,
				   DBUS_TYPE_STRING, &_unique_name,
				   DBUS_TYPE_STRING, &_user,
				   DBUS_TYPE_STRING, &_privilege,
				   DBUS_TYPE_STRING, &_ressource,
				   DBUS_TYPE_INVALID)) {
		retval = -1;	// only to be sure we have no changes trough the call
	} else {
		retval = (int) _retval;
	}

out:
	kdDebugFuncOut(trace);
	return retval;
}
/* ---> PolicyKit method call section :: END   <--- */

/*!
 * This function handles dBus service unregistering
 * NOTE: Because of the filter function this need to be a public function.
 *       Don't use this function in any other place than this class.
 * \param  type enum with the type of the message
 * \param  message String with the message
 * \param  string String with additional info
 */
void dbusInterface::onServiceUnregistered(const TQString& service) {
	if( service == SYSTEMD_LOGIN1_SERVICE ) {
		systemdSession = TQT_DBusObjectPath();
		if( systemdSeat ) {
			delete systemdSeat;
		}
		return;
	}
	if( service == CK_SERVICE ) {
		consolekitSession = TQT_DBusObjectPath();
		if( consolekitSeat ) {
			delete consolekitSeat;
		}
		return;
	}

	emit msgReceived_withStringString( type, message, string );
}

/*!
 * This functions is used to check if session is active

/*! 
 * This function is needed filter function for the D-Bus connection to filter
 * all needed messages from the bus which are needful for TDEPowersave. 
 * \param connection	existing connection to the D-Bus daemon
 * \param message 	the recieved message from the D-Bus daemon
 * \param data		void pointer (see dbus bindings for more information)
 * \return DBusHandlerResult
 */
bool dbusInterface::checkActiveSession() {
	if( systemdSeat && systemdSeat->canSend() ) {
		TQT_DBusObjectPath activeSession;
		TQValueList<TQT_DBusData> params;
		params
		 << TQT_DBusData::fromString( SYSTEMD_LOGIN1_SEAT_IFACE )
		 << TQT_DBusData::fromString( "ActiveSession" );
		TQT_DBusMessage reply = systemdSeat->sendWithReply("Get", params);
		if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
			activeSession = reply[0].toVariant().value.toStruct()[1].toObjectPath();
			return (activeSession == systemdSession);
	if (dbus_message_is_signal (message,
				    DBUS_INTERFACE_LOCAL,
				    "Disconnected")){
		((dbusInterface*) myInstance)->emitMsgReceived( DBUS_EVENT, "dbus.terminate", 0 );
		dbus_connection_unref(connection);
		kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}

        if ( dbus_message_get_type( message ) != DBUS_MESSAGE_TYPE_SIGNAL ) {
                if (trace) kdDebug() << "recieved message, but wasn't from type DBUS_MESSAGE_TYPE_SIGNAL" << endl;
		kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
        }

	ifaceType = dbus_message_get_interface( message );
        if (ifaceType == NULL) {
                kdDebug() << "Received message from invalid interface" << endl;
                kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
        }

	reply_wanted = !dbus_message_get_no_reply( message );

	if (ifaceType.startsWith(DBUS_INTERFACE_DBUS)) {
		if(trace) kdDebug() << "Received from DBUS_INTERFACE_DBUS" << endl;
		/* get the name of the signal */
		const char *signal = dbus_message_get_member( message );
		
		/* get the first argument. This must be a string at the moment */
		dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &value, DBUS_TYPE_INVALID );
	
		if ( dbus_error_is_set( &error ) ) {
			kdWarning() << "Received signal " << error.message << " but no string argument" << endl;
			dbus_error_free( &error );
			kdDebugFuncOut(trace);
			return DBUS_HANDLER_RESULT_HANDLED;
		}
	}
	if( consolekitSeat && consolekitSeat->canSend() ) {
		TQT_DBusObjectPath activeSession;
		TQValueList<TQT_DBusData> params;
		TQT_DBusMessage reply = consolekitSeat->sendWithReply("GetActiveSession", params);
		if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
			activeSession = reply[0].toObjectPath();
			return (activeSession == consolekitSession);
		
		else if ( ! strcmp( signal, "NameOwnerChanged" )) {
			char *service;
			char *old_owner;
			char *new_owner;
			
                	if (dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &service,
                                                   DBUS_TYPE_STRING, &old_owner,
                                                   DBUS_TYPE_STRING, &new_owner, DBUS_TYPE_INVALID)) {
				if (!strcmp(service, "org.freedesktop.Policy.Power")) {
					const char *own_name;
					
					own_name = dbus_bus_get_unique_name(((dbusInterface*) myInstance)->get_DBUS_connection());

					if (!strcmp(new_owner, own_name)) {
						kdDebug() << "=== now owner of org.freedesktop.Policy.Power ===" << endl;
						// we have now again the ower of the name!
						((dbusInterface*) myInstance)->emitMsgReceived( POLICY_POWER_OWNER_CHANGED,
											  "NOW_OWNER", 
											  NULL );
					} else {
						// some other has now the interface
						kdDebug() << "=== someone owner of org.freedesktop.Policy.Power ===" << endl;
						((dbusInterface*) myInstance)->emitMsgReceived( POLICY_POWER_OWNER_CHANGED,
											  "OTHER_OWNER", 
											  NULL );
					}
				}
			}
		}
		kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_HANDLED;	
	} else if (ifaceType.startsWith("org.freedesktop.ConsoleKit.Session")) {
		kdDebug() << "Received from org.freedesktop.ConsoleKit.Session" << endl;

		const char *session = dbus_message_get_path (message);
		const char *signal = dbus_message_get_member( message );
		
		if (! strcmp(signal, "ActiveChanged")) {
			dbus_bool_t active;

			if (dbus_message_get_args( message, &error, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID )) {
				((dbusInterface*) myInstance)->emitMsgReceived( CONSOLEKIT_SESSION_ACTIVE, 
									  session, TQString("%1").arg((int)active));
			} else {
				if (dbus_error_is_set( &error )) dbus_error_free( &error );
			}
		} else {
			kdDebug() << "Received unknown signal from org.freedesktop.ConsoleKit.Session: "
				  << signal << endl;
			kdDebugFuncOut(trace);
			return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
		}
		kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_HANDLED;
	} else {
		kdDebugFuncOut(trace);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}
	return false;
}

#include "dbusInterface.moc"

//! to get the current connection to D-Bus
DBusConnection * dbusInterface::get_DBUS_connection() {
	return dbus_connection;
}





*/
/*!
*  \class 	dbusInterface
*  \brief 	class for connection to D-Bus
*  \author 	Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>
*  \date    	2006-2007
*/

#ifndef _DBUS_INTERFACE_H_
#define _DBUS_INTERFACE_H_

#ifndef DBUS_API_SUBJECT_TO_CHANGE
#define DBUS_API_SUBJECT_TO_CHANGE

#endif

// QT - Header
#include <tqobject.h>
#include <tqstring.h>

// D-Bus Header
#include <tqdbusconnection.h>
#include <tqdbusobjectpath.h>
#include <tqdbusproxy.h>
#include <tqdbusunixfd.h>

// tdepowersave - Header
#include "tdepowersave_debug.h"

#define CK_MANAGER_IFACE	"org.freedesktop.ConsoleKit.Manager"
#define CK_MANAGER_OBJECT	"/org/freedesktop/ConsoleKit/Manager"
#define CK_SESSION_IFACE	"org.freedesktop.ConsoleKit.Session"
#define CK_SEAT_IFACE		"org.freedesktop.ConsoleKit.Seat"

#define SYSTEMD_LOGIN1_SERVICE		"org.freedesktop.login1"
#define SYSTEMD_LOGIN1_PATH		"/org/freedesktop/login1"
#define SYSTEMD_LOGIN1_MANAGER_IFACE	"org.freedesktop.login1.Manager"
#define SYSTEMD_LOGIN1_SESSION_IFACE	"org.freedesktop.login1.Session"
#define SYSTEMD_LOGIN1_SEAT_IFACE	"org.freedesktop.login1.Seat"
	HAL_CONDITION,
	CONSOLEKIT_SESSION_ACTIVE,
	POLICY_POWER_OWNER_CHANGED
};

class dbusInterface : public TQObject{
	Q_OBJECT


private:

	//! TQt connection to D-Bus
	TQT_DBusConnection dBusConn;

	//! TQt D-Bus proxy for watching signals
	TQT_DBusProxy* dBusWatch;
	TQT_DBusProxy* dBusLocal;

	TQT_DBusObjectPath systemdSession;
	TQT_DBusProxy* systemdSeat;
	TQT_DBusUnixFd systemdInhibit;

	TQT_DBusObjectPath consolekitSession;
	TQT_DBusProxy* consolekitSeat;
	//! if we could claim the org.freedesktop.Policy.Power interface
	/*!
	* This boolean represent information if TDEPowersave could claim the 
	* org.freedesktop.Policy.Power interface from the D-Bus
	* \li true:  if acquired
	* \li false: if not
	*/
	bool acquiredPolicyPower;

	/* D-Bus helper functions */
	//! to initialise the connection to D-Bus 
	bool initDBUS();

	//! handles signal service registred/unregistered
	void onServiceRegistered(const TQString&);
	void onServiceUnregistered(const TQString&);

private slots:

	//! to reconnect to D-Bus
	bool reconnect();

public:


	//! default destructor
	~dbusInterface();

	//! to close the connection to D-Bus
	bool reconnect();
	//! to close the connection to D-Bus and HAL
	bool close();

	//! to acquire the org.freedesktop.Policy.Power interface
	bool acquirePolicyPowerIface();
	//! to release the org.freedesktop.Policy.Power interface
	bool releasePolicyPowerIface();
	//! to check if the org.freedesktop.Policy.Power interface has an owner
	bool isPolicyPowerIfaceOwned();

	// --- helper to get private members of the class --- //
	//! to get information if TDEPowersave is connected to D-Bus
	bool isConnectedToDBUS();
	//! to get info about claim org.freedesktop.Policy.Power interface
	bool acquiredPolicyPowerInterface();

	//! to check active session state
	bool checkActiveSession();

public slots:

	void handleDBusSignal(const TQT_DBusMessage&);
	//! to call a methode on a dbus system bus method without reply
	bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
				   int first_arg_type, ... );
	//! to call a methode on a dbus system bus method with reply
	bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method, 
				   void *retvalue, int retval_type, int first_arg_type, ... );

signals:
	//! check if the user has a requested privilege
	int isUserPrivileged( TQString privilege, TQString udi, TQString ressource = "", TQString user = TQString());

	void activeSessionChanged(bool);
	void emitMsgReceived( msg_type type, TQString message, TQString string );

signals:
        //! signal with message to forward from D-Bus to HAL
	void msgReceived_withStringString( msg_type, TQString, TQString );
	//! signal if we resumed!
	void backFromSuspend( int result );
};

//! filter function to filter out needed information from D-Bus messages
DBusHandlerResult filterFunction (DBusConnection *connection, DBusMessage *message, void *data);

#endif




// include own header
#include "hardware.h"
#include "tdepowersave_debug.h"
#include "privileges.h"

// #define USE_EVENT_DEVICES_DIRECTLY 1


	laptop = false;
	brightness = false;
	brightness_in_hardware = false;
	schedPowerSavings = false;
	sessionIsActive = true;	 // assume as first we are active

	// initialize connection to the TDE hardware library

	primaryBatteries = new BatteryCollection(BAT_PRIMARY);
	setPrimaryBatteriesWarningLevel(); // force default settings

	// connect to D-Bus
	dbus_iface = new dbusInterface();
	sessionIsActive = dbus_iface->checkActiveSession();
	connect(dbus_iface, TQT_SIGNAL(activeSessionChanged(bool)), this, TQT_SLOT(handleSessionState(bool)));
	} else {
		kdError() << "Could not connect to D-Bus & HAL" << endl;
	}

	checkConsoleKitSession();
	checkPowermanagement();
	checkIsLaptop();
	checkBrightness();
	checkCPUFreq();
	// getSchedPowerSavings();
	checkSuspend();
	intialiseHWInfo();


	checkCPUFreq();
	checkSuspend();
	intialiseHWInfo();
	// getSchedPowerSavings();
	updatePrimaryBatteries();

	kdDebugFuncOut(trace);
	return true;
}


/*!
 * \b TQT_SLOT called if the state of the current session change
 * \param state boolean represent the state of the session
 */
void HardwareInfo::handleSessionState( bool state ) {
    if( state != sessionIsActive ) {
	sessionIsActive = state;
	TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
    }
}

/*!
 * This function is used to parse changed hardware nofifications from the TDE hardware library
 * \param device 	a \ref TDEGenericDevice* which should be processed
 */
void HardwareInfo::processHardwareChangedEvent (TDEGenericDevice* device) {

}

/*!
 * This funtion is used to parse a message from D-Bus for the different
 * messagetypes and events.
 * \param type 		a \ref msg_type which should be parse/processed
 * \param message 	the message
 * \param value 	an optional message value as e.g. message string
 */
void HardwareInfo::processMessage (msg_type type, TQString message, TQString value) {
	kdDebugFuncIn(trace);

	switch(type) {
		case ACPI_EVENT:
			// we don't handle acpi events here atm
			break;
		case HAL_DEVICE:
			// --> we can maybe ignore these events except for batteries, not shure atm
			int _type;

			if (message.startsWith("DeviceAdded")) {
				if (checkIfHandleDevice(value, &_type)) {
					switch (_type) {
						case BATTERY:
						case AC_ADAPTER:
						case BUTTON_SLEEP:
						case BUTTON_POWER:
						case LID:
							// TODO: handle code if needed actually not
							break;
						case LAPTOP_PANEL:
							checkBrightness();
							break;
						default:
							kdDebug() << "New device added Device udi: "
								  << value << "type: " << _type << endl;
							break;
					}
				}
			} else if (message.startsWith("DeviceRemoved")) {
				if (allUDIs.contains(value)) {
					if (checkIfHandleDevice(value, &_type)) {
						switch (_type) {
							case BATTERY:
							case AC_ADAPTER:
							case BUTTON_SLEEP:
							case BUTTON_POWER:
							case LID:
								// TODO: handle code if needed
								break;
							case LAPTOP_PANEL:
								checkBrightness();
								break;
							default:
								kdDebug() << "Couldn't handle unknown device" << endl;
								break;
						}
					}
				} else {
					kdDebug() << "Not monitored device removed: " << value << endl;
				}
			} else {
				kdDebug() << "Unknown HAL_DEVICE message: " << message << endl;
			}
			break;
		case CONSOLEKIT_SESSION_ACTIVE:
			if (!message.isEmpty() && !value.isEmpty()) {
				if (message == consoleKitSession) {
					if (value == "1") {
						sessionIsActive = true;
					} else {
						sessionIsActive = false;
					}
					TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
				} else {
					if (trace)
						kdDebug() << "CONSOLEKIT_SESSION_ACTIVE: not our session" << endl;
				}
			}
			break;
		case POLICY_POWER_OWNER_CHANGED:
			if (message.startsWith("NOW_OWNER")) {
				// TODO: add code
			} else if (message.startsWith("OTHER_OWNER")){
				// TODO: add code
			}
			break;
		default:
			kdDebug() << "Recieved unknown package type: " << type << endl;
			break;
	}

	kdDebugFuncOut(trace);
}

/*!
 * This TQT_SLOT is used to fetch the resume signal and multiplex. If needed some
 * actions after resume, do this here.
 * \param result 	integer with the result of the resume/suspend

}

/*!
 * This function checks the session for the running TDEPowersave instance
 * \return 		Boolean with result of operation
 * \retval true		if the query/check could get finished
 * \retval false	on every error
 */
bool HardwareInfo::checkConsoleKitSession () {
	kdDebugFuncIn(trace);

	bool retval = false;

	if (dbus_HAL->isConnectedToDBUS()) {
		char *reply;
		char *cookie = getenv("XDG_SESSION_COOKIE");

		if (cookie == NULL) {
			kdDebug() << "Could not get XDG_SESSION_COOKIE from environment" << endl;
			sessionIsActive = true;
		} else {
			if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, CK_MANAGER_OBJECT,
							CK_MANAGER_IFACE, "GetSessionForCookie",
							&reply, DBUS_TYPE_OBJECT_PATH,
							DBUS_TYPE_STRING, &cookie,
							DBUS_TYPE_INVALID)) {
				if (trace)
					kdDebug() << "GetSessionForCookie returned: " << reply << endl;

				if (reply != NULL) {
					dbus_bool_t i_reply;
					consoleKitSession = reply;

					if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, consoleKitSession,
									    CK_SESSION_IFACE, "IsActive",
									    &i_reply, DBUS_TYPE_BOOLEAN,
									    DBUS_TYPE_INVALID)) {
						sessionIsActive = ((i_reply != 0) ? true: false);
						if (trace)
							kdDebug() << "IsActive returned: " << sessionIsActive << endl;

						retval = true;
					} else {
						kdError() << "Could get session cookie and session name, but not "
							<< "but not the status of the session. Assume for now "
							<< "the Session is inactive!" << endl;
						sessionIsActive = false;
					}
				}
			}
		}
	}

	kdDebugFuncOut(trace);
	return retval;
}

/*!
 * This function check for a given UDI, if we should handle a device
 * \param _udi		TQString with the UDI of the device
 * \param *type		pointer to a integer to return the type of the device, see \ref device_type

	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);

	if (hwlist.count() > 0) {
		dbus_bool_t consider = (dbus_bool_t) getAcAdapter();
		TQStringList dynamic;

		if (checkCurrentCPUFreqPolicy() == cpufreq) {

					}
				}

#if 0
				// FIXME
				// What does "SetCPUFreqConsiderNice" actually do??!?!

				// correct set ondemand
				if (!dbus_HAL->dbusSystemMethodCall( HAL_SERVICE, HAL_COMPUTER_UDI,
								     HAL_CPUFREQ_IFACE,
								     "SetCPUFreqConsiderNice",
								     DBUS_TYPE_BOOLEAN, &consider,
								     DBUS_TYPE_INVALID)) {
					kdError() << "Couldn't set SetCPUFreqConsiderNice for DYNAMIC" << endl;
				}

#endif
				// Set performance limits on all CPUs
				TDEGenericDevice *hwdevice;
				TDECPUDevice *cpudevice;

bool HardwareInfo::setCPUFreqGovernor( const char *governor ) {
	kdDebugFuncIn(trace);

	int reply;
	bool ret = true;

	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);

}


/*!
 * Function to set the powersave mode (incl. e.g. disk settings) via TDE hardware library.
 * \param  on		boolean which tell if enable/disable powersave mode
 * \return boolean with result of the operation
 * \retval true  	if successful
 * \retval false 	else, if a error occurs
 */
bool HardwareInfo::setPowerSave( bool on ) {
	kdDebugFuncIn(trace);

	bool retval = false;

	// FIXME
	// Set up power saving to the best of our ability using "raw" functions
	printf("[FIXME] HardwareInfo::setPowerSave unimplemented!\n"); fflush(stdout);

	kdDebugFuncOut(trace);
	return retval;
}

/*!
 * Function to call GetSchedPowerSavings() via TDE hardware library.
 * \return boolean with result of the operation
 * \retval true  	if successful
 * \retval false 	else, if a error occurs
 */
bool HardwareInfo::getSchedPowerSavings() {
	kdDebugFuncIn(trace);

	bool returnval = false;

	// What does the HAL method GetSchedPowerSavings actually do?!?!?

	kdDebugFuncOut(trace);
	return returnval;
}

/*!
 * Function to call SetSchedPowerSavings() via TDE hardware library.
 * Note: this would only work on multiprocessor/-core machines.
 * \return boolean with result of the operation
 * \retval true  	if successful
 * \retval false 	else, if a error occurs
 */
bool HardwareInfo::setSchedPowerSavings( bool enable ) {
	kdDebugFuncIn(trace);

	bool retval = false;

	// What does the HAL method SetCPUFreqPerformance actually do?!?!?

	kdDebugFuncOut(trace);
	return retval;
}


// --> TDE hardware library method call (trigger actions) section -- END <---


 * Function to emit the signal about changes in the session state
 */
void HardwareInfo::emitSessionActiveState() {
	if (sessionIsActive) {
		if (!dbus_HAL->acquiredPolicyPowerInterface()) {
			dbus_HAL->acquirePolicyPowerIface();
		}
	} else {
		if (dbus_HAL->acquiredPolicyPowerInterface()) {
			dbus_HAL->releasePolicyPowerIface();
		}
	}

	emit desktopSessionIsActive(sessionIsActive);
}


	return cpuFreqAllowed;
}

/*! check if the org.freedesktop.Policy.Power interface has an owner
 * \return boolean with info if org.freedesktop.Policy.Power interface has an owner or not
 * \retval true 	if there is a owner
 * \retval false 	else
 */
bool HardwareInfo::isPolicyPowerIfaceOwned () {
	return dbus_HAL->isPolicyPowerIfaceOwned();
}


// --> get private members section -- END <---

#include "hardware.moc"




	UNKNOWN_DEVICE
};

enum ERROR_MSG {
	DBUS_NO_RIGHTS,
	DBUS_NOT_RUNNING,
	DBUS_RUNNING
};

//! hold information if suspend/standby/pm actions are supported and allowed
/*!
* This dictionary contains information about the available pm capabilities and

	TDEHardwareDevices *m_hwdevices;

	//! pointer to the dbusInterface connection class
	dbusInterface *dbus_iface;

	//! hold udis of special hardware execpt batteries represented by a TQString pairs (name,udi)
	/*!

	* \li false: 	else
	*/
	bool cpuFreq;
	//! if the machine support change *SchedPowerSavings methodes via TDE hardware library
	/*!
	* This boolean represent information if the machine support change the
	* SchedPowerSavings methodes via TDE hardware library.
	* \li true: 	if supported
	* \li false: 	else
	*/
	bool schedPowerSavings;
	//! if the machine support change brightness
	/*!
	* This boolean represent information if the machine support brightness changes.

	bool intialiseHWInfo();
	//! reinit all hardware information
	bool reinitHardwareInfos();
	//! to check the current ConsoleKit session
	bool checkConsoleKitSession();
	//! to check if we should handle a device
	bool checkIfHandleDevice ( TQString _udi, int *type );
	//! to set the CPUFreq governor
	bool setCPUFreqGovernor( const char *governor );
	//! to get the state of SchedPowerSave setting of kernel/TDE hardware library
	bool getSchedPowerSavings();
	//! to set the state of SchedPowerSave setting of kernel/TDE hardware library
	bool setSchedPowerSavings( bool enable );

	//! find and update a battery information
	void updateBatteryValues (TDEGenericDevice* device);

private slots:

	//! handle changes of the session state
	void handleSessionState (bool state);
	//! to fetch events from the TDE hardware library and handle them
	void processHardwareChangedEvent (TDEGenericDevice*);
	//! to fetch keypresses from the TDE hardware library and handle them

	void batteryWARNState(int type, int state);

	// Error signals
	//! signal if the HAL daemon terminate and restart
	void halRunning( bool );
	//! signal if the D-Bus daemon terminate and restart
	void dbusRunning( int );

	//! signal if the IsActive state of
	void desktopSessionIsActive (bool);

	*/
	bool update_info_primBattery_changed;

	//! boolean which tell us if the D-Bus daemon was terminated
	/*!
	* This boolean contains information if the D-Bus daemon terminated and
	* we recieved "dbus.terminate"
	* \li true:  If D-Bus terminated
	* \li false: If D-Bus not terminated
	*/
	bool dbus_terminated;

	// --> functions
	//! default constructor
	HardwareInfo();

	//! if the user is allowed to change CPU Freq PolicyKit
	int isCpuFreqAllowed ();

	//! if org.freedesktop.Policy.Power has a owner
	bool isPolicyPowerIfaceOwned();

	//! get state of the AC adapter
	bool getAcAdapter() const;
	//! get the state of the lid button

	bool setBrightnessUp(int percentageStep = -1);
	//! set the CPU frequency policy/speed
	bool setCPUFreq ( cpufreq_type cpufreq, int limit = 51 );
	//! call SetPowerSave method on TDE hardware library.
	bool setPowerSave( bool on );

	//! function to set warning states for the primary battery collection
	void setPrimaryBatteriesWarningLevel (int _warn = -1, int _low = -1, int _crit = -1 );




	// For now just report any batteries as primary...
	type = BAT_PRIMARY;
	return true;

#if 0
	if (dbus_HAL->halGetPropertyString(udi,"battery.type", &tmp_qstring)) {
		if (tmp_qstring.compare("primary") == 0) {
			type = BAT_PRIMARY;
		} else if (tmp_qstring.compare("mouse") == 0) {
			type = BAT_MOUSE;
		} else if (tmp_qstring.compare("keyboard") == 0) {
			type = BAT_KEYBOARD;
		} else if (tmp_qstring.compare("keyboard_mouse") == 0) {
			type = BAT_KEY_MOUSE;
		} else if (tmp_qstring.compare("camera") == 0) {
			type = BAT_CAMERA;
		} else if (tmp_qstring.compare("ups") == 0) {
			type = BAT_UPS;
		} else {
			//anything else will currently be "UNKNOWN"
			type = BAT_UNKNOWN;
		}
		kdDebugFuncOut(trace);
		return true;
	} else {
		//query was not successfull
		kdWarning() << "Query of battery.type of " << udi << " was not successfull." << endl;
		type = BAT_UNKNOWN;
		kdDebugFuncOut(trace);
		return false;
	}
#endif
}

//! to check battery.technology

Lines 45-51 Link Here

(-)a/src/hardware_battery.h (-1 / +1 lines)
45	// TDE hardware library	45	// TDE hardware library
46	#include <tdehardwaredevices.h>	46	#include <tdehardwaredevices.h>
47		47
48	#include "dbusInterface.h"	48	#include "tdepowersave_debug.h"
49		49
50	class Battery : public TQObject {	50	class Battery : public TQObject {
51		51




/***************************************************************************
 *   Copyright (C) 2007 by Danny Kukawka                                   *
 *                         <dkukawka@suse.de, danny.kukawka@web.de>        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of version 2 of the GNU General Public License     *
 *   as published by the Free Software Foundation.                         *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
 ***************************************************************************/

/*! 
*  \file 	privileges.h
*  \brief 	Headerfile containing defines for privileges
*  \author 	Danny Kukawka, <dkukawka@suse.de, danny.kukawka@web.de>
*  \date    	2007
*/

#ifndef _PRIVILEGES_H_
#define _PRIVILEGES_H_

#ifdef HAVE_HAL_0_5_10
 #define PRIV_SUSPEND		"org.freedesktop.hal.power-management.suspend"
 #define PRIV_HIBERNATE		"org.freedesktop.hal.power-management.hibernate"
 #define PRIV_STANDBY		"org.freedesktop.hal.power-management.standby"
 #define PRIV_CPUFREQ		"org.freedesktop.hal.power-management.cpufreq"
 #define PRIV_LAPTOP_PANEL	"org.freedesktop.hal.power-management.lcd-panel"
 #define PRIV_SETPOWERSAVE	"org.freedesktop.hal.power-management.set-powersave"
#else
 #define PRIV_SUSPEND		"hal-power-suspend"
 #define PRIV_HIBERNATE		"hal-power-hibernate"
 #define PRIV_STANDBY		"hal-power-standby"
 #define PRIV_CPUFREQ		"hal-power-cpufreq"
 #define PRIV_LAPTOP_PANEL	"hal-power-lcd-panel"
 #define PRIV_SETPOWERSAVE	"hal-power-set-powersave"
#endif

#endif




bool Settings::load_scheme_settings(TQString schemeName){

	tdeconfig->reparseConfiguration();
	bool setToDefault = false;

	if( schemeName == "Performance" || schemeName == i18n("Performance"))
		 schemeName = "Performance";

			// fallback to 'default-scheme'
			tdeconfig->setGroup("default-scheme");
			schemeName = "default-scheme";
			setToDefault = true;
		}
		currentScheme = schemeName;


		psMsgAsPassivePopup = tdeconfig->readBoolEntry("psMsgAsPassivePopup",false);
		forceDpmsOffOnLidClose = tdeconfig->readBoolEntry("forceDpmsOffOnLidClose",false);
		unmountExternalOnSuspend = tdeconfig->readBoolEntry("unmountExternalOnSuspend",true);
		callSetPowerSaveOnAC = tdeconfig->readBoolEntry("callSetPowerSaveOnAC",true);

		lockmethod = tdeconfig->readEntry("lockMethod", "NULL");
		if(lockmethod == "NULL") lockmethod = "automatic";




	 * \li false: if not
	 */
	bool forceDpmsOffOnLidClose;
	//! if tdepowersave should call SetPowerSave() on HAL
	/*!
	 * This boolean tells if tdepowersave should call SetPowerSave on HAL depending
	 * on the AC state.
	 * \li true:  if should call
	 * \li false: if not
	 */
	bool callSetPowerSaveOnAC;

	//! time after resume to fake keyevent
	/*!




		}
	}

	// call setPowerSave() depending on AC state
	if (settings->callSetPowerSaveOnAC) {
		if (hwinfo->getAcAdapter())
			hwinfo->setPowerSave(false);
		else
			hwinfo->setPowerSave(true);
	}

	// --> set autosuspend settings
	if(settings->autoSuspend) {
		setAutoSuspend(false);

				break;
		}
	} else if (batWarnCall) {
		// FIXME
		// Is there a way to check if is active power manager on currently active session?
		if (true) {
			switch (action) {
				case GO_SHUTDOWN:
					// to be sure if we really need the shutdown
					if ((checkAC && !hwinfo->getAcAdapter()) || !checkAC ) {
						DCOPRef shutdown = DCOPRef( "ksmserver", "ksmserver" );
						shutdown.send("logout", 0, 2, 2);

	if(hwinfo->isOnline()) {
		return settings->currentScheme;
	} else {
		return "ERROR: D-Bus not running";
	}

	kdDebugFuncOut(trace);

		}
		return _cpuFreq;
	} else {
		return "ERROR: DBus not running";
	}

	kdDebugFuncOut(trace);

		}
	}
	else {
		sleepList.append("ERROR: D-Bus not running");
	}

	kdDebugFuncOut(trace);

		}
	}
	else {
		_schemeList.append("ERROR: D-Bus not running");
	}

	kdDebugFuncOut(trace);

Return to bug 1597

Lines 23-35 Link Here

(-)a/src/dbusInterface.h (-75 / +43 lines)
23	*/	23	*/
24	/*!	24	/*!
25	* \class dbusInterface	25	* \class dbusInterface
26	* \brief class for connection to HAL via D-Bus	26	* \brief class for connection to D-Bus
27	* \author Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>	27	* \author Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>
28	* \date 2006-2007	28	* \date 2006-2007
29	*/	29	*/
30		30
31	#ifndef _DBUSHAL_H_	31	#ifndef _DBUS_INTERFACE_H_
32	#define _DBUSHAL_H_	32	#define _DBUS_INTERFACE_H_
33		33
34	#ifndef DBUS_API_SUBJECT_TO_CHANGE	34	#ifndef DBUS_API_SUBJECT_TO_CHANGE
35	#define DBUS_API_SUBJECT_TO_CHANGE	35	#define DBUS_API_SUBJECT_TO_CHANGE
Lines 41-52 Link Here
41	#endif	41	#endif
42		42
43	// QT - Header	43	// QT - Header
		44	#include <tqobject.h>
44	#include <tqstring.h>	45	#include <tqstring.h>
45		46
46	// D-Bus Header	47	// D-Bus Header
47	#include <dbus/dbus.h> // needed for dbus_bool_t	48	#include <tqdbusconnection.h>
48	#include <dbus/message.h>	49	#include <tqdbusobjectpath.h>
49	#include <dbus/connection.h>	50	#include <tqdbusproxy.h>
		51	#include <tqdbusunixfd.h>
50		52
51	// tdepowersave - Header	53	// tdepowersave - Header
52	#include "tdepowersave_debug.h"	54	#include "tdepowersave_debug.h"
Lines 55-70 Link Here
55	#define CK_MANAGER_IFACE "org.freedesktop.ConsoleKit.Manager"	57	#define CK_MANAGER_IFACE "org.freedesktop.ConsoleKit.Manager"
56	#define CK_MANAGER_OBJECT "/org/freedesktop/ConsoleKit/Manager"	58	#define CK_MANAGER_OBJECT "/org/freedesktop/ConsoleKit/Manager"
57	#define CK_SESSION_IFACE "org.freedesktop.ConsoleKit.Session"	59	#define CK_SESSION_IFACE "org.freedesktop.ConsoleKit.Session"
		60	#define CK_SEAT_IFACE "org.freedesktop.ConsoleKit.Seat"
58		61
59	enum msg_type {	62	#define SYSTEMD_LOGIN1_SERVICE "org.freedesktop.login1"
60	ACPI_EVENT,	63	#define SYSTEMD_LOGIN1_PATH "/org/freedesktop/login1"
61	DBUS_EVENT,	64	#define SYSTEMD_LOGIN1_MANAGER_IFACE "org.freedesktop.login1.Manager"
62	HAL_DEVICE,	65	#define SYSTEMD_LOGIN1_SESSION_IFACE "org.freedesktop.login1.Session"
63	HAL_PROPERTY_CHANGED,	66	#define SYSTEMD_LOGIN1_SEAT_IFACE "org.freedesktop.login1.Seat"
64	HAL_CONDITION,
65	CONSOLEKIT_SESSION_ACTIVE,
66	POLICY_POWER_OWNER_CHANGED
67	};
68		67
69	class dbusInterface : public TQObject{	68	class dbusInterface : public TQObject{
70	Q_OBJECT	69	Q_OBJECT
Lines 72-106 class dbusInterface : public TQObject{ Link Here
72		71
73	private:	72	private:
74		73
75	//! QT connection to D-Bus	74	//! TQt connection to D-Bus
76	DBusQt::Connection* m_dBusQtConnection;	75	TQT_DBusConnection dBusConn;
77	//! real connection to D-Bus	76
78	DBusConnection *dbus_connection;	77	//! TQt D-Bus proxy for watching signals
79		78	TQT_DBusProxy* dBusWatch;
80	//! to store information if TDEPowersave is connected to D-Bus	79	TQT_DBusProxy* dBusLocal;
81	/*!	80
82	* This boolean represent information about the state of the connection to D-Bus	81	TQT_DBusObjectPath systemdSession;
83	* \li true: if connected	82	TQT_DBusProxy* systemdSeat;
84	* \li false: if disconnected	83	TQT_DBusUnixFd systemdInhibit;
85	*/	84
86	bool dbus_is_connected;	85	TQT_DBusObjectPath consolekitSession;
87		86	TQT_DBusProxy* consolekitSeat;
88	//! if we could claim the org.freedesktop.Policy.Power interface
89	/*!
90	* This boolean represent information if TDEPowersave could claim the
91	* org.freedesktop.Policy.Power interface from the D-Bus
92	* \li true: if acquired
93	* \li false: if not
94	*/
95	bool acquiredPolicyPower;
96		87
97	/* D-Bus helper functions */	88	/* D-Bus helper functions */
98	//! to initialise the connection to D-Bus	89	//! to initialise the connection to D-Bus
99	bool initDBUS();	90	bool initDBUS();
100	//! to call a methode on a dbus interface with reply	91
101	bool dbusMethodCall( TQString interface, TQString path, TQString object, TQString method,	92	//! handles signal service registred/unregistered
102	DBusBusType dbus_type, void *retvalue, int retval_type,	93	void onServiceRegistered(const TQString&);
103	int first_arg_type, va_list var_args);	94	void onServiceUnregistered(const TQString&);
		95
		96	private slots:
		97
		98	//! to reconnect to D-Bus
		99	bool reconnect();
104		100
105	public:	101	public:
106		102
Lines 109-160 public: Link Here
109	//! default destructor	105	//! default destructor
110	~dbusInterface();	106	~dbusInterface();
111		107
112	//! to reconnect to D-Bus and HAL	108	//! to close the connection to D-Bus
113	bool reconnect();
114	//! to close the connection to D-Bus and HAL
115	bool close();	109	bool close();
116		110
117	//! to acquire the org.freedesktop.Policy.Power interface
118	bool acquirePolicyPowerIface();
119	//! to release the org.freedesktop.Policy.Power interface
120	bool releasePolicyPowerIface();
121	//! to check if the org.freedesktop.Policy.Power interface has an owner
122	bool isPolicyPowerIfaceOwned();
123
124	// --- helper to get private members of the class --- //	111	// --- helper to get private members of the class --- //
125	//! to get information if TDEPowersave is connected to D-Bus	112	//! to get information if TDEPowersave is connected to D-Bus
126	bool isConnectedToDBUS();	113	bool isConnectedToDBUS();
127	//! to get info about claim org.freedesktop.Policy.Power interface
128	bool acquiredPolicyPowerInterface();
129		114
130	//! return the current DBus connection	115	//! to check active session state
131	DBusConnection *get_DBUS_connection();	116	bool checkActiveSession();
132		117
133	/* D-Bus helper functions */	118	public slots:
134		119
135	/* functions to call methodes */	120	void handleDBusSignal(const TQT_DBusMessage&);
136	//! to call a methode on a dbus system bus method without reply
137	bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
138	int first_arg_type, ... );
139	//! to call a methode on a dbus system bus method with reply
140	bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
141	void *retvalue, int retval_type, int first_arg_type, ... );
142		121
143	/* PolicyKit call helper */	122	signals:
144	//! check if the user has a requested privilege
145	int isUserPrivileged( TQString privilege, TQString udi, TQString ressource = "", TQString user = TQString());
146		123
147	//! wrapper to emit a signal with a event from HAL	124	void activeSessionChanged(bool);
148	void emitMsgReceived( msg_type type, TQString message, TQString string );
149		125
150	signals:
151	//! signal with message to forward from D-Bus to HAL
152	void msgReceived_withStringString( msg_type, TQString, TQString );
153	//! signal if we resumed!
154	void backFromSuspend( int result );
155	};	126	};
156		127
157	//! filter function to filter out needed information from D-Bus messages
158	DBusHandlerResult filterFunction (DBusConnection connection, DBusMessage message, void *data);
159
160	#endif	128	#endif

Lines 76-87 enum device_type { Link Here

(-)a/src/hardware.h (-41 / +3 lines)
76	UNKNOWN_DEVICE	76	UNKNOWN_DEVICE
77	};	77	};
78		78
79	enum ERROR_MSG {
80	DBUS_NO_RIGHTS,
81	DBUS_NOT_RUNNING,
82	DBUS_RUNNING
83	};
84
85	//! hold information if suspend/standby/pm actions are supported and allowed	79	//! hold information if suspend/standby/pm actions are supported and allowed
86	/*!	80	/*!
87	* This dictionary contains information about the available pm capabilities and	81	* This dictionary contains information about the available pm capabilities and
Lines 138-144 private: Link Here
138	TDEHardwareDevices *m_hwdevices;	132	TDEHardwareDevices *m_hwdevices;
139		133
140	//! pointer to the dbusInterface connection class	134	//! pointer to the dbusInterface connection class
141	dbusInterface *dbus_HAL;	135	dbusInterface *dbus_iface;
142		136
143	//! hold udis of special hardware execpt batteries represented by a TQString pairs (name,udi)	137	//! hold udis of special hardware execpt batteries represented by a TQString pairs (name,udi)
144	/*!	138	/*!
Lines 225-238 private: Link Here
225	* \li false: else	219	* \li false: else
226	*/	220	*/
227	bool cpuFreq;	221	bool cpuFreq;
228	//! if the machine support change *SchedPowerSavings methodes via TDE hardware library
229	/*!
230	* This boolean represent information if the machine support change the
231	* SchedPowerSavings methodes via TDE hardware library.
232	* \li true: if supported
233	* \li false: else
234	*/
235	bool schedPowerSavings;
236	//! if the machine support change brightness	222	//! if the machine support change brightness
237	/*!	223	/*!
238	* This boolean represent information if the machine support brightness changes.	224	* This boolean represent information if the machine support brightness changes.
Lines 315-338 private: Link Here
315	bool intialiseHWInfo();	301	bool intialiseHWInfo();
316	//! reinit all hardware information	302	//! reinit all hardware information
317	bool reinitHardwareInfos();	303	bool reinitHardwareInfos();
318	//! to check the current ConsoleKit session
319	bool checkConsoleKitSession();
320	//! to check if we should handle a device	304	//! to check if we should handle a device
321	bool checkIfHandleDevice ( TQString _udi, int *type );	305	bool checkIfHandleDevice ( TQString _udi, int *type );
322	//! to set the CPUFreq governor	306	//! to set the CPUFreq governor
323	bool setCPUFreqGovernor( const char *governor );	307	bool setCPUFreqGovernor( const char *governor );
324	//! to get the state of SchedPowerSave setting of kernel/TDE hardware library
325	bool getSchedPowerSavings();
326	//! to set the state of SchedPowerSave setting of kernel/TDE hardware library
327	bool setSchedPowerSavings( bool enable );
328		308
329	//! find and update a battery information	309	//! find and update a battery information
330	void updateBatteryValues (TDEGenericDevice* device);	310	void updateBatteryValues (TDEGenericDevice* device);
331		311
332	private slots:	312	private slots:
333		313
334	//! to fetch events from D-Bus and handle them	314	//! handle changes of the session state
335	void processMessage (msg_type type, TQString message, TQString value);	315	void handleSessionState (bool state);
336	//! to fetch events from the TDE hardware library and handle them	316	//! to fetch events from the TDE hardware library and handle them
337	void processHardwareChangedEvent (TDEGenericDevice*);	317	void processHardwareChangedEvent (TDEGenericDevice*);
338	//! to fetch keypresses from the TDE hardware library and handle them	318	//! to fetch keypresses from the TDE hardware library and handle them
Lines 392-401 signals: Link Here
392	void batteryWARNState(int type, int state);	372	void batteryWARNState(int type, int state);
393		373
394	// Error signals	374	// Error signals
395	//! signal if the HAL daemon terminate and restart
396	void halRunning( bool );
397	//! signal if the D-Bus daemon terminate and restart
398	void dbusRunning( int );
399		375
400	//! signal if the IsActive state of	376	//! signal if the IsActive state of
401	void desktopSessionIsActive (bool);	377	void desktopSessionIsActive (bool);
Lines 428-442 public: Link Here
428	*/	404	*/
429	bool update_info_primBattery_changed;	405	bool update_info_primBattery_changed;
430		406
431	//! boolean which tell us if the D-Bus daemon was terminated
432	/*!
433	* This boolean contains information if the D-Bus daemon terminated and
434	* we recieved "dbus.terminate"
435	* \li true: If D-Bus terminated
436	* \li false: If D-Bus not terminated
437	*/
438	bool dbus_terminated;
439
440	// --> functions	407	// --> functions
441	//! default constructor	408	//! default constructor
442	HardwareInfo();	409	HardwareInfo();
Lines 463-471 public: Link Here
463	//! if the user is allowed to change CPU Freq PolicyKit	430	//! if the user is allowed to change CPU Freq PolicyKit
464	int isCpuFreqAllowed ();	431	int isCpuFreqAllowed ();
465		432
466	//! if org.freedesktop.Policy.Power has a owner
467	bool isPolicyPowerIfaceOwned();
468
469	//! get state of the AC adapter	433	//! get state of the AC adapter
470	bool getAcAdapter() const;	434	bool getAcAdapter() const;
471	//! get the state of the lid button	435	//! get the state of the lid button
Lines 498-505 public: Link Here
498	bool setBrightnessUp(int percentageStep = -1);	462	bool setBrightnessUp(int percentageStep = -1);
499	//! set the CPU frequency policy/speed	463	//! set the CPU frequency policy/speed
500	bool setCPUFreq ( cpufreq_type cpufreq, int limit = 51 );	464	bool setCPUFreq ( cpufreq_type cpufreq, int limit = 51 );
501	//! call SetPowerSave method on TDE hardware library.
502	bool setPowerSave( bool on );
503		465
504	//! function to set warning states for the primary battery collection	466	//! function to set warning states for the primary battery collection
505	void setPrimaryBatteriesWarningLevel (int _warn = -1, int _low = -1, int _crit = -1 );	467	void setPrimaryBatteriesWarningLevel (int _warn = -1, int _low = -1, int _crit = -1 );

Lines 279-313 bool Battery::checkBatteryType () { Link Here

(-)a/src/hardware_battery.cpp (-29 lines)
279	// For now just report any batteries as primary...	279	// For now just report any batteries as primary...
280	type = BAT_PRIMARY;	280	type = BAT_PRIMARY;
281	return true;	281	return true;
282
283	#if 0
284	if (dbus_HAL->halGetPropertyString(udi,"battery.type", &tmp_qstring)) {
285	if (tmp_qstring.compare("primary") == 0) {
286	type = BAT_PRIMARY;
287	} else if (tmp_qstring.compare("mouse") == 0) {
288	type = BAT_MOUSE;
289	} else if (tmp_qstring.compare("keyboard") == 0) {
290	type = BAT_KEYBOARD;
291	} else if (tmp_qstring.compare("keyboard_mouse") == 0) {
292	type = BAT_KEY_MOUSE;
293	} else if (tmp_qstring.compare("camera") == 0) {
294	type = BAT_CAMERA;
295	} else if (tmp_qstring.compare("ups") == 0) {
296	type = BAT_UPS;
297	} else {
298	//anything else will currently be "UNKNOWN"
299	type = BAT_UNKNOWN;
300	}
301	kdDebugFuncOut(trace);
302	return true;
303	} else {
304	//query was not successfull
305	kdWarning() << "Query of battery.type of " << udi << " was not successfull." << endl;
306	type = BAT_UNKNOWN;
307	kdDebugFuncOut(trace);
308	return false;
309	}
310	#endif
311	}	282	}
312		283
313	//! to check battery.technology	284	//! to check battery.technology

Lines 61-67 Settings::~Settings() Link Here

(-)a/src/settings.cpp (-3 lines)
61	bool Settings::load_scheme_settings(TQString schemeName){	61	bool Settings::load_scheme_settings(TQString schemeName){
62		62
63	tdeconfig->reparseConfiguration();	63	tdeconfig->reparseConfiguration();
64	bool setToDefault = false;
65		64
66	if( schemeName == "Performance" \|\| schemeName == i18n("Performance"))	65	if( schemeName == "Performance" \|\| schemeName == i18n("Performance"))
67	schemeName = "Performance";	66	schemeName = "Performance";
Lines 78-84 bool Settings::load_scheme_settings(TQString schemeName){ Link Here
78	// fallback to 'default-scheme'	77	// fallback to 'default-scheme'
79	tdeconfig->setGroup("default-scheme");	78	tdeconfig->setGroup("default-scheme");
80	schemeName = "default-scheme";	79	schemeName = "default-scheme";
81	setToDefault = true;
82	}	80	}
83	currentScheme = schemeName;	81	currentScheme = schemeName;
84		82
Lines 250-256 bool Settings::load_general_settings(){ Link Here
250	psMsgAsPassivePopup = tdeconfig->readBoolEntry("psMsgAsPassivePopup",false);	248	psMsgAsPassivePopup = tdeconfig->readBoolEntry("psMsgAsPassivePopup",false);
251	forceDpmsOffOnLidClose = tdeconfig->readBoolEntry("forceDpmsOffOnLidClose",false);	249	forceDpmsOffOnLidClose = tdeconfig->readBoolEntry("forceDpmsOffOnLidClose",false);
252	unmountExternalOnSuspend = tdeconfig->readBoolEntry("unmountExternalOnSuspend",true);	250	unmountExternalOnSuspend = tdeconfig->readBoolEntry("unmountExternalOnSuspend",true);
253	callSetPowerSaveOnAC = tdeconfig->readBoolEntry("callSetPowerSaveOnAC",true);
254		251
255	lockmethod = tdeconfig->readEntry("lockMethod", "NULL");	252	lockmethod = tdeconfig->readEntry("lockMethod", "NULL");
256	if(lockmethod == "NULL") lockmethod = "automatic";	253	if(lockmethod == "NULL") lockmethod = "automatic";

Lines 1790-1803 void tdepowersave::setSchemeSettings(){ Link Here

(-)a/src/tdepowersave.cpp (-14 / +8 lines)
1790	}	1790	}
1791	}	1791	}
1792		1792
1793	// call setPowerSave() depending on AC state
1794	if (settings->callSetPowerSaveOnAC) {
1795	if (hwinfo->getAcAdapter())
1796	hwinfo->setPowerSave(false);
1797	else
1798	hwinfo->setPowerSave(true);
1799	}
1800
1801	// --> set autosuspend settings	1793	// --> set autosuspend settings
1802	if(settings->autoSuspend) {	1794	if(settings->autoSuspend) {
1803	setAutoSuspend(false);	1795	setAutoSuspend(false);
Lines 2176-2185 void tdepowersave::handleActionCall ( action action, int value , bool checkAC, b Link Here
2176	break;	2168	break;
2177	}	2169	}
2178	} else if (batWarnCall) {	2170	} else if (batWarnCall) {
2179	if (!hwinfo->isPolicyPowerIfaceOwned()) {	2171	// FIXME
		2172	// Is there a way to check if is active power manager on currently active session?
		2173	if (true) {
2180	switch (action) {	2174	switch (action) {
2181	case GO_SHUTDOWN:	2175	case GO_SHUTDOWN:
2182	// to be shure if we really need the shutdown	2176	// to be sure if we really need the shutdown
2183	if ((checkAC && !hwinfo->getAcAdapter()) \|\| !checkAC ) {	2177	if ((checkAC && !hwinfo->getAcAdapter()) \|\| !checkAC ) {
2184	DCOPRef shutdown = DCOPRef( "ksmserver", "ksmserver" );	2178	DCOPRef shutdown = DCOPRef( "ksmserver", "ksmserver" );
2185	shutdown.send("logout", 0, 2, 2);	2179	shutdown.send("logout", 0, 2, 2);
Lines 2509-2515 TQString tdepowersave::currentScheme (){ Link Here
2509	if(hwinfo->isOnline()) {	2503	if(hwinfo->isOnline()) {
2510	return settings->currentScheme;	2504	return settings->currentScheme;
2511	} else {	2505	} else {
2512	return "ERROR: D-Bus and/or HAL not running";	2506	return "ERROR: D-Bus not running";
2513	}	2507	}
2514		2508
2515	kdDebugFuncOut(trace);	2509	kdDebugFuncOut(trace);
Lines 2540-2546 TQString tdepowersave::currentCPUFreqPolicy() { Link Here
2540	}	2534	}
2541	return _cpuFreq;	2535	return _cpuFreq;
2542	} else {	2536	} else {
2543	return "ERROR: HAL or/and DBus not running";	2537	return "ERROR: DBus not running";
2544	}	2538	}
2545		2539
2546	kdDebugFuncOut(trace);	2540	kdDebugFuncOut(trace);
Lines 2630-2636 TQStringList tdepowersave::allowed_sleepingStates(){ Link Here
2630	}	2624	}
2631	}	2625	}
2632	else {	2626	else {
2633	sleepList.append("ERROR: D-Bus and/or HAL not running");	2627	sleepList.append("ERROR: D-Bus not running");
2634	}	2628	}
2635		2629
2636	kdDebugFuncOut(trace);	2630	kdDebugFuncOut(trace);
Lines 2651-2657 TQStringList tdepowersave::listSchemes(){ Link Here
2651	}	2645	}
2652	}	2646	}
2653	else {	2647	else {
2654	_schemeList.append("ERROR: D-Bus and/or HAL not running");	2648	_schemeList.append("ERROR: D-Bus not running");
2655	}	2649	}
2656		2650
2657	kdDebugFuncOut(trace);	2651	kdDebugFuncOut(trace);

Lines 37-43 Link Here

(-)a/src/hardware.cpp (-252 / +17 lines)
37	// include own header	37	// include own header
38	#include "hardware.h"	38	#include "hardware.h"
39	#include "tdepowersave_debug.h"	39	#include "tdepowersave_debug.h"
40	#include "privileges.h"
41		40
42	// #define USE_EVENT_DEVICES_DIRECTLY 1	41	// #define USE_EVENT_DEVICES_DIRECTLY 1
43		42
Lines 51-57 HardwareInfo::HardwareInfo() { Link Here
51	laptop = false;	50	laptop = false;
52	brightness = false;	51	brightness = false;
53	brightness_in_hardware = false;	52	brightness_in_hardware = false;
54	schedPowerSavings = false;
55	sessionIsActive = true; // assume as first we are active	53	sessionIsActive = true; // assume as first we are active
56		54
57	// initialize connection to the TDE hardware library	55	// initialize connection to the TDE hardware library
Lines 79-98 HardwareInfo::HardwareInfo() { Link Here
79	primaryBatteries = new BatteryCollection(BAT_PRIMARY);	77	primaryBatteries = new BatteryCollection(BAT_PRIMARY);
80	setPrimaryBatteriesWarningLevel(); // force default settings	78	setPrimaryBatteriesWarningLevel(); // force default settings
81		79
82	// connect to D-Bus and HAL	80	// connect to D-Bus
83	dbus_HAL = new dbusInterface();	81	dbus_iface = new dbusInterface();
84	if (dbus_HAL->isConnectedToDBUS()) {	82	sessionIsActive = dbus_iface->checkActiveSession();
85	dbus_terminated = false;	83	connect(dbus_iface, TQT_SIGNAL(activeSessionChanged(bool)), this, TQT_SLOT(handleSessionState(bool)));
86	} else {
87	kdError() << "Could not connect to D-Bus & HAL" << endl;
88	}
89		84
90	checkConsoleKitSession();
91	checkPowermanagement();	85	checkPowermanagement();
92	checkIsLaptop();	86	checkIsLaptop();
93	checkBrightness();	87	checkBrightness();
94	checkCPUFreq();	88	checkCPUFreq();
95	// getSchedPowerSavings();
96	checkSuspend();	89	checkSuspend();
97	intialiseHWInfo();	90	intialiseHWInfo();
98		91
Lines 141-155 bool HardwareInfo::reinitHardwareInfos () { Link Here
141	checkCPUFreq();	134	checkCPUFreq();
142	checkSuspend();	135	checkSuspend();
143	intialiseHWInfo();	136	intialiseHWInfo();
144	// getSchedPowerSavings();
145	updatePrimaryBatteries();	137	updatePrimaryBatteries();
146		138
147	kdDebugFuncOut(trace);	139	kdDebugFuncOut(trace);
148	return true;	140	return true;
149	}	141	}
150		142
		143
151	/*!	144	/*!
152	* This funtion is used to parse changed hardware nofifications from the TDE hardware library	145	* \b TQT_SLOT called if the state of the current session change
		146	* \param state boolean represent the state of the session
		147	*/
		148	void HardwareInfo::handleSessionState( bool state ) {
		149	if( state != sessionIsActive ) {
		150	sessionIsActive = state;
		151	TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
		152	}
		153	}
		154
		155	/*!
		156	* This function is used to parse changed hardware nofifications from the TDE hardware library
153	* \param device a \ref TDEGenericDevice* which should be processed	157	* \param device a \ref TDEGenericDevice* which should be processed
154	*/	158	*/
155	void HardwareInfo::processHardwareChangedEvent (TDEGenericDevice* device) {	159	void HardwareInfo::processHardwareChangedEvent (TDEGenericDevice* device) {
Lines 216-314 void HardwareInfo::processKeyPressEvent(unsigned int keycode, TDEEventDevice* ed Link Here
216	}	220	}
217		221
218	/*!	222	/*!
219	* This funtion is used to parse a message from D-Bus for the different
220	* messagetypes and events.
221	* \param type a \ref msg_type which should be parse/processed
222	* \param message the message
223	* \param value an optional message value as e.g. message string
224	*/
225	void HardwareInfo::processMessage (msg_type type, TQString message, TQString value) {
226	kdDebugFuncIn(trace);
227
228	switch(type) {
229	case ACPI_EVENT:
230	// we don't handle acpi events here atm
231	break;
232	case HAL_DEVICE:
233	// --> we can maybe ignore these events except for batteries, not shure atm
234	int _type;
235
236	if (message.startsWith("DeviceAdded")) {
237	if (checkIfHandleDevice(value, &_type)) {
238	switch (_type) {
239	case BATTERY:
240	case AC_ADAPTER:
241	case BUTTON_SLEEP:
242	case BUTTON_POWER:
243	case LID:
244	// TODO: handle code if needed actually not
245	break;
246	case LAPTOP_PANEL:
247	checkBrightness();
248	break;
249	default:
250	kdDebug() << "New device added Device udi: "
251	<< value << "type: " << _type << endl;
252	break;
253	}
254	}
255	} else if (message.startsWith("DeviceRemoved")) {
256	if (allUDIs.contains(value)) {
257	if (checkIfHandleDevice(value, &_type)) {
258	switch (_type) {
259	case BATTERY:
260	case AC_ADAPTER:
261	case BUTTON_SLEEP:
262	case BUTTON_POWER:
263	case LID:
264	// TODO: handle code if needed
265	break;
266	case LAPTOP_PANEL:
267	checkBrightness();
268	break;
269	default:
270	kdDebug() << "Couldn't handle unknown device" << endl;
271	break;
272	}
273	}
274	} else {
275	kdDebug() << "Not monitored device removed: " << value << endl;
276	}
277	} else {
278	kdDebug() << "Unknown HAL_DEVICE message: " << message << endl;
279	}
280	break;
281	case CONSOLEKIT_SESSION_ACTIVE:
282	if (!message.isEmpty() && !value.isEmpty()) {
283	if (message == consoleKitSession) {
284	if (value == "1") {
285	sessionIsActive = true;
286	} else {
287	sessionIsActive = false;
288	}
289	TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
290	} else {
291	if (trace)
292	kdDebug() << "CONSOLEKIT_SESSION_ACTIVE: not our session" << endl;
293	}
294	}
295	break;
296	case POLICY_POWER_OWNER_CHANGED:
297	if (message.startsWith("NOW_OWNER")) {
298	// TODO: add code
299	} else if (message.startsWith("OTHER_OWNER")){
300	// TODO: add code
301	}
302	break;
303	default:
304	kdDebug() << "Recieved unknown package type: " << type << endl;
305	break;
306	}
307
308	kdDebugFuncOut(trace);
309	}
310
311	/*!
312	* This TQT_SLOT is used to fetch the resume signal and multiplex. If needed some	223	* This TQT_SLOT is used to fetch the resume signal and multiplex. If needed some
313	* actions after resume, do this here.	224	* actions after resume, do this here.
314	* \param result integer with the result of the resume/suspend	225	* \param result integer with the result of the resume/suspend
Lines 331-391 void HardwareInfo::handleResumeSignal (int result) { Link Here
331	}	242	}
332		243
333	/*!	244	/*!
334	* This function checks the session for the running TDEPowersave instance
335	* \return Boolean with result of operation
336	* \retval true if the query/check could get finished
337	* \retval false on every error
338	*/
339	bool HardwareInfo::checkConsoleKitSession () {
340	kdDebugFuncIn(trace);
341
342	bool retval = false;
343
344	if (dbus_HAL->isConnectedToDBUS()) {
345	char *reply;
346	char *cookie = getenv("XDG_SESSION_COOKIE");
347
348	if (cookie == NULL) {
349	kdDebug() << "Could not get XDG_SESSION_COOKIE from environment" << endl;
350	sessionIsActive = true;
351	} else {
352	if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, CK_MANAGER_OBJECT,
353	CK_MANAGER_IFACE, "GetSessionForCookie",
354	&reply, DBUS_TYPE_OBJECT_PATH,
355	DBUS_TYPE_STRING, &cookie,
356	DBUS_TYPE_INVALID)) {
357	if (trace)
358	kdDebug() << "GetSessionForCookie returned: " << reply << endl;
359
360	if (reply != NULL) {
361	dbus_bool_t i_reply;
362	consoleKitSession = reply;
363
364	if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, consoleKitSession,
365	CK_SESSION_IFACE, "IsActive",
366	&i_reply, DBUS_TYPE_BOOLEAN,
367	DBUS_TYPE_INVALID)) {
368	sessionIsActive = ((i_reply != 0) ? true: false);
369	if (trace)
370	kdDebug() << "IsActive returned: " << sessionIsActive << endl;
371
372	retval = true;
373	} else {
374	kdError() << "Could get session cookie and session name, but not "
375	<< "but not the status of the session. Assume for now "
376	<< "the Session is inactive!" << endl;
377	sessionIsActive = false;
378	}
379	}
380	}
381	}
382	}
383
384	kdDebugFuncOut(trace);
385	return retval;
386	}
387
388	/*!
389	* This function check for a given UDI, if we should handle a device	245	* This function check for a given UDI, if we should handle a device
390	* \param _udi TQString with the UDI of the device	246	* \param _udi TQString with the UDI of the device
391	* \param *type pointer to a integer to return the type of the device, see \ref device_type	247	* \param *type pointer to a integer to return the type of the device, see \ref device_type
Lines 1090-1096 bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) { Link Here
1090	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);	946	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);
1091		947
1092	if (hwlist.count() > 0) {	948	if (hwlist.count() > 0) {
1093	dbus_bool_t consider = (dbus_bool_t) getAcAdapter();
1094	TQStringList dynamic;	949	TQStringList dynamic;
1095		950
1096	if (checkCurrentCPUFreqPolicy() == cpufreq) {	951	if (checkCurrentCPUFreqPolicy() == cpufreq) {
Lines 1122-1141 bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) { Link Here
1122	}	977	}
1123	}	978	}
1124		979
1125	#if 0
1126	// FIXME
1127	// What does "SetCPUFreqConsiderNice" actually do??!?!
1128
1129	// correct set ondemand
1130	if (!dbus_HAL->dbusSystemMethodCall( HAL_SERVICE, HAL_COMPUTER_UDI,
1131	HAL_CPUFREQ_IFACE,
1132	"SetCPUFreqConsiderNice",
1133	DBUS_TYPE_BOOLEAN, &consider,
1134	DBUS_TYPE_INVALID)) {
1135	kdError() << "Couldn't set SetCPUFreqConsiderNice for DYNAMIC" << endl;
1136	}
1137
1138	#endif
1139	// Set performance limits on all CPUs	980	// Set performance limits on all CPUs
1140	TDEGenericDevice *hwdevice;	981	TDEGenericDevice *hwdevice;
1141	TDECPUDevice *cpudevice;	982	TDECPUDevice *cpudevice;
Lines 1185-1191 bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) { Link Here
1185	bool HardwareInfo::setCPUFreqGovernor( const char *governor ) {	1026	bool HardwareInfo::setCPUFreqGovernor( const char *governor ) {
1186	kdDebugFuncIn(trace);	1027	kdDebugFuncIn(trace);
1187		1028
1188	int reply;
1189	bool ret = true;	1029	bool ret = true;
1190		1030
1191	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);	1031	TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);
Lines 1205-1265 bool HardwareInfo::setCPUFreqGovernor( const char *governor ) { Link Here
1205	}	1045	}
1206		1046
1207		1047
1208	/*!
1209	* Function to set the powersave mode (incl. e.g. disk settings) via TDE hardware library.
1210	* \param on boolean which tell if enable/disable powersave mode
1211	* \return boolean with result of the operation
1212	* \retval true if successful
1213	* \retval false else, if a error occurs
1214	*/
1215	bool HardwareInfo::setPowerSave( bool on ) {
1216	kdDebugFuncIn(trace);
1217
1218	bool retval = false;
1219
1220	// FIXME
1221	// Set up power saving to the best of our ability using "raw" functions
1222	printf("[FIXME] HardwareInfo::setPowerSave unimplemented!\n"); fflush(stdout);
1223
1224	kdDebugFuncOut(trace);
1225	return retval;
1226	}
1227
1228	/*!
1229	* Function to call GetSchedPowerSavings() via TDE hardware library.
1230	* \return boolean with result of the operation
1231	* \retval true if successful
1232	* \retval false else, if a error occurs
1233	*/
1234	bool HardwareInfo::getSchedPowerSavings() {
1235	kdDebugFuncIn(trace);
1236
1237	bool returnval = false;
1238
1239	// What does the HAL method GetSchedPowerSavings actually do?!?!?
1240
1241	kdDebugFuncOut(trace);
1242	return returnval;
1243	}
1244
1245	/*!
1246	* Function to call SetSchedPowerSavings() via TDE hardware library.
1247	* Note: this would only work on multiprocessor/-core machines.
1248	* \return boolean with result of the operation
1249	* \retval true if successful
1250	* \retval false else, if a error occurs
1251	*/
1252	bool HardwareInfo::setSchedPowerSavings( bool enable ) {
1253	kdDebugFuncIn(trace);
1254
1255	bool retval = false;
1256
1257	// What does the HAL method SetCPUFreqPerformance actually do?!?!?
1258
1259	kdDebugFuncOut(trace);
1260	return retval;
1261	}
1262
1263		1048
1264	// --> TDE hardware library method call (trigger actions) section -- END <---	1049	// --> TDE hardware library method call (trigger actions) section -- END <---
1265		1050
Lines 1304-1319 void HardwareInfo::emitS2diskButtonPressed() { Link Here
1304	* Function to emit the signal about changes in the session state	1089	* Function to emit the signal about changes in the session state
1305	*/	1090	*/
1306	void HardwareInfo::emitSessionActiveState() {	1091	void HardwareInfo::emitSessionActiveState() {
1307	if (sessionIsActive) {
1308	if (!dbus_HAL->acquiredPolicyPowerInterface()) {
1309	dbus_HAL->acquirePolicyPowerIface();
1310	}
1311	} else {
1312	if (dbus_HAL->acquiredPolicyPowerInterface()) {
1313	dbus_HAL->releasePolicyPowerIface();
1314	}
1315	}
1316
1317	emit desktopSessionIsActive(sessionIsActive);	1092	emit desktopSessionIsActive(sessionIsActive);
1318	}	1093	}
1319		1094
Lines 1635-1650 int HardwareInfo::isCpuFreqAllowed () { Link Here
1635	return cpuFreqAllowed;	1410	return cpuFreqAllowed;
1636	}	1411	}
1637		1412
1638	/*! check if the org.freedesktop.Policy.Power interface has an owner
1639	* \return boolean with info if org.freedesktop.Policy.Power interface has an owner or not
1640	* \retval true if there is a owner
1641	* \retval false else
1642	*/
1643	bool HardwareInfo::isPolicyPowerIfaceOwned () {
1644	return dbus_HAL->isPolicyPowerIfaceOwned();
1645	}
1646
1647
1648	// --> get private members section -- END <---	1413	// --> get private members section -- END <---
1649		1414
1650	#include "hardware.moc"	1415	#include "hardware.moc"

Lines 1-46 Link Here

(-)a/src/privileges.h (-46 lines)
1	/***************************************************************************
2	* Copyright (C) 2007 by Danny Kukawka *
3	* <dkukawka@suse.de, danny.kukawka@web.de> *
4	* *
5	* This program is free software; you can redistribute it and/or modify *
6	* it under the terms of version 2 of the GNU General Public License *
7	* as published by the Free Software Foundation. *
8	* *
9	* This program is distributed in the hope that it will be useful, *
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12	* GNU General Public License for more details. *
13	* *
14	* You should have received a copy of the GNU General Public License *
15	* along with this program; if not, write to the *
16	* Free Software Foundation, Inc., *
17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
18	***************************************************************************/
19
20	/*!
21	* \file privileges.h
22	* \brief Headerfile containing defines for privileges
23	* \author Danny Kukawka, <dkukawka@suse.de, danny.kukawka@web.de>
24	* \date 2007
25	*/
26
27	#ifndef _PRIVILEGES_H_
28	#define _PRIVILEGES_H_
29
30	#ifdef HAVE_HAL_0_5_10
31	#define PRIV_SUSPEND "org.freedesktop.hal.power-management.suspend"
32	#define PRIV_HIBERNATE "org.freedesktop.hal.power-management.hibernate"
33	#define PRIV_STANDBY "org.freedesktop.hal.power-management.standby"
34	#define PRIV_CPUFREQ "org.freedesktop.hal.power-management.cpufreq"
35	#define PRIV_LAPTOP_PANEL "org.freedesktop.hal.power-management.lcd-panel"
36	#define PRIV_SETPOWERSAVE "org.freedesktop.hal.power-management.set-powersave"
37	#else
38	#define PRIV_SUSPEND "hal-power-suspend"
39	#define PRIV_HIBERNATE "hal-power-hibernate"
40	#define PRIV_STANDBY "hal-power-standby"
41	#define PRIV_CPUFREQ "hal-power-cpufreq"
42	#define PRIV_LAPTOP_PANEL "hal-power-lcd-panel"
43	#define PRIV_SETPOWERSAVE "hal-power-set-powersave"
44	#endif
45
46	#endif

Lines 200-213 public: Link Here

(-)a/src/settings.h (-8 lines)
200	* \li false: if not	200	* \li false: if not
201	*/	201	*/
202	bool forceDpmsOffOnLidClose;	202	bool forceDpmsOffOnLidClose;
203	//! if tdepowersave should call SetPowerSave() on HAL
204	/*!
205	* This boolean tells if tdepowersave should call SetPowerSave on HAL depending
206	* on the AC state.
207	* \li true: if should call
208	* \li false: if not
209	*/
210	bool callSetPowerSaveOnAC;
211		203
212	//! time after resume to fake keyevent	204	//! time after resume to fake keyevent
213	/*!	205	/*!