int main(int argc, char **argv) { GOptionContext *context; GMainLoop *loop; GError *err = NULL; DBusGProxy *dev; char *username; g_type_init(); dbus_g_object_register_marshaller (fprintd_marshal_VOID__STRING_BOOLEAN, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INVALID); context = g_option_context_new ("Verify a fingerprint"); g_option_context_add_main_entries (context, entries, NULL); if (g_option_context_parse (context, &argc, &argv, &err) == FALSE) { g_print ("couldn't parse command-line options: %s\n", err->message); g_error_free (err); return 1; } if (usernames == NULL) { username = ""; } else { username = usernames[0]; } if (g_fatal_warnings) { GLogLevelFlags fatal_mask; fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK); fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL; g_log_set_always_fatal (fatal_mask); } loop = g_main_loop_new(NULL, FALSE); create_manager(); dev = open_device(username); find_finger(dev, username); do_verify(dev); release_device(dev); return 0; }
DBusGProxy *iskufx_dbus_proxy_new(void) { DBusGProxy *proxy; proxy = dbus_roccat_proxy_new_for_name( ROCCAT_DBUS_SERVER_NAME, ISKUFX_DBUS_SERVER_PATH, ISKUFX_DBUS_SERVER_INTERFACE); if (!proxy) return NULL; dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__UCHAR, G_TYPE_NONE, G_TYPE_UCHAR, G_TYPE_INVALID); dbus_g_object_register_marshaller(g_cclosure_roccat_marshal_VOID__UCHAR_UCHAR, G_TYPE_NONE, G_TYPE_UCHAR, G_TYPE_UCHAR, G_TYPE_INVALID); dbus_g_object_register_marshaller(g_cclosure_roccat_marshal_VOID__UCHAR_UCHAR_STRING, G_TYPE_NONE, G_TYPE_UCHAR, G_TYPE_UCHAR, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy, "ProfileChanged", G_TYPE_UCHAR, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy, "BrightnessChanged", G_TYPE_UCHAR, G_TYPE_UCHAR, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy, "MacroChanged", G_TYPE_UCHAR, G_TYPE_UCHAR, G_TYPE_STRING, G_TYPE_INVALID); return proxy; }
DBusGProxy * _notify_get_g_proxy (void) { GError *error; DBusGConnection *bus; if (_proxy != NULL) return _proxy; /* lazily initialize D-Bus connection */ error = NULL; bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (error != NULL) { g_error_free (error); return NULL; } _proxy = dbus_g_proxy_new_for_name (bus, NOTIFY_DBUS_NAME, NOTIFY_DBUS_CORE_OBJECT, NOTIFY_DBUS_CORE_INTERFACE); dbus_g_connection_unref (bus); g_signal_connect (_proxy, "destroy", G_CALLBACK (on_proxy_destroy), NULL); dbus_g_object_register_marshaller (notify_marshal_VOID__UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_object_register_marshaller (notify_marshal_VOID__UINT_STRING, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (_proxy, "NotificationClosed", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal (_proxy, "ActionInvoked", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID); if (!_notify_update_spec_version ()) { return NULL; } return _proxy; }
void geoclue_types_init (void) { if (initted != FALSE) return; dbus_g_object_register_marshaller (geoclue_marshal_VOID__INT_INT_DOUBLE_DOUBLE_DOUBLE, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_INVALID); dbus_g_object_register_marshaller (geoclue_marshal_VOID__INT_INT_DOUBLE_DOUBLE_DOUBLE_BOXED, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_BOXED, G_TYPE_INVALID); dbus_g_object_register_marshaller (geoclue_marshal_VOID__INT_BOXED_BOXED, G_TYPE_NONE, G_TYPE_INT, G_TYPE_BOXED, G_TYPE_BOXED, G_TYPE_INVALID); dbus_g_object_register_marshaller (geoclue_marshal_VOID__STRING_STRING_STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_object_register_marshaller (geoclue_marshal_VOID__INT_INT_INT_POINTER_POINTER, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, DBUS_TYPE_G_INT_ARRAY, GEOCLUE_SATELLITE_INFO_ARRAY, G_TYPE_INVALID); dbus_g_error_domain_register (GEOCLUE_ERROR, GEOCLUE_ERROR_DBUS_INTERFACE, GEOCLUE_TYPE_ERROR); initted = TRUE; }
static void interface_add_done (NMSupplicantInterface *self, char *path) { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); nm_log_dbg (LOGD_SUPPLICANT, "(%s): interface added to supplicant", priv->dev); priv->object_path = path; priv->iface_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, WPAS_DBUS_IFACE_INTERFACE); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "PropertiesChanged", DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "PropertiesChanged", G_CALLBACK (wpas_iface_properties_changed), self, NULL); dbus_g_proxy_add_signal (priv->iface_proxy, "ScanDone", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "ScanDone", G_CALLBACK (wpas_iface_scan_done), self, NULL); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "BSSAdded", DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "BSSAdded", G_CALLBACK (wpas_iface_bss_added), self, NULL); priv->props_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, DBUS_INTERFACE_PROPERTIES); /* Get initial properties */ wpas_iface_get_props (self); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_READY); }
static void listen_tracker (GtkListStore *model) { #if 0 DBusGConnection *bus; DBusGProxy *wrap; bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL); dbus_g_object_register_marshaller (marshal_VOID__BOXED_BOXED, G_TYPE_NONE, G_TYPE_STRV, G_TYPE_STRV, G_TYPE_INVALID); wrap = dbus_g_proxy_new_for_name (bus, "org.freedesktop.Tracker1", "/org/freedesktop/Tracker1/Resources/Classes/mfo/FeedChannel", "org.freedesktop.Tracker1.Resources.Class"); dbus_g_proxy_add_signal (wrap, "SubjectsAdded", G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsAdded", G_CALLBACK (channel_added_cb), model, NULL); dbus_g_proxy_add_signal (wrap, "SubjectsChanged", G_TYPE_STRV, G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsChanged", G_CALLBACK (channel_changed_cb), model, NULL); dbus_g_proxy_add_signal (wrap, "SubjectsRemoved", G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsRemoved", G_CALLBACK (channel_removed_cb), model, NULL); #endif }
static void set_session_over_handler (DBusGConnection *bus, MateSettingsManager *manager) { DBusGProxy *session_proxy; g_assert (bus != NULL); mate_settings_profile_start (NULL); session_proxy = dbus_g_proxy_new_for_name (bus, MATE_SESSION_DBUS_NAME, MATE_SESSION_DBUS_OBJECT, MATE_SESSION_DBUS_INTERFACE); dbus_g_object_register_marshaller ( g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, G_TYPE_INVALID); dbus_g_proxy_add_signal (session_proxy, "SessionOver", G_TYPE_INVALID); dbus_g_proxy_connect_signal (session_proxy, "SessionOver", G_CALLBACK (on_session_over), manager, NULL); watch_for_term_signal (manager); mate_settings_profile_end (NULL); }
static void start_avahi_service_browser(DBusGConnection *bus_system){ GError *error = NULL; char *service_browser_path; if (!dbus_g_proxy_call(proxy_avahi_service, "ServiceBrowserNew", &error, G_TYPE_INT, -1, G_TYPE_INT, -1, G_TYPE_STRING, "_http._tcp", G_TYPE_STRING, "local", G_TYPE_UINT, 0, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, &service_browser_path, G_TYPE_INVALID)) lose_gerror("Failed to call ServiceBrowserNew", error); printf("new service browser (%s) has started.\n", service_browser_path); proxy_avahi_service_browser = dbus_g_proxy_new_for_name(bus_system, "org.freedesktop.Avahi", service_browser_path, "org.freedesktop.Avahi.ServiceBrowser"); dbus_g_object_register_marshaller( _avahi_marshal_VOID__INT_INT_STRING_STRING_STRING_UINT, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); // dbus_g_object_register_marshaller( // _avahi_marshal_VOID__INT_INT_STRING_STRING_STRING_INT_UINT, // G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, // G_TYPE_STRING, G_TYPE_INT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy_avahi_service_browser, "ItemNew", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy_avahi_service_browser, "ItemNew", G_CALLBACK(service_browser_ItemNew), NULL, NULL); dbus_g_proxy_add_signal(proxy_avahi_service_browser, "ItemRemove", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy_avahi_service_browser, "ItemRemove", G_CALLBACK(service_browser_ItemRemove), NULL, NULL); }
static void geoclue_gsmloc_ofono_class_init (GeoclueGsmlocOfonoClass *klass) { GObjectClass *o_class = (GObjectClass *)klass; GParamSpec *pspec; g_type_class_add_private (klass, sizeof (GeoclueGsmlocOfonoPrivate)); o_class->dispose = geoclue_gsmloc_ofono_dispose; o_class->get_property = geoclue_gsmloc_ofono_get_property; dbus_g_object_register_marshaller (ofono_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); signals[NETWORK_DATA_CHANGED] = g_signal_new ( "network-data-changed", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, ofono_marshal_VOID__STRING_STRING_STRING_STRING, G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); pspec = g_param_spec_boolean ("available", "Available", "Is oFono available", FALSE, G_PARAM_READABLE); g_object_class_install_property (o_class, PROP_AVAILABLE, pspec); }
static gboolean online_init (void) { DBusGConnection *conn; if (proxy) return TRUE; conn = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL); if (!conn) { g_warning ("Cannot get connection to system message bus"); return FALSE; } proxy = dbus_g_proxy_new_for_name (conn, "net.connman", "/", "net.connman.Manager"); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (proxy, "StateChanged", G_TYPE_STRING, NULL); dbus_g_proxy_connect_signal (proxy, "StateChanged", (GCallback)state_changed, NULL, NULL); current_state = FALSE; /* Get the current state */ dbus_g_proxy_begin_call (proxy, "GetState", got_state_cb, NULL, NULL, G_TYPE_INVALID); return TRUE; }
void gnome_remote_init () { DBusGConnection *bus; GError *error = NULL; dbus_g_thread_init(); bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if ((bus == NULL) || error) { g_warning ("Error connecting to DBus: %s", error->message); } else { media_player_keys_proxy = dbus_g_proxy_new_for_name (bus, "org.gnome.SettingsDaemon", "/org/gnome/SettingsDaemon/MediaKeys", "org.gnome.SettingsDaemon.MediaKeys"); if (media_player_keys_proxy == NULL) return; dbus_g_proxy_call (media_player_keys_proxy, "GrabMediaPlayerKeys", &error, G_TYPE_STRING, "Audacious", G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_INVALID); if (error != NULL) { g_error_free (error); error = NULL; g_object_unref(media_player_keys_proxy); media_player_keys_proxy = NULL; media_player_keys_proxy = dbus_g_proxy_new_for_name (bus, "org.gnome.SettingsDaemon", "/org/gnome/SettingsDaemon", "org.gnome.SettingsDaemon"); if (media_player_keys_proxy == NULL) return; dbus_g_proxy_call (media_player_keys_proxy, "GrabMediaPlayerKeys", &error, G_TYPE_STRING, "Audacious", G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_INVALID); if (error != NULL) { g_warning ("Could not grab media player keys: %s", error->message); g_error_free (error); g_object_unref(media_player_keys_proxy); media_player_keys_proxy = NULL; return; } } dbus_g_object_register_marshaller (hotkey_marshal_VOID__STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (media_player_keys_proxy, "MediaPlayerKeyPressed", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (media_player_keys_proxy, "MediaPlayerKeyPressed", G_CALLBACK (on_media_player_key_pressed), NULL, NULL); } }
static void _cd_connect_to_resuming_signal (GldiModuleInstance *myApplet) { if ((s_bUsedLogind = cairo_dock_dbus_detect_system_application ("org.freedesktop.login1"))) myData.pProxyResuming = cairo_dock_create_new_system_proxy ( "org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager"); else if (cairo_dock_dbus_detect_system_application ("org.freedesktop.UPower")) myData.pProxyResuming = cairo_dock_create_new_system_proxy ( "org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower"); if (myData.pProxyResuming == NULL) // no proxy found { cd_debug ("LoginD and UPower bus are not available, can't connect to 'resuming' signal"); return; } if (s_bUsedLogind) { dbus_g_object_register_marshaller ( g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_add_signal (myData.pProxyResuming, "PrepareForSleep", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (myData.pProxyResuming, "PrepareForSleep", G_CALLBACK (_on_prepare_for_sleep), myApplet, NULL); } else // UPower { dbus_g_object_register_marshaller ( g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, G_TYPE_INVALID); dbus_g_proxy_add_signal (myData.pProxyResuming, "Resuming", G_TYPE_INVALID); dbus_g_proxy_connect_signal (myData.pProxyResuming, "Resuming", G_CALLBACK (_on_resuming), myApplet, NULL); } }
/** * gpm_phone_service_appeared_cb: */ static void gpm_phone_service_appeared_cb (GDBusConnection *connection, const gchar *name, const gchar *name_owner, GpmPhone *phone) { GError *error = NULL; g_return_if_fail (GPM_IS_PHONE (phone)); if (phone->priv->connection == NULL) { egg_debug ("get connection"); g_clear_error (&error); phone->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (error != NULL) { egg_warning ("Could not connect to DBUS daemon: %s", error->message); g_error_free (error); phone->priv->connection = NULL; return; } } if (phone->priv->proxy == NULL) { egg_debug ("get proxy"); g_clear_error (&error); phone->priv->proxy = dbus_g_proxy_new_for_name_owner (phone->priv->connection, MATE_PHONE_MANAGER_DBUS_SERVICE, MATE_PHONE_MANAGER_DBUS_PATH, MATE_PHONE_MANAGER_DBUS_INTERFACE, &error); if (error != NULL) { egg_warning ("Cannot connect, maybe the daemon is not running: %s", error->message); g_error_free (error); phone->priv->proxy = NULL; return; } /* complicated type. ick */ dbus_g_object_register_marshaller(gpm_marshal_VOID__UINT_UINT_BOOLEAN, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID); /* get BatteryStateChanged */ dbus_g_proxy_add_signal (phone->priv->proxy, "BatteryStateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (phone->priv->proxy, "BatteryStateChanged", G_CALLBACK (gpm_phone_battery_state_changed), phone, NULL); /* get NumberBatteriesChanged */ dbus_g_proxy_add_signal (phone->priv->proxy, "NumberBatteriesChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (phone->priv->proxy, "NumberBatteriesChanged", G_CALLBACK (gpm_phone_num_batteries_changed), phone, NULL); } }
gboolean cd_NetworkMonitor_connect_to_bus (void) { cd_debug ("%s ()", __func__); //\_____________ On verifie la presence de NM sur le bus. if (! cairo_dock_dbus_detect_system_application("org.freedesktop.NetworkManager")) return FALSE; dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__GHashTable_GHashTable, G_TYPE_NONE, CD_DBUS_TYPE_HASH_TABLE_OF_HASH_TABLE, G_TYPE_INVALID); // pour la methode GetSettings (il faut le faire avant de recuperer tout proxy, sinon les signaux ne passent plus !) //\_____________ On recupere l'objet principal de NM. myData.dbus_proxy_NM = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.NetworkManager"); g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM), FALSE); myData.dbus_proxy_NM_prop = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.DBus.Properties"); g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM_prop), FALSE); //\_____________ On se connecte aux signaux de base : wifi active (WirelessEnabled && WirelessHardwareEnabled ), etat de NM (State). dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, G_TYPE_HASH_TABLE ,G_TYPE_INVALID); // enregistrement d'un marshaller specifique au signal (sinon impossible de le recuperer ni de le voir dbus_g_proxy_add_signal(myData.dbus_proxy_NM, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_NM, "PropertiesChanged", G_CALLBACK(onChangeNMProperties), NULL, NULL); //\_____________ On recupere l'objet des connections. myData.cServiceName = g_strdup ("org.freedesktop.NetworkManagerUserSettings"); myData.dbus_proxy_Settings = cairo_dock_create_new_system_proxy ( myData.cServiceName, "/org/freedesktop/NetworkManagerSettings", "org.freedesktop.NetworkManagerSettings"); dbus_g_proxy_add_signal(myData.dbus_proxy_Settings, "NewConnection", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_Settings, "NewConnection", G_CALLBACK(onNewConnection), NULL, NULL); return TRUE; }
int main (int argc, char **argv) { GtkTreeModel *model; GtkWidget *tree; GtkWidget *window; GtkWidget *scrolled; if (!g_thread_supported ()) { g_thread_init (NULL); } gtk_init (&argc, &argv); dbus_g_thread_init (); dbus_g_object_register_marshaller (connman_marshal_VOID__STRING_BOXED, /* return */ G_TYPE_NONE, /* args */ G_TYPE_STRING, G_TYPE_VALUE, /* eom */ G_TYPE_INVALID); model = carrick_network_model_new (); tree = create_tree (model); gtk_tree_view_set_model (GTK_TREE_VIEW (tree), GTK_TREE_MODEL (model)); gtk_widget_show (tree); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled), tree); gtk_widget_show (scrolled); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); gtk_container_add (GTK_CONTAINER (window), scrolled); gtk_widget_show (window); gtk_main (); return 0; }
void uprof_init_real (void) { static gboolean initialized = FALSE; if (initialized) return; g_type_init (); #ifndef USE_RDTSC int ret; struct timespec ts; ret = clock_getcpuclockid(0, &clockid); if (ret == ENOENT) { g_warning ("Using the CPU clock will be unreliable on this system if " "you don't assure processor affinity"); } else if (ret != 0) { const char *str = strerror (errno); g_warning ("Failed to get CPU clock ID: %s", str); } if (clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) { const char *str = strerror (errno); g_warning ("Failed to query CLOCK_PROCESS_CPUTIME_ID clock: %s", str); } #endif mainloop_context = uprof_context_new ("Mainloop context"); dbus_g_object_register_marshaller (_uprof_marshal_VOID__STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); _uprof_report_register_dbus_type_info (); _uprof_service_register_dbus_type_info (); service = _uprof_service_new (); initialized = TRUE; }
static Modem * modem_new (DBusGConnection *bus, const char *path, gpointer owner) { Modem *modem; modem = g_slice_new0 (Modem); modem->owner = owner; modem->path = g_strdup (path); modem->loc_proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, path, MM_DBUS_LOC_INTERFACE); modem->modem_proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, path, MM_DBUS_MODEM_INTERFACE); /* Listen for property changes */ modem->props_proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, path, "org.freedesktop.DBus.Properties"); dbus_g_object_register_marshaller (mm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (modem->props_proxy, "MmPropertiesChanged", G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (modem->props_proxy, "MmPropertiesChanged", G_CALLBACK (modem_properties_changed), modem, NULL); debugmsg ("%s: (%s) modem created", __func__, path); /* Check if the Location interface is actually supported before doing * anything with the modem, because if it's not, we don't care about * the modem at all. */ dbus_g_proxy_begin_call (modem->props_proxy, "GetAll", loc_props_cb, modem, NULL, G_TYPE_STRING, MM_DBUS_LOC_INTERFACE, G_TYPE_INVALID); return modem; }
DBusGProxy *kovaplus_dbus_proxy_new(void) { DBusGProxy *proxy; proxy = dbus_roccat_proxy_new_for_name(ROCCAT_DBUS_SERVER_NAME, KOVAPLUS_DBUS_SERVER_PATH, KOVAPLUS_DBUS_SERVER_INTERFACE); if (!proxy) return NULL; dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__UCHAR, G_TYPE_NONE, G_TYPE_UCHAR, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy, "ProfileChanged", G_TYPE_UCHAR, G_TYPE_INVALID); return proxy; }
static void gupnp_network_manager_class_init (GUPnPNetworkManagerClass *klass) { GObjectClass *object_class; object_class = G_OBJECT_CLASS (klass); object_class->constructed = gupnp_network_manager_constructed; object_class->dispose = gupnp_network_manager_dispose; dbus_g_object_register_marshaller (gupnp_marshal_VOID__UINT_UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); g_type_class_add_private (klass, sizeof (GUPnPNetworkManagerPrivate)); }
FcitxIMClient* FcitxIMClientOpen(FcitxIMClientConnectCallback connectcb, FcitxIMClientDestroyCallback destroycb, GObject* data) { FcitxIMClient* client = fcitx_malloc0(sizeof(FcitxIMClient)); GError *error = NULL; client->connectcb = connectcb; client->destroycb = destroycb; client->data = data; client->conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error); client->id = -1; /* You must have dbus to make it works */ if (client->conn == NULL) { g_warning("%s", error->message); free(client); return NULL; } client->dbusproxy = dbus_g_proxy_new_for_name(client->conn, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); if (!client->dbusproxy) { g_object_unref(client->conn); free(client); return NULL; } sprintf(client->servicename, "%s-%d", FCITX_DBUS_SERVICE, FcitxGetDisplayNumber()); dbus_g_object_register_marshaller(fcitx_marshall_VOID__STRING_STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal(client->dbusproxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal(client->dbusproxy, "NameOwnerChanged", G_CALLBACK(_changed_cb), client, NULL); client->triggerkey[0].sym = client->triggerkey[0].state = client->triggerkey[1].sym = client->triggerkey[1].state = 0; FcitxIMClientCreateIC(client); return client; }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { NMObject *object; NMDevicePrivate *priv; object = (NMObject *) G_OBJECT_CLASS (nm_device_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = NM_DEVICE_GET_PRIVATE (object); priv->proxy = dbus_g_proxy_new_for_name (nm_object_get_connection (object), NM_DBUS_SERVICE, nm_object_get_path (object), NM_DBUS_INTERFACE_DEVICE); register_for_property_changed (NM_DEVICE (object)); dbus_g_object_register_marshaller (_nm_marshal_VOID__UINT_UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->proxy, "StateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "StateChanged", G_CALLBACK (device_state_changed), NM_DEVICE (object), NULL); return G_OBJECT (object); }
static void constructed (GObject *object) { NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (object); G_OBJECT_CLASS (nm_vpn_connection_parent_class)->constructed (object); priv->proxy = _nm_object_new_proxy (NM_OBJECT (object), NULL, NM_DBUS_INTERFACE_VPN_CONNECTION); dbus_g_object_register_marshaller (g_cclosure_marshal_generic, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->proxy, "VpnStateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "VpnStateChanged", G_CALLBACK (vpn_state_changed_proxy), object, NULL); register_properties (NM_VPN_CONNECTION (object)); }
gboolean wmvm_do_udisks_init(void) { GPtrArray *devices; GError *error; int n; #if !GLIB_CHECK_VERSION(2,35,0) g_type_init(); #endif dbus_g_object_register_marshaller (udisks_marshal_VOID__BOXED_BOOLEAN_STRING_UINT_BOOLEAN_DOUBLE, G_TYPE_NONE, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_DOUBLE, G_TYPE_INVALID); if (!init_udisks_connection()) { return FALSE; } /* prime the list of devices */ error = NULL; if (!org_freedesktop_UDisks_enumerate_devices(udisks_proxy, &devices, &error)) { g_message("Error enumerating devices: %s", error->message); g_error_free(error); return FALSE; } for (n = 0; n < (int) devices->len; n++) udisks_device_added(udisks_proxy, g_ptr_array_index(devices, n), NULL); g_ptr_array_foreach(devices, (GFunc) g_free, NULL); g_ptr_array_free(devices, TRUE); return TRUE; }
NMBluezDevice * nm_bluez_device_new (const char *path) { NMBluezDevice *self; NMBluezDevicePrivate *priv; NMDBusManager *dbus_mgr; DBusGConnection *connection; self = (NMBluezDevice *) g_object_new (NM_TYPE_BLUEZ_DEVICE, NM_BLUEZ_DEVICE_PATH, path, NULL); if (!self) return NULL; priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self); dbus_mgr = nm_dbus_manager_get (); connection = nm_dbus_manager_get_connection (dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (connection, BLUEZ_SERVICE, priv->path, BLUEZ_DEVICE_INTERFACE); g_object_unref (dbus_mgr); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->proxy, "PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "PropertyChanged", G_CALLBACK (property_changed), self, NULL); query_properties (self); return self; }
static void dun_start (PluginInfo *info) { GError *error = NULL; GtkTreeIter iter; g_message ("%s: starting DUN device discovery...", __func__); /* Set up dbus */ info->bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (error || !info->bus) { dun_error (info, __func__, error, _("could not connect to the system bus.")); g_clear_error (&error); goto out; } gtk_label_set_text (GTK_LABEL (info->label), _("Detecting phone configuration...")); /* Start the spinner */ if (!info->spinner) { info->spinner = nma_bling_spinner_new (); gtk_box_pack_start (GTK_BOX (info->hbox), info->spinner, FALSE, FALSE, 6); } nma_bling_spinner_start (BMA_BLING_SPINNER (info->spinner)); gtk_widget_show_all (info->hbox); gtk_widget_set_sensitive (info->dun_button, FALSE); /* ModemManager stuff */ info->mm_proxy = dbus_g_proxy_new_for_name (info->bus, MM_SERVICE, MM_PATH, MM_INTERFACE); g_assert (info->mm_proxy); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, G_TYPE_BOXED, G_TYPE_INVALID); dbus_g_proxy_add_signal (info->mm_proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (info->mm_proxy, "DeviceAdded", G_CALLBACK (modem_added), info, NULL); dbus_g_proxy_add_signal (info->mm_proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (info->mm_proxy, "DeviceRemoved", G_CALLBACK (modem_removed), info, NULL); /* Get the device we're looking for */ info->dun_proxy = NULL; if (get_device_iter (info->btmodel, info->bdaddr, &iter)) gtk_tree_model_get (info->btmodel, &iter, BLUETOOTH_COLUMN_PROXY, &info->dun_proxy, -1); if (info->dun_proxy) { info->dun_timeout_id = g_timeout_add_seconds (45, dun_timeout_cb, info); dbus_g_proxy_set_interface (info->dun_proxy, BLUEZ_SERIAL_INTERFACE); g_message ("%s: calling Connect...", __func__); /* Watch for BT device property changes */ dbus_g_object_register_marshaller (nma_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_add_signal (info->dun_proxy, "PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (info->dun_proxy, "PropertyChanged", G_CALLBACK (dun_property_changed), info, NULL); /* Request a connection to the device and get the port */ dbus_g_proxy_begin_call_with_timeout (info->dun_proxy, "Connect", dun_connect_cb, info, NULL, 20000, G_TYPE_STRING, "dun", G_TYPE_INVALID); } else dun_error (info, __func__, error, _("could not find the Bluetooth device.")); out: g_message ("%s: finished", __func__); }
static void dun_start (NmaBtDevice *self) { NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self); gboolean have_mm = FALSE, have_mm1 = TRUE; g_message ("%s: starting DUN device discovery...", __func__); _set_status (self, _("Detecting phone configuration...")); /* ModemManager stuff */ priv->mm_proxy = dbus_g_proxy_new_for_name (priv->bus, MM_SERVICE, MM_PATH, MM_INTERFACE); g_assert (priv->mm_proxy); have_mm = _name_has_owner (priv->bus, MM_SERVICE); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, G_TYPE_BOXED, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->mm_proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->mm_proxy, "DeviceAdded", G_CALLBACK (modem_added), self, NULL); dbus_g_proxy_add_signal (priv->mm_proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->mm_proxy, "DeviceRemoved", G_CALLBACK (modem_removed), self, NULL); #if WITH_MODEM_MANAGER_1 /* ModemManager1 stuff */ { priv->dbus_connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL); if (priv->dbus_connection) { priv->modem_manager_1 = mm_manager_new_sync (priv->dbus_connection, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, NULL, NULL); if (priv->modem_manager_1) { g_signal_connect (priv->modem_manager_1, "object-added", G_CALLBACK (modem_object_added), self); g_signal_connect (priv->modem_manager_1, "object-removed", G_CALLBACK (modem_object_removed), self); } } have_mm1 = !!priv->modem_manager_1; } #endif /* Ensure at least one of ModemManager or ModemManager1 are around */ if (!have_mm && !have_mm1) { dun_error (self, __func__, NULL, _("ModemManager is not running")); return; } /* Bluez */ priv->dun_proxy = dbus_g_proxy_new_for_name (priv->bus, BLUEZ_SERVICE, priv->object_path, BLUEZ_SERIAL_INTERFACE); g_assert (priv->dun_proxy); priv->dun_timeout_id = g_timeout_add_seconds (45, dun_timeout_cb, self); g_message ("%s: calling Connect...", __func__); /* Watch for BT device property changes */ dbus_g_object_register_marshaller (_nma_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->dun_proxy, "PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->dun_proxy, "PropertyChanged", G_CALLBACK (dun_property_changed), self, NULL); /* Request a connection to the device and get the port */ dbus_g_proxy_begin_call_with_timeout (priv->dun_proxy, "Connect", dun_connect_cb, self, NULL, 20000, G_TYPE_STRING, "dun", G_TYPE_INVALID); g_message ("%s: waiting for Connect success...", __func__); }
static void sw_client_service_class_init (SwClientServiceClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); g_type_class_add_private (klass, sizeof (SwClientServicePrivate)); object_class->get_property = sw_client_service_get_property; object_class->set_property = sw_client_service_set_property; object_class->dispose = sw_client_service_dispose; object_class->finalize = sw_client_service_finalize; signals[AVATAR_RETRIEVED_SIGNAL] = g_signal_new ("avatar-retrieved", SW_CLIENT_TYPE_SERVICE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (SwClientServiceClass, avatar_retrieved), NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); signals[CAPS_CHANGED_SIGNAL] = g_signal_new ("capabilities-changed", SW_CLIENT_TYPE_SERVICE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (SwClientServiceClass, capabilities_changed), NULL, NULL, g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, G_TYPE_STRV); signals[STATUS_UPDATED_SIGNAL] = g_signal_new ("status-updated", SW_CLIENT_TYPE_SERVICE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (SwClientServiceClass, status_updated), NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); signals[USER_CHANGED_SIGNAL] = g_signal_new ("user-changed", SW_CLIENT_TYPE_SERVICE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (SwClientServiceClass, user_changed), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); dbus_g_object_register_marshaller (sw_marshal_VOID__INT_INT_STRING, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INVALID); }
static GObject * constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; BMRemoteSettingsPrivate *priv; const char *service = BM_DBUS_SERVICE_USER_SETTINGS; GError *error = NULL; object = G_OBJECT_CLASS (bm_remote_settings_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = BM_REMOTE_SETTINGS_GET_PRIVATE (object); /* D-Bus proxy for clearing connections on NameOwnerChanged */ priv->dbus_proxy = dbus_g_proxy_new_for_name (priv->bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); g_assert (priv->dbus_proxy); dbus_g_object_register_marshaller (_bm_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->dbus_proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->dbus_proxy, "NameOwnerChanged", G_CALLBACK (name_owner_changed), object, NULL); /* Settings service proxy */ if (priv->scope == BM_CONNECTION_SCOPE_SYSTEM) service = BM_DBUS_SERVICE_SYSTEM_SETTINGS; if (!dbus_g_proxy_call (priv->dbus_proxy, "NameHasOwner", &error, G_TYPE_STRING, service, G_TYPE_INVALID, G_TYPE_BOOLEAN, &priv->service_running, G_TYPE_INVALID)) { g_warning ("%s (BMRemoteSettings) error getting remote settings service status: (%d) %s\n", __func__, error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_error_free (error); priv->service_running = FALSE; } priv->proxy = dbus_g_proxy_new_for_name (priv->bus, service, BM_DBUS_PATH_SETTINGS, BM_DBUS_IFACE_SETTINGS); g_assert (priv->proxy); dbus_g_proxy_set_default_timeout (priv->proxy, G_MAXINT); dbus_g_proxy_add_signal (priv->proxy, "NewConnection", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "NewConnection", G_CALLBACK (new_connection_cb), object, NULL); priv->fetch_id = g_idle_add (fetch_connections, object); return object; }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMModemPrivate *priv; DBusGConnection *bus; object = G_OBJECT_CLASS (nm_modem_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = NM_MODEM_GET_PRIVATE (object); if (!priv->device) { nm_log_err (LOGD_HW, "modem parent device not provided"); goto err; } if (!priv->device) { nm_log_err (LOGD_HW, "modem command interface not provided"); goto err; } if (!priv->path) { nm_log_err (LOGD_HW, "D-Bus path not provided"); goto err; } bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, priv->path, MM_DBUS_INTERFACE_MODEM); priv->props_proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, priv->path, DBUS_INTERFACE_PROPERTIES); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->props_proxy, "MmPropertiesChanged", G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->props_proxy, "MmPropertiesChanged", G_CALLBACK (modem_properties_changed), object, NULL); query_mm_enabled (NM_MODEM (object)); return object; err: g_object_unref (object); return NULL; }
static void mnb_panel_oop_class_init (MnbPanelOopClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); g_type_class_add_private (klass, sizeof (MnbPanelOopPrivate)); object_class->get_property = mnb_panel_oop_get_property; object_class->set_property = mnb_panel_oop_set_property; object_class->dispose = mnb_panel_oop_dispose; object_class->finalize = mnb_panel_oop_finalize; object_class->constructed = mnb_panel_oop_constructed; g_object_class_install_property (object_class, PROP_DBUS_NAME, g_param_spec_string ("dbus-name", "Dbus name", "Dbus name", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, PROP_X, g_param_spec_int ("x", "X coordinate", "X coordiante", 0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_Y, g_param_spec_int ("y", "Y coordinate", "Y coordiante", 0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_WIDTH, g_param_spec_uint ("width", "Width", "Width", 0, G_MAXUINT, 1024, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_HEIGHT, g_param_spec_uint ("height", "Height", "Height", 0, G_MAXUINT, 1024, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_MODAL, g_param_spec_boolean ("modal", "Modal", "Whether panel has modal transients", FALSE, G_PARAM_READABLE)); signals[READY] = g_signal_new ("ready", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (MnbPanelOopClass, ready), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[REMOTE_PROCESS_DIED] = g_signal_new ("remote-process-died", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (MnbPanelOopClass, remote_process_died), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[DESTROY] = g_signal_new ("destroy", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); dbus_g_object_register_marshaller (meego_netbook_marshal_VOID__UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_object_register_marshaller (meego_netbook_marshal_VOID__INT_INT, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_INVALID); dbus_g_object_register_marshaller (meego_netbook_marshal_VOID__ENUM, G_TYPE_NONE, G_TYPE_ENUM, G_TYPE_INVALID); }