void empathy_connection_managers_prepare_async ( EmpathyConnectionManagers *self, GAsyncReadyCallback callback, gpointer user_data) { EmpathyConnectionManagersPriv *priv = GET_PRIV (self); GSimpleAsyncResult *result; result = g_simple_async_result_new (G_OBJECT (managers), callback, user_data, empathy_connection_managers_prepare_finish); if (priv->ready) { g_simple_async_result_complete_in_idle (result); g_object_unref (result); return; } g_signal_connect (self, "notify::ready", G_CALLBACK (notify_ready_cb), result); }
static void empathy_connection_managers_dispose (GObject *object) { EmpathyConnectionManagers *self = EMPATHY_CONNECTION_MANAGERS (object); EmpathyConnectionManagersPriv *priv = GET_PRIV (self); if (priv->dispose_has_run) return; priv->dispose_has_run = TRUE; if (priv->dbus != NULL) g_object_unref (priv->dbus); priv->dbus = NULL; empathy_connection_managers_free_cm_list (self); /* release any references held by the object here */ if (G_OBJECT_CLASS (empathy_connection_managers_parent_class)->dispose) G_OBJECT_CLASS (empathy_connection_managers_parent_class)->dispose (object); }
static void clicked_cb (GtkButton *button, gpointer user_data) { EmpathyIrcNetworkChooserPriv *priv = GET_PRIV (button); GtkWindow *window; if (priv->dialog != NULL) goto out; window = empathy_get_toplevel_window (GTK_WIDGET (button)); priv->dialog = empathy_irc_network_chooser_dialog_new (priv->settings, priv->network, window); gtk_widget_show_all (priv->dialog); tp_g_signal_connect_object (priv->dialog, "response", G_CALLBACK (dialog_response_cb), button, 0); out: empathy_window_present (GTK_WINDOW (priv->dialog)); }
static void gossip_cell_renderer_expander_get_size (GtkCellRenderer *cell, GtkWidget *widget, GdkRectangle *cell_area, gint *x_offset, gint *y_offset, gint *width, gint *height) { GossipCellRendererExpander *expander; GossipCellRendererExpanderPriv *priv; expander = (GossipCellRendererExpander*) cell; priv = GET_PRIV (expander); if (cell_area) { if (x_offset) { *x_offset = cell->xalign * (cell_area->width - (priv->expander_size + (2 * cell->xpad))); *x_offset = MAX (*x_offset, 0); } if (y_offset) { *y_offset = cell->yalign * (cell_area->height - (priv->expander_size + (2 * cell->ypad))); *y_offset = MAX (*y_offset, 0); } } else { if (x_offset) *x_offset = 0; if (y_offset) *y_offset = 0; } if (width) *width = cell->xpad * 2 + priv->expander_size; if (height) *height = cell->ypad * 2 + priv->expander_size; }
static void empathy_call_handler_request_cb (EmpathyDispatchOperation *operation, const GError *error, gpointer user_data) { EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data); EmpathyCallHandlerPriv *priv = GET_PRIV (self); if (error != NULL) return; priv->call = EMPATHY_TP_CALL ( empathy_dispatch_operation_get_channel_wrapper (operation)); g_object_ref (priv->call); empathy_call_handler_start_tpfs (self); empathy_tp_call_to (priv->call, priv->contact, priv->initial_audio, priv->initial_video); empathy_dispatch_operation_claim (operation); }
static void tp_contact_list_remove_from_group (EmpathyContactList *list, EmpathyContact *contact, const gchar *group_name) { EmpathyTpContactListPriv *priv = GET_PRIV (list); TpChannel *channel; TpHandle handle; GArray handles = {(gchar *) &handle, 1}; channel = g_hash_table_lookup (priv->groups, group_name); if (channel == NULL) { return; } handle = empathy_contact_get_handle (contact); DEBUG ("remove contact %s (%d) from group %s", empathy_contact_get_id (contact), handle, group_name); tp_cli_channel_interface_group_call_remove_members (channel, -1, &handles, NULL, NULL, NULL, NULL, NULL); }
static gboolean ft_manager_delete_event_cb (GtkWidget *widget, GdkEvent *event, EmpathyFTManager *manager) { EmpathyFTManagerPriv *priv = GET_PRIV (manager); DEBUG ("%p", manager); /* remove all the completed/cancelled/errored transfers */ ft_manager_clear (manager); if (g_hash_table_size (priv->ft_handler_to_row_ref) > 0) { /* There is still FTs on flight, just hide the window */ DEBUG ("Hiding window"); gtk_widget_hide (widget); return TRUE; } return FALSE; }
static void _empathy_account_connection_invalidated_cb (TpProxy *self, guint domain, gint code, gchar *message, gpointer user_data) { EmpathyAccount *account = EMPATHY_ACCOUNT (user_data); EmpathyAccountPriv *priv = GET_PRIV (account); if (priv->connection == NULL) return; DEBUG ("(%s) Connection invalidated", empathy_account_get_unique_name (account)); g_assert (priv->connection == TP_CONNECTION (self)); empathy_account_free_connection (account); g_object_notify (G_OBJECT (account), "connection"); }
static void presence_chooser_finalize (GObject *object) { EmpathyPresenceChooserPriv *priv; priv = GET_PRIV (object); if (priv->flash_timeout_id) { g_source_remove (priv->flash_timeout_id); } if (priv->focus_out_idle_source) { g_source_remove (priv->focus_out_idle_source); } g_signal_handlers_disconnect_by_func (priv->idle, presence_chooser_presence_changed_cb, object); g_object_unref (priv->idle); G_OBJECT_CLASS (empathy_presence_chooser_parent_class)->finalize (object); }
/** * empathy_avatar_image_set: * @avatar_image: an #EmpathyAvatarImage * @avatar: the #EmpathyAvatar to set @avatar_image to * * Sets @avatar_image to display the avatar indicated by @avatar. */ void empathy_avatar_image_set (EmpathyAvatarImage *avatar_image, EmpathyAvatar *avatar) { EmpathyAvatarImagePriv *priv = GET_PRIV (avatar_image); GdkPixbuf *scaled_pixbuf; g_return_if_fail (EMPATHY_IS_AVATAR_IMAGE (avatar_image)); if (priv->pixbuf) { g_object_unref (priv->pixbuf); priv->pixbuf = NULL; } if (avatar) { priv->pixbuf = empathy_pixbuf_from_data ((gchar *) avatar->data, avatar->len); } if (!priv->pixbuf) { gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), "stock_person", GTK_ICON_SIZE_DIALOG); return; } scaled_pixbuf = empathy_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_SMALL); gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled_pixbuf); if (scaled_pixbuf != priv->pixbuf) { gtk_widget_set_tooltip_text (GTK_WIDGET (avatar_image), _("Click to enlarge")); } else { gtk_widget_set_tooltip_text (GTK_WIDGET (avatar_image), NULL); } g_object_unref (scaled_pixbuf); }
static void tp_contact_list_group_add_channel (EmpathyTpContactList *list, const gchar *object_path, GHashTable *properties) { EmpathyTpContactListPriv *priv = GET_PRIV (list); TpChannel *channel; GError *error = NULL; channel = tp_channel_new_from_properties (priv->connection, object_path, properties, &error); if (channel == NULL) { DEBUG ("Failed to create group channel: %s", error->message); g_error_free (error); return; } /* Give the ref to the callback */ tp_channel_call_when_ready (channel, tp_contact_list_group_ready_cb, list); }
static void remove_from_member_if_needed (EmpathyTpContactList *list, TpHandle handle) { /* remove contact from members if it's not in publish and subscribe */ EmpathyTpContactListPriv *priv = GET_PRIV (list); const TpIntSet *members; members = tp_channel_group_get_members (priv->subscribe); if (tp_intset_is_member (members, handle)) return; members = tp_channel_group_get_remote_pending (priv->subscribe); if (tp_intset_is_member (members, handle)) return; members = tp_channel_group_get_members (priv->publish); if (tp_intset_is_member (members, handle)) return; tp_contact_list_remove_handle (list, priv->members, handle); }
/* We handle configure events on the toplevel in order to * reposition our window when the toplevel moves. */ static gboolean handle_toplevel_configure(GtkWidget *toplevel, GdkEventConfigure *event, GtkWidget *widget) { MozWebViewPriv *priv; gint x, y; priv = GET_PRIV(widget); DBG(g_print("Configure event !\n")); gdk_window_get_position(widget->window, &x, &y); x += widget->allocation.x; y += widget->allocation.y; SetWindowPos(priv->native_window, NULL, x, y, widget->allocation.width, widget->allocation.height, SWP_NOACTIVATE | SWP_NOZORDER); return FALSE; }
static void preferences_theme_variants_setup (EmpathyPreferences *preferences) { EmpathyPreferencesPriv *priv = GET_PRIV (preferences); GtkComboBox *combo; GtkCellLayout *cell_layout; GtkCellRenderer *renderer; GtkListStore *store; combo = GTK_COMBO_BOX (priv->combobox_chat_theme_variant); cell_layout = GTK_CELL_LAYOUT (combo); /* Create the model */ store = gtk_list_store_new (COL_VARIANT_COUNT, G_TYPE_STRING, /* name */ G_TYPE_BOOLEAN); /* is default */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), COL_VARIANT_NAME, GTK_SORT_ASCENDING); /* Add cell renderer */ renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", COL_VARIANT_NAME, NULL); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); g_object_unref (store); g_signal_connect (combo, "changed", G_CALLBACK (preferences_theme_variant_changed_cb), preferences); /* Track changes of the GSetting key */ g_signal_connect (priv->gsettings_chat, "changed::" EMPATHY_PREFS_CHAT_THEME_VARIANT, G_CALLBACK (preferences_theme_variant_notify_cb), preferences); }
static void contact_list_view_set_list_features (EmpathyContactListView *view, EmpathyContactListFeatureFlags features) { EmpathyContactListViewPriv *priv = GET_PRIV (view); gboolean has_tooltip; g_return_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view)); priv->list_features = features; /* Update DnD source/dest */ if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DRAG) { gtk_drag_source_set (GTK_WIDGET (view), GDK_BUTTON1_MASK, drag_types_source, G_N_ELEMENTS (drag_types_source), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { gtk_drag_source_unset (GTK_WIDGET (view)); } if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DROP) { gtk_drag_dest_set (GTK_WIDGET (view), GTK_DEST_DEFAULT_ALL, drag_types_dest, G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { /* FIXME: URI could still be droped depending on FT feature */ gtk_drag_dest_unset (GTK_WIDGET (view)); } /* Update has-tooltip */ has_tooltip = (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_TOOLTIP) != 0; gtk_widget_set_has_tooltip (GTK_WIDGET (view), has_tooltip); }
static void megaphone_applet_update_contact (MegaphoneApplet *applet) { MegaphoneAppletPriv *priv = GET_PRIV (applet); const gchar *name; const gchar *status; gchar *tip; const gchar *avatar_token = NULL; if (priv->contact) { EmpathyAvatar *avatar; avatar = empathy_contact_get_avatar (priv->contact); if (avatar) { avatar_token = avatar->token; } } if (avatar_token) { panel_applet_gconf_set_string (PANEL_APPLET (applet), "avatar_token", avatar_token, NULL); } megaphone_applet_update_icon (applet); if (priv->contact ) { name = empathy_contact_get_name (priv->contact); status = empathy_contact_get_status (priv->contact); tip = g_strdup_printf ("<b>%s</b>: %s", name, status); gtk_widget_set_tooltip_markup (GTK_WIDGET (applet), tip); g_free (tip); } else { gtk_widget_set_tooltip_markup (GTK_WIDGET (applet), _("Please configure a contact.")); } }
static unsigned int vcl_json(struct http_request *request, const char *arg, void *data) { struct agent_core_t *core = data; struct vcl_priv_t *vcl; struct ipc_ret_t vret; struct vsb *json; struct http_response *resp; GET_PRIV(core, vcl); assert(STARTS_WITH(request->url, "/vcljson")); assert(request->method == M_GET); if (arg) { http_reply(request->connection, 404, "/vcljson takes no argument"); return (0); } ipc_run(vcl->vadmin, &vret, "vcl.list"); if (vret.status == 400) http_reply(request->connection, 500, vret.answer); else { json = vcl_list_json(vret.answer); assert(VSB_finish(json) == 0); resp = http_mkresp(request->connection, 200, NULL); resp->data = VSB_data(json); resp->ndata = VSB_len(json); http_add_header(resp, "Content-Type", "application/json"); send_response(resp); http_free_resp(resp); VSB_clear(json); VSB_delete(json); } free(vret.answer); return (0); }
static gboolean protocol_chooser_filter_visible_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) { EmpathyProtocolChooser *protocol_chooser = user_data; EmpathyProtocolChooserPriv *priv = GET_PRIV (protocol_chooser); TpConnectionManager *cm = NULL; gchar *protocol_name = NULL; gboolean visible = FALSE; gchar *service; gtk_tree_model_get (model, iter, COL_CM, &cm, COL_PROTOCOL_NAME, &protocol_name, COL_SERVICE, &service, -1); if (cm != NULL && protocol_name != NULL) { TpConnectionManagerProtocol *protocol; protocol = (TpConnectionManagerProtocol *) tp_connection_manager_get_protocol (cm, protocol_name); if (protocol != NULL) { visible = priv->filter_func (cm, protocol, service, priv->filter_user_data); } } if (cm != NULL) g_object_unref (cm); g_free (service); return visible; }
static void empathy_call_handler_dispose (GObject *object) { EmpathyCallHandlerPriv *priv = GET_PRIV (object); if (priv->dispose_has_run) return; priv->dispose_has_run = TRUE; if (priv->contact != NULL) g_object_unref (priv->contact); priv->contact = NULL; if (priv->tfchannel != NULL) g_object_unref (priv->tfchannel); priv->tfchannel = NULL; if (priv->call != NULL) { empathy_tp_call_close (priv->call); g_object_unref (priv->call); } priv->call = NULL; if (priv->fsnotifier != NULL) { g_object_unref (priv->fsnotifier); } priv->fsnotifier = NULL; /* release any references held by the object here */ if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose) G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object); }
static void ft_handler_read_async_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GFileInputStream *stream; GError *error = NULL; HashingData *hash_data; EmpathyFTHandler *handler = user_data; EmpathyFTHandlerPriv *priv = GET_PRIV (handler); DEBUG ("GFile read async CB."); stream = g_file_read_finish (priv->gfile, res, &error); if (error != NULL) { emit_error_signal (handler, error); g_clear_error (&error); return; } hash_data = g_slice_new0 (HashingData); hash_data->stream = G_INPUT_STREAM (stream); hash_data->total_bytes = priv->total_bytes; hash_data->handler = g_object_ref (handler); /* FIXME: MD5 is the only ContentHashType supported right now */ hash_data->checksum = g_checksum_new (G_CHECKSUM_MD5); tp_asv_set_uint32 (priv->request, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_HASH_TYPE, TP_FILE_HASH_TYPE_MD5); g_signal_emit (handler, signals[HASHING_STARTED], 0); g_io_scheduler_push_job (do_hash_job, hash_data, NULL, G_PRIORITY_DEFAULT, priv->cancellable); }
static void tp_chat_got_added_contacts_cb (EmpathyTpContactFactory *factory, guint n_contacts, EmpathyContact * const * contacts, guint n_failed, const TpHandle *failed, const GError *error, gpointer user_data, GObject *chat) { EmpathyTpChatPriv *priv = GET_PRIV (chat); guint i; const TpIntSet *members; TpHandle handle; EmpathyContact *contact; if (error) { DEBUG ("Error: %s", error->message); return; } members = tp_channel_group_get_members (priv->channel); for (i = 0; i < n_contacts; i++) { contact = contacts[i]; handle = empathy_contact_get_handle (contact); /* Make sure the contact is still member */ if (tp_intset_is_member (members, handle)) { priv->members = g_list_prepend (priv->members, g_object_ref (contact)); g_signal_emit_by_name (chat, "members-changed", contact, NULL, 0, NULL, TRUE); } } tp_chat_update_remote_contact (EMPATHY_TP_CHAT (chat)); tp_chat_check_if_ready (EMPATHY_TP_CHAT (chat)); }
static void populate_data (EmpathyGroupsWidget *self) { EmpathyGroupsWidgetPriv *priv = GET_PRIV (self); EmpathyConnectionAggregator *aggregator; GeeSet *member_groups; GList *all_groups, *l; /* Remove the old groups */ gtk_list_store_clear (priv->group_store); /* FIXME: We have to get the whole group list from * EmpathyConnectionAggregator, as libfolks hasn't grown API to get the whole * group list yet. (bgo#627398) */ aggregator = empathy_connection_aggregator_dup_singleton (); all_groups = empathy_connection_aggregator_get_all_groups (aggregator); g_object_unref (aggregator); /* Get the list of groups that this #FolksGroupDetails is currently in */ member_groups = folks_group_details_get_groups (priv->group_details); for (l = all_groups; l != NULL; l = l->next) { const gchar *group_str = l->data; gboolean enabled; enabled = gee_collection_contains (GEE_COLLECTION (member_groups), group_str); gtk_list_store_insert_with_values (priv->group_store, NULL, -1, COL_NAME, group_str, COL_EDITABLE, TRUE, COL_ENABLED, enabled, -1); } g_list_free (all_groups); }
static void tp_contact_list_publish_group_members_changed_cb (TpChannel *channel, gchar *message, GArray *added, GArray *removed, GArray *local_pending, GArray *remote_pending, TpHandle actor, TpChannelGroupChangeReason reason, EmpathyTpContactList *list) { EmpathyTpContactListPriv *priv = GET_PRIV (list); guint i; /* We now send our presence to those contacts, remove them from pendings */ add_to_members (list, added); for (i = 0; i < added->len; i++) { tp_contact_list_remove_handle (list, priv->pendings, g_array_index (added, TpHandle, i)); } /* We refuse to send our presence to those contacts, remove from pendings */ for (i = 0; i < removed->len; i++) { TpHandle handle = g_array_index (removed, TpHandle, i); tp_contact_list_remove_handle (list, priv->pendings, handle); remove_from_member_if_needed (list, handle); } /* Those contacts want our presence, auto accept those that are already * member, otherwise add in pendings. */ if (local_pending->len > 0) { empathy_tp_contact_factory_get_from_handles (priv->connection, local_pending->len, (TpHandle *) local_pending->data, tp_contact_list_got_local_pending_cb, NULL, NULL, G_OBJECT (list)); } }
static void unlink_individual (EmpathyIndividualLinker *self, FolksIndividual *individual) { EmpathyIndividualLinkerPriv *priv = GET_PRIV (self); GeeSet *removed_personas, *old_personas; GeeHashSet *final_personas; gboolean personas_changed; /* Remove the individual from the link */ g_hash_table_remove (priv->changed_individuals, individual); /* Remove personas which are in @individual from priv->new_individual. */ old_personas = folks_individual_get_personas (priv->new_individual); removed_personas = folks_individual_get_personas (individual); final_personas = gee_hash_set_new (FOLKS_TYPE_PERSONA, g_object_ref, g_object_unref, g_direct_hash, g_direct_equal); gee_collection_add_all (GEE_COLLECTION (final_personas), GEE_COLLECTION (old_personas)); personas_changed = gee_collection_remove_all (GEE_COLLECTION (final_personas), GEE_COLLECTION (removed_personas)); if (personas_changed) { folks_individual_set_personas (priv->new_individual, GEE_SET (final_personas)); } g_clear_object (&final_personas); /* Update the toggle renderers, so that if this Individual is listed in * another group in the EmpathyIndividualView, the toggle button for that * group is updated. */ update_toggle_renderers (self); g_object_notify (G_OBJECT (self), "has-changed"); }
static void empathy_irc_server_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { EmpathyIrcServer *self = EMPATHY_IRC_SERVER (object); EmpathyIrcServerPriv *priv = GET_PRIV (self); switch (property_id) { case PROP_ADDRESS: if (tp_strdiff (priv->address, g_value_get_string (value))) { g_free (priv->address); priv->address = g_value_dup_string (value); g_signal_emit (object, signals[MODIFIED], 0); } break; case PROP_PORT: if (priv->port != g_value_get_uint (value)) { priv->port = g_value_get_uint (value); g_signal_emit (object, signals[MODIFIED], 0); } break; case PROP_SSL: if (priv->ssl != g_value_get_boolean (value)) { priv->ssl = g_value_get_boolean (value); g_signal_emit (object, signals[MODIFIED], 0); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void tp_contact_list_group_members_changed_cb (TpChannel *channel, gchar *message, GArray *added, GArray *removed, GArray *local_pending, GArray *remote_pending, guint actor, guint reason, EmpathyTpContactList *list) { EmpathyTpContactListPriv *priv = GET_PRIV (list); const gchar *group_name; guint i; contacts_added_to_group (list, channel, added); group_name = tp_channel_get_identifier (channel); for (i = 0; i < removed->len; i++) { EmpathyContact *contact; TpHandle handle; handle = g_array_index (removed, TpHandle, i); contact = g_hash_table_lookup (priv->members, GUINT_TO_POINTER (handle)); if (contact == NULL) { continue; } DEBUG ("Contact %s (%d) removed from group %s", empathy_contact_get_id (contact), handle, group_name); g_signal_emit_by_name (list, "groups-changed", contact, group_name, FALSE); } }
static void chat_window_edit_activate_cb (GtkWidget *menuitem, EmpathyChatWindow *window) { EmpathyChatWindowPriv *priv; GtkClipboard *clipboard; GtkTextBuffer *buffer; gboolean text_available; priv = GET_PRIV (window); g_return_if_fail (priv->current_chat != NULL); if (!empathy_chat_get_tp_chat (priv->current_chat)) { gtk_widget_set_sensitive (priv->menu_edit_copy, FALSE); gtk_widget_set_sensitive (priv->menu_edit_cut, FALSE); gtk_widget_set_sensitive (priv->menu_edit_paste, FALSE); return; } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->current_chat->input_text_view)); if (gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL)) { gtk_widget_set_sensitive (priv->menu_edit_copy, TRUE); gtk_widget_set_sensitive (priv->menu_edit_cut, TRUE); } else { gboolean selection; selection = empathy_chat_view_get_selection_bounds (priv->current_chat->view, NULL, NULL); gtk_widget_set_sensitive (priv->menu_edit_cut, FALSE); gtk_widget_set_sensitive (priv->menu_edit_copy, selection); } clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD); text_available = gtk_clipboard_wait_is_text_available (clipboard); gtk_widget_set_sensitive (priv->menu_edit_paste, text_available); }
static void contact_list_store_dispose (GObject *object) { EmpathyContactListStorePriv *priv = GET_PRIV (object); GList *contacts, *l; if (priv->dispose_has_run) return; priv->dispose_has_run = TRUE; contacts = empathy_contact_list_get_members (priv->list); for (l = contacts; l; l = l->next) { g_signal_handlers_disconnect_by_func (l->data, G_CALLBACK (contact_list_store_contact_updated_cb), object); g_object_unref (l->data); } g_list_free (contacts); g_signal_handlers_disconnect_by_func (priv->list, G_CALLBACK (contact_list_store_members_changed_cb), object); g_signal_handlers_disconnect_by_func (priv->list, G_CALLBACK (contact_list_store_groups_changed_cb), object); g_object_unref (priv->list); if (priv->inhibit_active) { g_source_remove (priv->inhibit_active); } if (priv->setup_idle_id != 0) { g_source_remove (priv->setup_idle_id); } G_OBJECT_CLASS (empathy_contact_list_store_parent_class)->dispose (object); }
/******************************************************************* * GtkWidgetClass * *******************************************************************/ static void moz_web_view_realize(GtkWidget *widget) { MozWebViewPriv *priv = GET_PRIV(widget); GdkWindowAttr attributes; gint attributes_mask; GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED); attributes.window_type = GDK_WINDOW_CHILD; attributes.x = widget->allocation.x; attributes.y = widget->allocation.y; attributes.width = widget->allocation.width; attributes.height = widget->allocation.height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual(widget); attributes.colormap = gtk_widget_get_colormap(widget); attributes.event_mask = gtk_widget_get_events(widget) | //| GDK_ALL_EVENTS_MASK; GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; widget->window = gtk_widget_get_parent_window(widget); g_object_ref(widget->window); priv->native_window = create_native_window(widget); priv->view->CreateBrowser(priv->native_window, 0, 0, widget->allocation.width, widget->allocation.height); widget->style = gtk_style_attach(widget->style, widget->window); gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL); if (priv->requested_uri) moz_web_view_load_uri(MOZ_WEB_VIEW(widget), priv->requested_uri); }
static void do_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { EmpathyImportDialogPriv *priv = GET_PRIV (object); switch (property_id) { case PROP_PARENT: priv->parent_window = g_value_get_object (value); break; case PROP_SHOW_WARNING: priv->show_warning = g_value_get_boolean (value); break; case PROP_CMS: priv->cms = g_value_dup_object (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }