static void
pad_removed (GstElement * element, GstPad * pad, KmsPlayerEndPoint * self)
{
GST_DEBUG ("Pad removed");
GstElement *appsink, *appsrc;
if (GST_PAD_IS_SINK (pad))
return;
appsink = g_object_steal_data (G_OBJECT (pad), APPSINK_DATA);
appsrc = g_object_steal_data (G_OBJECT (pad), APPSRC_DATA);
if (appsrc != NULL) {
GST_INFO ("Removing %" GST_PTR_FORMAT " from its parent", appsrc);
if (GST_OBJECT_PARENT (appsrc) != NULL) {
g_object_ref (appsrc);
gst_bin_remove (GST_BIN (GST_OBJECT_PARENT (appsrc)), appsrc);
gst_element_set_state (appsrc, GST_STATE_NULL);
g_object_unref (appsrc);
}
}
if (appsink == NULL) {
GST_ERROR ("No appsink was found associated with %" GST_PTR_FORMAT, pad);
return;
}
if (!gst_element_set_locked_state (appsink, TRUE))
GST_ERROR ("Could not block element %s", GST_ELEMENT_NAME (appsink));
GST_DEBUG ("Removing appsink %s from %s", GST_ELEMENT_NAME (appsink),
GST_ELEMENT_NAME (self->priv->pipeline));
gst_element_set_state (appsink, GST_STATE_NULL);
gst_bin_remove (GST_BIN (self->priv->pipeline), appsink);
}
/**
* callback for fullscreen mode gtk_container_foreach()
*/
static void
fullscreen_toggle_widget_visible(GtkWidget *wid, gpointer user_data) {
gchar* data_label;
struct FullscreenData *fdata;
gboolean old_v;
gchar *propName;
fdata = user_data;
// remove shadow of scrolled window
if (GTK_IS_SCROLLED_WINDOW(wid)) {
GtkShadowType shadow_type;
data_label = "fullscreen_shadow_type";
propName = "shadow-type";
if (fdata->visible == FALSE) {
g_object_get(G_OBJECT(wid),
propName, &shadow_type, NULL);
g_object_set(G_OBJECT(wid),
propName, GTK_SHADOW_NONE, NULL);
g_object_set_data(G_OBJECT(wid), data_label,
GINT_TO_POINTER(shadow_type));
} else {
shadow_type = GPOINTER_TO_INT(g_object_steal_data(
G_OBJECT(wid), data_label));
if (shadow_type && shadow_type != GTK_SHADOW_NONE) {
g_object_set(G_OBJECT(wid),
propName, shadow_type, NULL);
}
}
}
if (wid == fdata->me && !GTK_IS_NOTEBOOK(wid)) {
return;
}
data_label = "fullscreen_visible";
if (GTK_IS_NOTEBOOK(wid)) {
propName = "show-tabs";
} else {
propName = "visible";
}
if (fdata->visible == FALSE) {
g_object_get(G_OBJECT(wid), propName, &old_v, NULL);
g_object_set(G_OBJECT(wid), propName, FALSE, NULL);
g_object_set_data(G_OBJECT(wid), data_label,
GINT_TO_POINTER(old_v));
} else {
old_v = GPOINTER_TO_INT(g_object_steal_data(
G_OBJECT(wid), data_label));
if (old_v == TRUE) {
g_object_set(G_OBJECT(wid), propName, TRUE, NULL);
}
}
}
/**
* Restore the Buddy List to its former glory by splitting off conversations
*
* This effectively will undo everything done by pwm_merge_conversation(). The
* Buddy List should be returned to its original state, and any conversations
* should be in a separate window.
*
* @param[in] gtkblist The Buddy List that has had enough of this plugin
**/
void pwm_split_conversation(PidginBuddyList *gtkblist)
{
PidginWindow *
gtkconvwin; /*< Conversation window merged into gtkblist */
GtkWidget *paned; /*< The panes on the Buddy List window */
gchar *title; /*< Original title of the Buddy List window */
gtkconvwin = pwm_blist_get_convs(gtkblist);
paned = pwm_fetch(gtkblist, "paned");
title = pwm_fetch(gtkblist, "title");
/* Ensure the conversation window's menu items are returned. */
pwm_set_conv_menus_visible(gtkblist, FALSE);
/* End the association between the Buddy List and its conversation
* window. */
g_object_steal_data(G_OBJECT(gtkblist->notebook), "pwm_convs");
g_object_steal_data(G_OBJECT(gtkconvwin->notebook), "pwm_blist");
/* Point the conversation window's structure back to its original
* window. */
gtkconvwin->window = pwm_fetch(gtkblist, "conv_window");
pwm_clear(gtkblist, "conv_window");
/* Stop passing focus events from Buddy List to conversation window. */
g_object_disconnect(G_OBJECT(gtkblist->window), "any_signal",
G_CALLBACK(focus_in_event_cb), gtkconvwin->window,
NULL);
/* Restore the conversation window's notebook. */
pwm_widget_replace(pwm_fetch(gtkblist, "placeholder"),
gtkconvwin->notebook, NULL);
pwm_clear(gtkblist, "placeholder");
/* Free the dummy conversation, and display the window if it survives.
*/
pwm_free_dummy_conversation(gtkblist);
if (g_list_find(pidgin_conv_windows_get_list(), gtkconvwin) != NULL)
pidgin_conv_window_show(gtkconvwin);
/* Restore the Buddy List's original structure, and destroy the panes.
*/
pwm_widget_replace(paned, gtkblist->notebook, NULL);
pwm_clear(gtkblist, "paned");
/* Restore the window title and icons from before conversations set
* them. */
gtk_window_set_icon_list(GTK_WINDOW(gtkblist->window), NULL);
gtk_window_set_title(GTK_WINDOW(gtkblist->window), title);
g_free(title);
pwm_clear(gtkblist, "title");
}
static void
xedit_modeline_plugin_deactivate (XeditPlugin *plugin,
XeditWindow *window)
{
WindowData *wdata;
GList *views;
GList *l;
xedit_debug (DEBUG_PLUGINS);
wdata = g_object_steal_data (G_OBJECT (window), WINDOW_DATA_KEY);
g_signal_handler_disconnect (window, wdata->tab_added_handler_id);
g_signal_handler_disconnect (window, wdata->tab_removed_handler_id);
window_data_free (wdata);
views = xedit_window_get_views (window);
for (l = views; l != NULL; l = l->next)
{
disconnect_handlers (XEDIT_VIEW (l->data));
modeline_parser_deactivate (GTK_SOURCE_VIEW (l->data));
}
g_list_free (views);
}
void library_view_genres(GtkToggleToolButton *btn, GObject* lview)
{
if (g_object_steal_data(G_OBJECT(btn), "ignore"))
return;
library_view_t* view = (library_view_t*) g_object_get_data(lview, "library_view_t");
library_view_aspect_page(view, GENRE_ASPECT);
}
void plugin_cleanup(void)
{
guint i = 0;
gtk_widget_destroy(main_menu_item);
column_mode = FALSE;
foreach_document(i)
{
ScintillaObject *sci = documents[i]->editor->sci;
assign_select_keys(sci);
g_object_steal_data(G_OBJECT(sci), "column_mode");
g_object_steal_data(G_OBJECT(sci), "select_anchor");
g_object_steal_data(G_OBJECT(sci), "select_space");
}
}
void
gstroke_cleanup (GtkWidget *widget)
{
struct gstroke_metrics *metrics;
GHashTable *hash_table =
(GHashTable*)g_object_get_data(G_OBJECT(widget), GSTROKE_SIGNALS);
if (hash_table)
/* FIXME: does this delete the elements too? */
g_hash_table_destroy (hash_table);
g_object_steal_data(G_OBJECT(widget), GSTROKE_SIGNALS);
metrics = (struct gstroke_metrics*)g_object_get_data(G_OBJECT(widget),
GSTROKE_METRICS);
g_free(metrics);
g_object_steal_data(G_OBJECT(widget), GSTROKE_METRICS);
}
static gboolean remmina_rdp_close_connection(RemminaProtocolWidget* gp)
{
rfContext* rfi;
freerdp* instance;
rfi = GET_DATA(gp);
instance = rfi->instance;
if (rfi->thread)
{
pthread_cancel(rfi->thread);
if (rfi->thread)
pthread_join(rfi->thread, NULL);
}
pthread_mutex_destroy(&rfi->mutex);
g_mutex_free(rfi->gmutex);
g_cond_free(rfi->gcond);
remmina_rdp_event_uninit(gp);
remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");
if (instance)
{
if ( rfi->connected ) {
if (instance->context->channels)
freerdp_channels_close(instance->context->channels, instance);
freerdp_disconnect(instance);
rfi->connected = False;
}
}
if (rfi->rfx_context)
{
rfx_context_free(rfi->rfx_context);
rfi->rfx_context = NULL;
}
if (instance)
{
/* Remove instance->context from gp object data to avoid double free */
g_object_steal_data(G_OBJECT(gp), "plugin-data");
if (instance->context->channels) {
freerdp_channels_free(instance->context->channels);
instance->context->channels = NULL;
}
freerdp_context_free(instance); /* context is rfContext* rfi */
freerdp_free(instance);
rfi->instance = NULL;
}
return FALSE;
}
static void
signal_removed (gpointer data,
GClosure *closure)
{
DisconnectData *dd = data;
g_object_steal_data (dd->alive_object, "alive-object-data");
g_free (dd);
}
static gboolean
bst_canvas_link_build_async (gpointer data)
{
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (data);
if (gnome_canvas_item_check_undisposed (item))
{
BstCanvasLink *clink = BST_CANVAS_LINK (item);
if (!clink->arrow)
clink->arrow = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink),
GNOME_TYPE_CANVAS_POLYGON,
"outline_color_rgba", 0x000000ff,
"fill_color_rgba", 0xff0000ff,
NULL),
"signal::destroy", gtk_widget_destroyed, &clink->arrow,
"swapped_signal::event", bst_canvas_link_child_event, clink,
NULL);
if (!clink->tag_start)
clink->tag_start = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink),
GNOME_TYPE_CANVAS_ELLIPSE,
"outline_color_rgba", 0x000000ff, // xffff00ff,
"fill_color_rgba", 0xffff00ff,
NULL),
"signal::destroy", gtk_widget_destroyed, &clink->tag_start,
"swapped_signal::event", bst_canvas_link_child_event, clink,
NULL);
if (!clink->tag_end)
{
gboolean is_jchannel = FALSE;
if (clink->icsource)
is_jchannel = bst_canvas_source_is_jchannel (clink->icsource, clink->ichannel);
clink->tag_end = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink),
GNOME_TYPE_CANVAS_ELLIPSE,
"outline_color_rgba", 0x000000ff, // 0xff0000ff,
"fill_color_rgba", is_jchannel ? 0x00ff00ff : 0xff0000ff,
NULL),
"signal::destroy", gtk_widget_destroyed, &clink->tag_end,
"swapped_signal::event", bst_canvas_link_child_event, clink,
NULL);
}
if (!clink->line)
clink->line = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink),
GNOME_TYPE_CANVAS_LINE,
"fill_color", "black",
NULL),
"signal::destroy", gtk_widget_destroyed, &clink->line,
"swapped_signal::notify", bst_canvas_link_adjust_arrow, clink,
"swapped_signal::notify", bst_canvas_link_adjust_tags, clink,
NULL);
bst_canvas_link_update (clink);
}
GnomeCanvas *canvas = g_object_steal_data (item, "bst-workaround-canvas-ref");
g_object_unref (item);
if (canvas)
g_object_unref (canvas); /* canvases don't properly protect their items */
return FALSE;
}
static void
bus_factory_proxy_destroy (BusFactoryProxy *factory)
{
GList *p;
for (p = factory->engine_list; p != NULL ; p = p->next) {
IBusEngineDesc *desc = (IBusEngineDesc *)p->data;
g_object_steal_data ((GObject *)desc, "factory");
g_object_unref (desc);
}
g_list_free (factory->engine_list);
factory->engine_list = NULL;
if (factory->component) {
g_object_steal_data ((GObject *)factory->component, "factory");
g_object_unref (factory->component);
factory->component = NULL;
}
IBUS_OBJECT_CLASS(parent_class)->destroy (IBUS_OBJECT (factory));
}
static inline void
callbacks_set (MilterEventLoop *event_loop, GList *callbacks)
{
GObject *object;
object = G_OBJECT(event_loop);
g_object_steal_data(object, CALLBACKS_KEY);
g_object_set_data_full(object,
CALLBACKS_KEY,
callbacks,
(GDestroyNotify)g_list_free);
}
static gboolean
kms_recorder_end_point_post_error (gpointer data)
{
KmsRecorderEndPoint *self = KMS_RECORDER_END_POINT (data);
gchar *message = (gchar *) g_object_steal_data (G_OBJECT (self), "message");
GST_ELEMENT_ERROR (self, STREAM, FAILED, ("%s", message), (NULL));
g_free (message);
return G_SOURCE_REMOVE;
}
static void
gplp_unload_base (GOPluginLoader *loader, GOErrorInfo **ret_error)
{
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
GOPlugin *plugin = go_plugin_loader_get_plugin (loader);
GO_INIT_RET_ERROR_INFO (ret_error);
g_object_steal_data (G_OBJECT (plugin), "python-loader");
gnm_python_destroy_interpreter (
loader_python->py_object, loader_python->py_interpreter_info);
g_object_unref (loader_python->py_object);
}
/***********************************************
* hc_gtk2_engine_hack_menu_shell_cleanuo_signals -
*
* Cleanup/remove Menu Shell signals
***********************************************/
void
hc_gtk2_engine_hack_menu_shell_cleanup_signals(GtkWidget *widget)
{
if (GE_IS_MENU_BAR(widget))
{
gint id = 0;
id = (gint)g_object_steal_data (G_OBJECT(widget), "HC_MENU_SHELL_MOTION_ID");
g_signal_handler_disconnect(G_OBJECT(widget), id);
id = (gint)g_object_steal_data (G_OBJECT(widget), "HC_MENU_SHELL_LEAVE_ID");
g_signal_handler_disconnect(G_OBJECT(widget), id);
id = (gint)g_object_steal_data (G_OBJECT(widget), "HC_MENU_SHELL_DESTROY_ID");
g_signal_handler_disconnect(G_OBJECT(widget), id);
id = (gint)g_object_steal_data (G_OBJECT(widget), "HC_MENU_SHELL_STYLE_SET_ID");
g_signal_handler_disconnect(G_OBJECT(widget), id);
g_object_steal_data (G_OBJECT(widget), "HC_MENU_SHELL_HACK_SET");
}
}
static void gsb_csv_export_tree_view_list_export_rows ( FILE *csv_file, GtkTreeView *tree_view )
{
GtkTreeModel *model;
model = gtk_tree_view_get_model ( tree_view );
g_object_set_data ( G_OBJECT ( model ), "tree_view", tree_view );
gtk_tree_model_foreach ( model,
( GtkTreeModelForeachFunc ) gsb_csv_export_tree_view_list_foreach_callback,
csv_file );
g_object_steal_data ( G_OBJECT ( model ), "tree_view" );
}
static void
upload_keys (SeahorseWidget *swidget)
{
GtkWidget *widget;
const gchar *cuser, *chost;
gchar *user, *host, *port;
GList *keys;
GCancellable *cancellable;
keys = (GList*)g_object_steal_data (G_OBJECT (swidget), "upload-keys");
if (keys == NULL)
return;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "user-label"));
cuser = gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (cuser && g_utf8_validate (cuser, -1, NULL));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "host-label"));
chost = (gchar*)gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (chost && g_utf8_validate (chost, -1, NULL));
user = g_strdup (cuser);
host = g_strdup (chost);
/* Port is anything past a colon */
port = strchr (host, ':');
if (port) {
*port = 0;
port++;
/* Trim and check */
seahorse_util_string_trim_whitespace (port);
if (!port[0])
port = NULL;
}
seahorse_util_string_trim_whitespace (host);
seahorse_util_string_trim_whitespace (user);
cancellable = g_cancellable_new ();
/* Start an upload process */
seahorse_ssh_op_upload_async (SEAHORSE_SSH_SOURCE (seahorse_object_get_place (keys->data)),
keys, user, host, port, cancellable, on_upload_complete, NULL);
g_free (host);
g_free (user);
seahorse_progress_show (cancellable, _("Configuring Secure Shell Keys..."), FALSE);
g_object_unref (cancellable);
}
static void
qtcEntryCleanup(GtkWidget *widget)
{
if (qtcEntryLastMo == widget)
qtcEntryLastMo = NULL;
if (GTK_IS_ENTRY(widget)) {
GObject *obj = G_OBJECT(widget);
qtcDisconnectFromData(obj, "QTC_ENTRY_ENTER_ID");
qtcDisconnectFromData(obj, "QTC_ENTRY_LEAVE_ID");
qtcDisconnectFromData(obj, "QTC_ENTRY_DESTROY_ID");
qtcDisconnectFromData(obj, "QTC_ENTRY_UNREALIZE_ID");
qtcDisconnectFromData(obj, "QTC_ENTRY_STYLE_SET_ID");
g_object_steal_data(obj, "QTC_ENTRY_HACK_SET");
}
}
GdkPixbuf* vfs_file_info_get_big_icon( VFSFileInfo* fi )
{
/* get special icons for special files, especially for
some desktop icons */
if ( G_UNLIKELY( fi->flags != VFS_FILE_INFO_NONE ) )
{
int w, h;
int icon_size;
vfs_mime_type_get_icon_size( &icon_size, NULL );
if ( fi->big_thumbnail )
{
w = gdk_pixbuf_get_width( fi->big_thumbnail );
h = gdk_pixbuf_get_height( fi->big_thumbnail );
}
else
w = h = 0;
if ( ABS( MAX( w, h ) - icon_size ) > 2 )
{
char * icon_name = NULL;
if ( fi->big_thumbnail )
{
icon_name = ( char* ) g_object_steal_data(
G_OBJECT(fi->big_thumbnail), "name" );
g_object_unref( fi->big_thumbnail );
fi->big_thumbnail = NULL;
}
if ( G_LIKELY( icon_name ) )
{
if ( G_UNLIKELY( icon_name[ 0 ] == '/' ) )
fi->big_thumbnail = gdk_pixbuf_new_from_file( icon_name, NULL );
else
fi->big_thumbnail = vfs_load_icon(
gtk_icon_theme_get_default(),
icon_name, icon_size );
}
if ( fi->big_thumbnail )
g_object_set_data_full( G_OBJECT(fi->big_thumbnail), "name", icon_name, g_free );
else
g_free( icon_name );
}
return fi->big_thumbnail ? g_object_ref( fi->big_thumbnail ) : NULL;
}
if( G_UNLIKELY(!fi->mime_type) )
return NULL;
return vfs_mime_type_get_icon( fi->mime_type, TRUE );
}
// Hack to force webview exit from fullscreen mode on new page
static void
liferea_webkit_load_status_changed (WebKitWebView *view, GParamSpec *pspec, gpointer user_data)
{
WebKitLoadStatus loadStatus;
g_object_get (view, "load-status", &loadStatus, NULL);
if (loadStatus == WEBKIT_LOAD_PROVISIONAL) {
gboolean isFullscreen;
isFullscreen = GPOINTER_TO_INT(g_object_steal_data(
G_OBJECT(view), "fullscreen_on"));
if (isFullscreen == TRUE) {
webkit_web_view_execute_script (view,
"document.webkitExitFullscreen();");
}
}
}
static void
qtcComboBoxCleanup(GtkWidget *widget)
{
if (!widget)
return;
GObject *obj = G_OBJECT(widget);
if (g_object_get_data(obj, "QTC_COMBO_BOX_SET")) {
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_DESTROY_ID");
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_UNREALIZE_ID");
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_STYLE_SET_ID");
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_ENTER_ID");
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_LEAVE_ID");
qtcDisconnectFromData(obj, "QTC_COMBO_BOX_STATE_CHANGE_ID");
g_object_steal_data(G_OBJECT(widget), "QTC_COMBO_BOX_SET");
}
}
static gboolean
fade_in (gpointer data)
{
GtkWidget *spinner = data;
gdouble opacity;
opacity = gtk_widget_get_opacity (spinner);
opacity = opacity + 0.1;
gtk_widget_set_opacity (spinner, opacity);
if (opacity >= 1.0) {
g_object_steal_data (G_OBJECT (spinner), "fade-timeout");
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}
static gboolean
start_spinning (gpointer data)
{
GtkWidget *spinner = data;
guint id;
gtk_widget_set_opacity (spinner, 0);
gtk_spinner_start (GTK_SPINNER (spinner));
id = g_timeout_add (100, fade_in, spinner);
g_object_set_data_full (G_OBJECT (spinner), "fade-timeout",
GUINT_TO_POINTER (id), remove_source);
/* don't try to remove this source in the future */
g_object_steal_data (G_OBJECT (spinner), "start-timeout");
return G_SOURCE_REMOVE;
}
/* Finalize this object */
static void cookie_permission_manager_finalize(GObject *inObject)
{
CookiePermissionManager *self=COOKIE_PERMISSION_MANAGER(inObject);
CookiePermissionManagerPrivate *priv=self->priv;
GList *browsers, *browser;
GList *tabs, *tab;
WebKitWebView *webkitView;
/* Dispose allocated resources */
if(priv->databaseFilename)
{
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE_FILENAME]);
}
if(priv->database)
{
sqlite3_close(priv->database);
priv->database=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE]);
}
g_signal_handler_disconnect(priv->cookieJar, priv->cookieJarChangedID);
g_object_steal_data(G_OBJECT(priv->cookieJar), "cookie-permission-manager");
g_signal_handlers_disconnect_by_data(priv->application, self);
browsers=midori_app_get_browsers(priv->application);
for(browser=browsers; browser; browser=g_list_next(browser))
{
g_signal_handlers_disconnect_by_data(browser->data, self);
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browser->data));
for(tab=tabs; tab; tab=g_list_next(tab))
{
webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(MIDORI_VIEW(tab->data)));
g_signal_handlers_disconnect_by_data(webkitView, self);
}
g_list_free(tabs);
}
g_list_free(browsers);
/* Call parent's class finalize method */
G_OBJECT_CLASS(cookie_permission_manager_parent_class)->finalize(inObject);
}
static void
disconnect_handlers (XeditView *view)
{
DocumentData *data;
GtkTextBuffer *doc;
doc = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
data = g_object_steal_data (G_OBJECT (doc), DOCUMENT_DATA_KEY);
if (data)
{
g_signal_handler_disconnect (doc, data->document_loaded_handler_id);
g_signal_handler_disconnect (doc, data->document_saved_handler_id);
document_data_free (data);
}
else
{
g_warning ("Modeline handlers not found");
}
}
static void qtcScrolledWindowCleanup(GtkWidget *widget)
{
if (widget && g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET"))
{
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_DESTROY_ID"));
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_UNREALIZE_ID"));
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_STYLE_SET_ID"));
if(ENTRY_MO)
{
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_ENTER_ID"));
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_LEAVE_ID"));
}
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_IN_ID"));
g_signal_handler_disconnect(G_OBJECT(widget),
(gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_OUT_ID"));
g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET");
}
}
void
gtr_widget_set_visible (GtkWidget * w, gboolean b)
{
/* toggle the transient children, too */
if (GTK_IS_WINDOW (w))
{
GList * l;
GList * windows = gtk_window_list_toplevels ();
GtkWindow * window = GTK_WINDOW (w);
for (l=windows; l!=NULL; l=l->next)
{
if (!GTK_IS_WINDOW (l->data))
continue;
if (gtk_window_get_transient_for (GTK_WINDOW (l->data)) != window)
continue;
if (gtk_widget_get_visible (GTK_WIDGET (l->data)) == b)
continue;
if (b && g_object_get_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN) != NULL)
{
g_object_steal_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN);
gtr_widget_set_visible (GTK_WIDGET (l->data), TRUE);
}
else if (!b)
{
g_object_set_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN, GINT_TO_POINTER (1));
gtr_widget_set_visible (GTK_WIDGET (l->data), FALSE);
}
}
g_list_free (windows);
}
gtk_widget_set_visible (w, b);
}
void
_nm_object_cache_clear (NMObject *except)
{
GHashTableIter iter;
NMObject *obj;
const char *path;
char *foo;
_init_cache ();
g_hash_table_iter_init (&iter, cache);
while (g_hash_table_iter_next (&iter, (gpointer) &path, (gpointer) &obj)) {
if (obj != except) {
/* Remove the callback so that if the object isn't yet released
* by a client, when it does finally get unrefed, it won't trigger
* the cache removal for a new object with the same path as the
* one being released.
*/
foo = g_object_steal_data (G_OBJECT (obj), "nm-object-cache-tag");
g_free (foo);
g_hash_table_iter_remove (&iter);
}
}
}
static gboolean
bst_canvas_source_build_async (gpointer data)
{
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (data);
if (gnome_canvas_item_check_undisposed (item))
{
BstCanvasSource *csource = BST_CANVAS_SOURCE (item);
GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (csource);
/* keep in mind, that creation order affects stacking */
/* add input and output channel items */
if (!csource->built_ichannels)
{
csource->built_ichannels = TRUE;
bst_canvas_source_build_channels (csource,
TRUE, /* input channels */
0xffff00, 0x808000, /* ichannels */
0x00afff, 0x005880, /* jchannels */
TRUE, FALSE);
return TRUE;
}
if (!csource->built_ochannels)
{
csource->built_ochannels = TRUE;
bst_canvas_source_build_channels (csource,
FALSE, /* output channels */
0xff0000, 0x800000, /* ochannels */
0, 0, /* unused */
TRUE, FALSE);
return TRUE;
}
/* add icon to group */
if (!csource->icon_item)
{
csource->icon_item = g_object_connect (gnome_canvas_item_new (group,
GNOME_TYPE_CANVAS_PIXBUF,
"x", ICON_X (csource),
"y", ICON_Y (csource),
"width", ICON_WIDTH (csource),
"height", ICON_HEIGHT (csource),
NULL),
"signal::destroy", gtk_widget_destroyed, &csource->icon_item,
"swapped_signal::event", bst_canvas_source_child_event, csource,
NULL);
source_icon_changed (csource);
return TRUE;
}
if (!csource->text)
{
/* add text item, invoke name_changed callback to setup the text value */
guint ocolor = csource->source && bse_item_internal (csource->source) ? RGBA_INTERNAL : RGBA_BLACK;
csource->text = gnome_canvas_item_new (group,
GNOME_TYPE_CANVAS_TEXT,
"fill_color_rgba", ocolor,
"anchor", GTK_ANCHOR_NORTH,
"justification", GTK_JUSTIFY_CENTER,
"x", TEXT_X (csource),
"y", TEXT_Y (csource),
"font", TEXT_FONT,
NULL);
g_object_connect (csource->text,
"signal::destroy", gtk_widget_destroyed, &csource->text,
"swapped_signal::event", bst_canvas_source_child_event, csource,
NULL);
gnome_canvas_text_set_zoom_size (GNOME_CANVAS_TEXT (csource->text), FONT_HEIGHT);
source_name_changed (csource);
return TRUE;
}
/* add input and output channel hints */
if (!csource->built_ihints)
{
csource->built_ihints = TRUE;
bst_canvas_source_build_channels (csource,
TRUE, /* input channels */
0xffff00, 0x808000, /* ichannels */
0x00afff, 0x005880, /* jchannels */
FALSE, TRUE);
return TRUE;
}
if (!csource->built_ohints)
{
csource->built_ohints = TRUE;
bst_canvas_source_build_channels (csource,
FALSE, /* output channels */
0xff0000, 0x800000, /* ochannels */
0, 0, /* unused */
FALSE, TRUE);
return TRUE;
}
}
GnomeCanvas *canvas = g_object_steal_data (item, "bst-workaround-canvas-ref");
g_object_unref (item);
if (canvas)
g_object_unref (canvas); /* canvases don't properly protect their items */
return FALSE;
}
void
remove_pidgin_menuitems (PurpleConversation * conv) {
if (PIDGIN_IS_PIDGIN_CONVERSATION (conv)) {
PurplePlugin *plugin;
GtkWidget *screenshot_insert_menuitem;
GtkWidget *screenshot_menuitem, *conversation_menu;
GtkWidget *insert_menu;
PidginWindow *win;
PidginConversation *gtkconv;
gtkconv = PIDGIN_CONVERSATION (conv);
plugin = purple_plugins_find_with_id (PLUGIN_ID);
win = pidgin_conv_get_window (gtkconv);
if (win != NULL) {
if ((conversation_menu =
gtk_item_factory_get_widget (win->menu.item_factory,
N_("/Conversation"))) != NULL) {
/* remove signal */
gulong handler = g_signal_handler_find (conversation_menu,
G_SIGNAL_MATCH_FUNC,
0,
0,
NULL,
G_CALLBACK
(on_conversation_menu_show_cb),
NULL);
if (handler)
g_signal_handler_disconnect (conversation_menu, handler);
if ((screenshot_menuitem =
g_object_get_data (G_OBJECT (conversation_menu),
"screenshot_menuitem")) != NULL) {
gtk_widget_destroy (screenshot_menuitem);
g_object_steal_data (G_OBJECT (conversation_menu),
"screenshot_menuitem");
g_object_steal_data (G_OBJECT (conversation_menu),
"img_menuitem");
#ifdef ENABLE_UPLOAD
g_object_steal_data (G_OBJECT (conversation_menu),
"link_menuitem");
g_object_steal_data (G_OBJECT (conversation_menu),
"ftp_link_menuitem");
#endif
}
}
}
/* remove signal */
if ((insert_menu =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"insert_menu")) != NULL) {
gulong handler = g_signal_handler_find (insert_menu,
G_SIGNAL_MATCH_FUNC,
0,
0,
NULL,
G_CALLBACK
(on_insert_menu_show_cb),
NULL);
if (handler)
g_signal_handler_disconnect (insert_menu, handler);
}
screenshot_insert_menuitem =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem");
if (screenshot_insert_menuitem != NULL) {
gtk_widget_destroy (screenshot_insert_menuitem);
g_object_steal_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem");
}
}
}
