property.cpp

Go to the documentation of this file.

/*
 *
 *  D-Bus++ - C++ bindings for D-Bus
 *
 *  Copyright (C) 2005-2007  Paolo Durante <shackan@gmail.com>
 *
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <dbus-c++/debug.h>
#include <dbus-c++/property.h>
 
#include <dbus-c++/introspection.h>
 
using namespace DBus;
 
static const char *properties_name = "org.freedesktop.DBus.Properties";
 
PropertiesAdaptor::PropertiesAdaptor()
  : InterfaceAdaptor(properties_name)
{
  register_method(PropertiesAdaptor, Get, Get);
  register_method(PropertiesAdaptor, Set, Set);
}
 
Message PropertiesAdaptor::Get(const CallMessage &call)
{
  MessageIter ri = call.reader();
 
  std::string iface_name;
  std::string property_name;
 
  ri >> iface_name >> property_name;
 
  debug_log("requesting property %s on interface %s", property_name.c_str(), iface_name.c_str());
 
  InterfaceAdaptor *interface = (InterfaceAdaptor *) find_interface(iface_name);
 
  if (!interface)
    throw ErrorFailed("requested interface not found");
 
  Variant *value = interface->get_property(property_name);
 
  if (!value)
    throw ErrorFailed("requested property not found");
 
  on_get_property(*interface, property_name, *value);
 
  ReturnMessage reply(call);
 
  MessageIter wi = reply.writer();
 
  wi << *value;
  return reply;
}
 
Message PropertiesAdaptor::Set(const CallMessage &call)
{
  MessageIter ri = call.reader();
 
  std::string iface_name;
  std::string property_name;
  Variant value;
 
  ri >> iface_name >> property_name >> value;
 
  InterfaceAdaptor *interface = (InterfaceAdaptor *) find_interface(iface_name);
 
  if (!interface)
    throw ErrorFailed("requested interface not found");
 
  on_set_property(*interface, property_name, value);
 
  interface->set_property(property_name, value);
 
  ReturnMessage reply(call);
 
  return reply;
}
 
IntrospectedInterface *PropertiesAdaptor::introspect() const
{
  static IntrospectedArgument Get_args[] =
  {
    { "interface_name", "s", true },
    { "property_name", "s", true },
    { "value", "v", false },
    { 0, 0, 0 }
  };
  static IntrospectedArgument Set_args[] =
  {
    { "interface_name", "s", true },
    { "property_name", "s", true },
    { "value", "v", true },
    { 0, 0, 0 }
  };
  static IntrospectedMethod Properties_methods[] =
  {
    { "Get", Get_args },
    { "Set", Set_args },
    { 0, 0 }
  };
  static IntrospectedMethod Properties_signals[] =
  {
    { 0, 0 }
  };
  static IntrospectedProperty Properties_properties[] =
  {
    { 0, 0, 0, 0 }
  };
  static IntrospectedInterface Properties_interface =
  {
    properties_name,
    Properties_methods,
    Properties_signals,
    Properties_properties
  };
  return &Properties_interface;
}
 
PropertiesProxy::PropertiesProxy()
  : InterfaceProxy(properties_name)
{
}
 
Variant PropertiesProxy::Get(const std::string &iface, const std::string &property)
{
//todo
  Variant v;
  return v;
}
 
void PropertiesProxy::Set(const std::string &iface, const std::string &property, const Variant &value)
{
//todo
}