static void gmpc_mpd_data_treeview_tooltip_metadata_changed (GmpcMpdDataTreeviewTooltip* self, GmpcMetaWatcher* gmw2, const mpd_Song* song, MetaDataType type, MetaDataResult _result_, const MetaData* met) { gchar* _tmp0_ = NULL; gchar* _tmp1_; gboolean _tmp2_; GError * _inner_error_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (gmw2 != NULL); g_return_if_fail (song != NULL); if (type != self->mtype) { return; } _tmp0_ = mpd_song_checksum (song); _tmp1_ = _tmp0_; _tmp2_ = g_strcmp0 (self->priv->checksum, _tmp1_) != 0; _g_free0 (_tmp1_); if (_tmp2_) { return; } if (_result_ == META_DATA_UNAVAILABLE) { gtk_image_clear (self->priv->image); } else { if (_result_ == META_DATA_FETCHING) { gtk_image_clear (self->priv->image); } else { if (_result_ == META_DATA_AVAILABLE) { if (met->content_type == META_DATA_CONTENT_URI) { const gchar* _tmp3_ = NULL; GdkPixbuf* _tmp4_ = NULL; GdkPixbuf* pb; _tmp3_ = meta_data_get_uri (met); _tmp4_ = gdk_pixbuf_new_from_file_at_scale (_tmp3_, 150, 150, TRUE, &_inner_error_); pb = _tmp4_; if (_inner_error_ != NULL) { goto __catch27_g_error; } gtk_image_set_from_pixbuf (self->priv->image, pb); _g_object_unref0 (pb); goto __finally27; __catch27_g_error: { GError * e; e = _inner_error_; _inner_error_ = NULL; gtk_image_clear (self->priv->image); _g_error_free0 (e); } __finally27: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return; } } else { gtk_image_clear (self->priv->image); } } } } }
void moko_tips_set_matches (MokoTips *tips, GList *list) { MokoTipsPrivate *priv; gint i; g_return_if_fail (MOKO_IS_TIPS (tips)); priv = tips->priv; for (i = 0; i < N_TIPS; i++) { MokoContactEntry *entry = NULL; GtkWidget *label = gtk_bin_get_child (GTK_BIN (priv->tips[i])); entry = (MokoContactEntry*)g_list_nth_data (list, i); if (entry && entry->contact) { gtk_label_set_text (GTK_LABEL (label), entry->contact->name); if (i == 0) { GdkPixbuf *scaled = NULL; if (!entry->contact->photo) moko_contacts_get_photo (moko_contacts_get_default (), entry->contact); if (!entry->contact->photo) { gtk_image_clear (GTK_IMAGE (priv->image)); } else { scaled = gdk_pixbuf_scale_simple (entry->contact->photo, 36, 36, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); g_object_unref (scaled); } } gtk_widget_show (label); } else { gtk_widget_hide (label); gtk_label_set_text (GTK_LABEL (label), ""); if (i == 0) { gtk_image_clear (GTK_IMAGE (priv->image)); gtk_widget_show (label); } } g_object_set_data (G_OBJECT (priv->tips[i]), "entry", entry); } }
static void cleanup_window() { gtk_widget_set_sensitive(button, FALSE); gtk_widget_set_sensitive(revoke_button, FALSE); gtk_image_clear(GTK_IMAGE(permission_status_icon)); gtk_image_clear(GTK_IMAGE(additional_details_icon)); gtk_label_set_label(GTK_LABEL(permission_status_label), ("")); gtk_label_set_label(GTK_LABEL(details_label_first), ""); gtk_widget_hide(url_button); gtk_label_set_label(GTK_LABEL(details_label_second), ""); gtk_label_set_label(GTK_LABEL(additional_details_label), ""); }
static void workspaceview_refresh( vObject *vobject ) { Workspaceview *wview = WORKSPACEVIEW( vobject ); Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject ); #ifdef DEBUG printf( "workspaceview_refresh: %p %s\n", ws, IOBJECT( ws )->name ); #endif /*DEBUG*/ gtk_widget_set_sensitive( GTK_WIDGET( wview ), !ws->locked ); workspace_jump_update( ws, wview->popup_jump ); if( ws->rpane_open && !wview->rpane->open ) pane_animate_open( wview->rpane ); if( !ws->rpane_open && wview->rpane->open ) pane_animate_closed( wview->rpane ); if( ws->lpane_open && !wview->lpane->open ) pane_animate_open( wview->lpane ); if( !ws->lpane_open && wview->lpane->open ) pane_animate_closed( wview->lpane ); if( wview->label ) { gtk_label_set_text( GTK_LABEL( wview->label ), IOBJECT( ws )->name ); if( IOBJECT( ws )->caption ) set_tooltip( wview->label, "%s", IOBJECT( ws )->caption ); if( ws->locked ) gtk_image_set_from_stock( GTK_IMAGE( wview->padlock ), STOCK_LOCK, GTK_ICON_SIZE_MENU ); else gtk_image_clear( GTK_IMAGE( wview->padlock ) ); if( ws->errors ) gtk_image_set_from_stock( GTK_IMAGE( wview->alert ), STOCK_ALERT, GTK_ICON_SIZE_MENU ); else gtk_image_clear( GTK_IMAGE( wview->alert ) ); } VOBJECT_CLASS( parent_class )->refresh( vobject ); }
void bline_image_set_visible (BlineImage *self, IplImage *image) { GdkPixbuf *pixbuf; IplImage *rgbimage; if (image == NULL) { gtk_image_clear (GTK_IMAGE (self)); return; } rgbimage = cvCreateImage (cvSize (image->width, image->height), image->depth, 3); cvConvertImage (image, rgbimage, 0); pixbuf = gdk_pixbuf_new_from_data ((const guchar *) rgbimage->imageData, GDK_COLORSPACE_RGB, FALSE, rgbimage->depth, rgbimage->width, rgbimage->height, rgbimage->widthStep, bline_image_release_pixbuf_ipl_image, (gpointer) rgbimage); gtk_image_set_from_pixbuf (GTK_IMAGE (self), pixbuf); g_object_unref (G_OBJECT (pixbuf)); }
static void field_changed_cb (GtkWidget *widget, GdauiDsnEditor *config) { if (widget == config->priv->wprovider) { /* replace the expander's contents */ const gchar *pname; pname = gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)); _gdaui_provider_spec_editor_set_provider (GDAUI_PROVIDER_SPEC_EDITOR (config->priv->dsn_spec), pname); _gdaui_provider_auth_editor_set_provider (GDAUI_PROVIDER_AUTH_EDITOR (config->priv->dsn_auth), pname); GdaProviderInfo *pinfo; pinfo = gda_config_get_provider_info (pname); GdkPixbuf *pix; pix = support_create_pixbuf_for_provider (pinfo); if (pix) { gtk_image_set_from_pixbuf (GTK_IMAGE (config->priv->icon), pix); g_object_unref (pix); } else gtk_image_clear (GTK_IMAGE (config->priv->icon)); if (pinfo) gtk_widget_hide (config->priv->warning); else gtk_widget_show (config->priv->warning); } if (! config->priv->no_change_signal) g_signal_emit (config, gdaui_dsn_editor_signals[CHANGED], 0, NULL); }
static void open_image(char* path) { unsigned int width, height; if(bdk_window.decoder != NULL){ bdk_window.decoder = delete_Decoder(bdk_window.decoder); } bdk_window.decoder = create_Decoder_c(path, bdk_window.error_path); width = get_SIZ_Xsiz(bdk_window.decoder) - get_SIZ_XOsiz(bdk_window.decoder); height = get_SIZ_Ysiz(bdk_window.decoder) - get_SIZ_YOsiz(bdk_window.decoder); bdk_window.buffer = new unsigned char[width * height * 3]; bdk_window.pixbuf = gdk_pixbuf_new_from_data( bdk_window.buffer, GDK_COLORSPACE_RGB, FALSE, 8, width, height, width * 3, NULL, NULL); fill_buffer( bdk_window.decoder, 0, 0, bdk_window.buffer, width, height); gtk_image_clear(GTK_IMAGE(bdk_window.image)); gtk_image_set_from_pixbuf(GTK_IMAGE(bdk_window.image), bdk_window.pixbuf); //gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (bdk_window.scrolled_window), bdk_window.image); create_and_fill_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(bdk_window.view), bdk_window.model); g_object_unref(bdk_window.model); }
static void clear_infowin (void) { gtk_entry_set_text ((GtkEntry *) entry_title, ""); gtk_entry_set_text ((GtkEntry *) entry_artist, ""); gtk_entry_set_text ((GtkEntry *) entry_album, ""); gtk_entry_set_text ((GtkEntry *) entry_comment, ""); gtk_entry_set_text ((GtkEntry *) gtk_bin_get_child ((GtkBin *) entry_genre), ""); gtk_entry_set_text ((GtkEntry *) entry_year, ""); gtk_entry_set_text ((GtkEntry *) entry_track, ""); infowin_label_set_text (label_format_name, NULL); infowin_label_set_text (label_quality, NULL); infowin_label_set_text (label_bitrate, NULL); gtk_label_set_text ((GtkLabel *) label_mini_status, "<span size=\"small\"></span>"); gtk_label_set_use_markup ((GtkLabel *) label_mini_status, TRUE); g_free (current_file); current_file = NULL; current_decoder = NULL; something_changed = FALSE; can_write = FALSE; gtk_widget_set_sensitive (btn_apply, FALSE); gtk_image_clear ((GtkImage *) image_artwork); }
void check_file(SettingItem * item,gchar * f) { GdkPixbuf * p; p = gdk_pixbuf_new_from_file(f,NULL); if(p) { gtk_image_set_from_pixbuf(item->image,p); gtk_image_set_from_pixbuf(item->preview,p); } else { gtk_image_clear(item->image); gtk_image_clear(item->preview); } if(p) g_object_unref(p); }
/** * album_art_set_pixbuf: * */ void mpris2_album_art_set_pixbuf (Mpris2AlbumArt *albumart, GdkPixbuf *pixbuf) { g_return_if_fail (MPRIS2_IS_ALBUM_ART(albumart)); gtk_image_clear (GTK_IMAGE(albumart)); gtk_image_set_from_pixbuf (GTK_IMAGE(albumart), pixbuf); }
static void gnac_properties_reset_field(GtkWidget *widget) { if (GTK_IS_ENTRY(widget)) { gtk_entry_set_text(GTK_ENTRY(widget), ""); } else if (GTK_IS_IMAGE(widget)) { gtk_image_clear(GTK_IMAGE(widget)); } }
static void ido_source_menu_item_set_icon (IdoSourceMenuItem *item, GIcon *icon) { if (icon) gtk_image_set_from_gicon (GTK_IMAGE (item->icon), icon, GTK_ICON_SIZE_MENU); else gtk_image_clear (GTK_IMAGE (item->icon)); }
static void on_click_exit_us(GtkImageMenuItem *item, gpointer user_data){ gtk_image_clear((GtkImage*)img_exit_us); if (b_exit_us) { img_exit_us = (GtkImage*)gtk_image_new_from_file(PIXMAPSDIR"us.png"); gtk_image_menu_item_set_image(i_exit_us, (GtkWidget*)img_exit_us); b_exit_us = 0; } else { img_exit_us = (GtkImage*)gtk_image_new_from_file(PIXMAPSDIR"us_on.png"); gtk_image_menu_item_set_image(i_exit_us, (GtkWidget*)img_exit_us); b_exit_us = 1; } }
static void image_update(GtkObject *obj, GtkImage *view) { if(gegl_can_process(geglGraph->node_pixbuf)) { //g_free(geglGraph->pixbuf); geglGraph->pixbuf=NULL; gegl_node_process(geglGraph->node_pixbuf); } gtk_image_clear(view); gtk_image_set_from_pixbuf(view,geglGraph->pixbuf); }
static void change_button(PROC_T *p, const gchar *STOCKID, void (*func)){ if(p->btn){ g_signal_handler_disconnect(p->btn, p->btnhandler); }else{ p->btn=new_button(); } if(p->btnimage){//update image gtk_image_clear(GTK_IMAGE(p->btnimage)); gtk_image_set_from_stock(GTK_IMAGE(p->btnimage),STOCKID,GTK_ICON_SIZE_MENU); }else{//create image and add to display p->btnimage=gtk_image_new_from_stock(STOCKID,GTK_ICON_SIZE_MENU); gtk_container_add(GTK_CONTAINER(p->btn), p->btnimage); } p->btnhandler=g_signal_connect(p->btn,"button_press_event",G_CALLBACK(func),(gpointer)p); gtk_widget_show_all(p->btn); }
static void updatePortPixbuf(struct viewport *pp) { int mypage_i; /* no valid target size? */ if (pp->width <= 0 || pp->height <= 0) return; /* decide which page to render - if any */ mypage_i = pagenumForPort(pp); if (mypage_i < 0 || mypage_i >= doc_n_pages) { /* This port does not show anything right now, so clear its * content and quit. */ gtk_image_clear(GTK_IMAGE(pp->image)); return; } /* if note-control is active, print current page number if on * "main" frame. (don't do this on the beamer because it could be * locked.) * this allows you to attach any kind of other program or script * which can show notes for a specific slide. simply pipe the * output of pdfpres to your other tool. */ if (pp->offset == 0 && !pp->isBeamer) { printNote(doc_page + 1); if (runpref.do_notectrl) { printf("%d\n", doc_page + 1); fflush(stdout); } } /* get a pixbuf for this viewport. caching is behind * getRenderedPixbuf(). */ pp->pixbuf = getRenderedPixbuf(pp, mypage_i); /* display the current page. */ if (pp->pixbuf != NULL) gtk_image_set_from_pixbuf(GTK_IMAGE(pp->image), pp->pixbuf); else fprintf(stderr, "[Cache] Returned empty pixbuf." " You're doing something wrong.\n"); }
void wibuti_widget_set_icon(WibutiWidget *self, GdkPixbuf *icon) { // TODO: fix memory leak if (self->use_icon) { if (icon == NULL) { gtk_image_clear(self->image_icon); self->icon = NULL; } else { GdkPixbuf *icon_tmp1 = gdk_pixbuf_scale_simple(icon, ICON_WIDTH, ICON_HEIGHT, GDK_INTERP_BILINEAR); self->icon = icon_tmp1; if (!self->is_active) { gdk_pixbuf_saturate_and_pixelate(icon_tmp1, icon_tmp1, 0, FALSE); } GdkPixbuf *icon_tmp2 = gdk_pixbuf_rotate_simple(icon_tmp1, self->angle); gtk_image_set_from_pixbuf(self->image_icon, icon_tmp2); g_object_unref(icon_tmp2); } } }
static void ido_media_player_menu_item_set_album_art (IdoMediaPlayerMenuItem *self, const gchar *url) { GFile *file; g_return_if_fail (IDO_IS_MEDIA_PLAYER_MENU_ITEM (self)); gtk_image_clear (GTK_IMAGE (self->album_art)); if (url == NULL) return; file = g_file_new_for_uri (url); g_file_read_async (file, G_PRIORITY_DEFAULT, self->cancellable, album_art_file_opened, self); g_object_unref (file); }
void multitrack_close_track( void *data ) { multitracker_t *mt = (multitracker_t*) data; if( mt->selected > 0 && mt->selected < MAX_TRACKS ) { gvr_track_disconnect( mt->preview, mt->selected ); mt->view[mt->selected]->status_lock = 1; gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(mt->view[mt->selected]->toggle), FALSE ); gtk_widget_set_sensitive_(GTK_WIDGET(mt->view[mt->selected]->panel), FALSE ); gtk_widget_set_sensitive_(GTK_WIDGET(mt->view[mt->selected]->toggle), FALSE ); gtk_image_clear( GTK_IMAGE(mt->view[mt->selected]->area ) ); mt->view[mt->selected]->status_lock = 0; } }
void gs_app_tile_set_app (GsAppTile *tile, GsApp *app) { GsAppTilePrivate *priv; const gchar *summary; g_return_if_fail (GS_IS_APP_TILE (tile)); g_return_if_fail (GS_IS_APP (app) || app == NULL); priv = gs_app_tile_get_instance_private (tile); gtk_image_clear (GTK_IMAGE (priv->image)); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), 64); if (priv->app) g_signal_handlers_disconnect_by_func (priv->app, app_state_changed, tile); g_clear_object (&priv->app); if (!app) return; priv->app = g_object_ref (app); if (gs_app_get_rating_kind (priv->app) == GS_APP_RATING_KIND_USER) { gs_star_widget_set_rating (GS_STAR_WIDGET (priv->stars), GS_APP_RATING_KIND_USER, gs_app_get_rating (priv->app)); } else { gs_star_widget_set_rating (GS_STAR_WIDGET (priv->stars), GS_APP_RATING_KIND_KUDOS, gs_app_get_kudos_percentage (priv->app)); } gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "content"); g_signal_connect (priv->app, "notify::state", G_CALLBACK (app_state_changed), tile); app_state_changed (priv->app, NULL, tile); gs_image_set_from_pixbuf (GTK_IMAGE (priv->image), gs_app_get_pixbuf (app)); gtk_label_set_label (GTK_LABEL (priv->name), gs_app_get_name (app)); summary = gs_app_get_summary (app); gtk_label_set_label (GTK_LABEL (priv->summary), summary); gtk_widget_set_visible (priv->summary, summary && summary[0]); }
static void gtkToggleSetPixbuf(Ihandle* ih, const char* name, int make_inactive, const char* attrib_name) { GtkButton* button = (GtkButton*)ih->handle; GtkImage* image = (GtkImage*)gtk_button_get_image(button); if (name) { GdkPixbuf* pixbuf = iupImageGetImage(name, ih, make_inactive, attrib_name); GdkPixbuf* old_pixbuf = gtk_image_get_pixbuf(image); if (pixbuf != old_pixbuf) gtk_image_set_from_pixbuf(image, pixbuf); return; } /* if not defined */ #if GTK_CHECK_VERSION(2, 8, 0) gtk_image_clear(image); #endif }
static void vwin_clear(void) { fp_img_free(img_normal); img_normal = NULL; fp_img_free(img_bin); img_bin = NULL; fp_print_data_free(enroll_data); enroll_data = NULL; gtk_image_clear(GTK_IMAGE(vwin_verify_img)); gtk_widget_set_sensitive(vwin_img_save_btn, FALSE); gtk_list_store_clear(GTK_LIST_STORE(vwin_fingmodel)); gtk_label_set_text(GTK_LABEL(vwin_vfy_status), NULL); gtk_label_set_text(GTK_LABEL(vwin_minutiae_cnt), NULL); gtk_widget_set_sensitive(vwin_fingcombo, FALSE); gtk_widget_set_sensitive(vwin_vfy_button, FALSE); }
static void view_state_changed (ChamplainView *view, GParamSpec *gobject, GtkImage *image) { ChamplainState state; if (destroying) return; g_object_get (G_OBJECT (view), "state", &state, NULL); if (state == CHAMPLAIN_STATE_LOADING) { gtk_image_set_from_icon_name (image, "edit-find", GTK_ICON_SIZE_BUTTON); } else { gtk_image_clear (image); } }
static void sequence_preview_cb(GtkWidget *widget, gpointer user_data) { sequence_view_t *v = (sequence_view_t*) user_data; multitracker_t *mt = v->backlink; int status = 0; if(v->status_lock) return; if(v->num != mt->master_track ) { status = (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget) ) == TRUE ? 1 : 0 ); gvr_track_toggle_preview( mt->preview, v->num,status ); sequence_preview_size( mt, v->num ); if( !status ) gtk_image_clear( GTK_IMAGE(v->area ) ); } }
static void on_update_img_preview( GtkFileChooser *chooser, GtkImage* img ) { char* file = gtk_file_chooser_get_preview_filename(chooser); GdkPixbuf* pix = NULL; if(file) { pix = gdk_pixbuf_new_from_file_at_scale( file, 128, 128, TRUE, NULL ); g_free( file ); } if(pix) { gtk_file_chooser_set_preview_widget_active(chooser, TRUE); gtk_image_set_from_pixbuf(img, pix); g_object_unref(pix); } else { gtk_image_clear(img); gtk_file_chooser_set_preview_widget_active(chooser, FALSE); } }
static void gtkButtonSetPixbuf(Ihandle* ih, const char* name, int make_inactive) { GtkImage* image; if (!iupAttribGet(ih, "_IUPGTK_EVENTBOX")) image = (GtkImage*)gtk_button_get_image((GtkButton*)ih->handle); else image = (GtkImage*)gtk_bin_get_child((GtkBin*)ih->handle); if (name && image) { GdkPixbuf* pixbuf = iupImageGetImage(name, ih, make_inactive); GdkPixbuf* old_pixbuf = gtk_image_get_pixbuf(image); if (pixbuf != old_pixbuf) gtk_image_set_from_pixbuf(image, pixbuf); return; } /* if not defined */ #if GTK_CHECK_VERSION(2, 8, 0) if (image) gtk_image_clear(image); #endif }
/** * 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 = tpaw_pixbuf_from_data ((gchar *) avatar->data, avatar->len); } if (!priv->pixbuf) { gtk_image_clear (GTK_IMAGE (priv->image)); return; } scaled_pixbuf = tpaw_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); }
// Updates the images according to preferences and the window situation // Warning! This function is called very often, so it should only do the most necessary things! void updateTitle(WTApplet *wtapplet) { WnckWindow *controlledwindow; gchar *title_text, *title_color, *title_font; GdkPixbuf *icon_pixbuf; if (wtapplet->prefs->only_maximized) { controlledwindow = wtapplet->umaxedwindow; } else { controlledwindow = wtapplet->activewindow; } if (controlledwindow == NULL) return; if (controlledwindow == wtapplet->rootwindow) { // we're on desktop if (wtapplet->prefs->hide_on_unmaximized) { // hide everything icon_pixbuf = NULL; title_text = ""; } else { // display "custom" icon/title (TODO: customization via preferences?) icon_pixbuf = gtk_widget_render_icon(GTK_WIDGET(wtapplet),GTK_STOCK_HOME,GTK_ICON_SIZE_MENU,NULL); // This has to be unrefed! title_text = ("Desktop"); } } else { icon_pixbuf = wnck_window_get_icon(controlledwindow); // This only returns a pointer - it SHOULDN'T be unrefed! title_text = (gchar*)wnck_window_get_name(controlledwindow); } // TODO: we need the default font to somehow be the same in both modes if (wtapplet->prefs->custom_style) { // custom style if (controlledwindow == wtapplet->activewindow) { // window focused title_color = wtapplet->prefs->title_active_color; title_font = wtapplet->prefs->title_active_font; } else { // window unfocused title_color = wtapplet->prefs->title_inactive_color; title_font = wtapplet->prefs->title_inactive_font; } } else { // automatic (non-custom) style if (controlledwindow == wtapplet->activewindow) { // window focused title_color = wtapplet->panel_color_fg; title_font = ""; } else { // window unfocused title_color = "#808080"; // inactive title color. best fits for any panel regardless of color title_font = ""; } } // Set tooltips if (wtapplet->prefs->show_tooltips) { gtk_widget_set_tooltip_text (GTK_WIDGET(wtapplet->icon), title_text); gtk_widget_set_tooltip_text (GTK_WIDGET(wtapplet->title), title_text); } title_text = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span>", title_font, title_color, title_text); // Apply markup to label widget gtk_label_set_markup(GTK_LABEL(wtapplet->title), title_text); g_free(title_text); if (icon_pixbuf == NULL) { gtk_image_clear(wtapplet->icon); } else { // We're updating window info (Careful! We've had pixbuf memory leaks here) GdkPixbuf *ipb1 = gdk_pixbuf_scale_simple(icon_pixbuf, ICON_WIDTH, ICON_HEIGHT, GDK_INTERP_BILINEAR); if (controlledwindow == wtapplet->rootwindow) g_object_unref(icon_pixbuf); //this is stupid beyond belief, thanks to the retarded GTK framework GdkPixbuf *ipb2 = gdk_pixbuf_rotate_simple(ipb1, wtapplet->angle); g_object_unref(ipb1); // Unref ipb1 to get it cleared from memory (we still need ipb2) // Saturate icon when window is not focused if (controlledwindow != wtapplet->activewindow) gdk_pixbuf_saturate_and_pixelate(ipb2, ipb2, 0, FALSE); // Apply pixbuf to icon widget gtk_image_set_from_pixbuf(wtapplet->icon, ipb2); g_object_unref(ipb2); // Unref ipb2 to get it cleared from memory } }
/** * gdaui_dsn_editor_set_dsn * @editor: a #GdauiDsnEditor widget * @dsn_info: (allow-none): a #GdaDsnInfo pointer or %NULL * * * Requests that @editor update its contents with @dsn_info's contents */ void gdaui_dsn_editor_set_dsn (GdauiDsnEditor *editor, const GdaDsnInfo *dsn_info) { g_return_if_fail (GDAUI_IS_DSN_EDITOR (editor)); editor->priv->no_change_signal = TRUE; if (dsn_info) { GdaProviderInfo *pinfo; pinfo = gda_config_get_provider_info (dsn_info->provider); GdkPixbuf *pix; pix = support_create_pixbuf_for_provider (pinfo); if (pix) { gtk_image_set_from_pixbuf (GTK_IMAGE (editor->priv->icon), pix); g_object_unref (pix); } else gtk_image_clear (GTK_IMAGE (editor->priv->icon)); if (pinfo) gtk_widget_hide (editor->priv->warning); else gtk_widget_show (editor->priv->warning); gchar *tmp; tmp = g_markup_printf_escaped ("<big><b>%s</b></big>", dsn_info->name); gtk_label_set_markup (GTK_LABEL (editor->priv->wname), tmp); g_free (tmp); g_free (editor->priv->name); editor->priv->name = g_strdup (dsn_info->name); gdaui_provider_selector_set_provider (GDAUI_PROVIDER_SELECTOR (editor->priv->wprovider), dsn_info->provider); _gdaui_provider_spec_editor_set_provider (GDAUI_PROVIDER_SPEC_EDITOR (editor->priv->dsn_spec), dsn_info->provider); _gdaui_provider_spec_editor_set_specs (GDAUI_PROVIDER_SPEC_EDITOR (editor->priv->dsn_spec), dsn_info->cnc_string); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (editor->priv->wdesc)), dsn_info->description ? dsn_info->description : "", -1); _gdaui_provider_auth_editor_set_provider (GDAUI_PROVIDER_AUTH_EDITOR (editor->priv->dsn_auth), dsn_info->provider); _gdaui_provider_auth_editor_set_auth (GDAUI_PROVIDER_AUTH_EDITOR (editor->priv->dsn_auth), dsn_info->auth_string); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->is_system), dsn_info->is_system); if (dsn_info->is_system && !gda_config_can_modify_system_config ()) { gtk_widget_set_sensitive (editor->priv->wprovider, FALSE); gtk_text_view_set_editable (GTK_TEXT_VIEW (editor->priv->wdesc), pinfo ? TRUE : FALSE); gtk_widget_set_sensitive (editor->priv->dsn_spec, FALSE); gtk_widget_set_sensitive (editor->priv->dsn_auth, FALSE); gtk_widget_set_sensitive (editor->priv->is_system, FALSE); } else { gtk_widget_set_sensitive (editor->priv->wprovider, pinfo ? TRUE : FALSE); gtk_text_view_set_editable (GTK_TEXT_VIEW (editor->priv->wdesc), pinfo ? TRUE : FALSE); gtk_widget_set_sensitive (editor->priv->dsn_spec, TRUE); gtk_widget_set_sensitive (editor->priv->dsn_auth, TRUE); gtk_widget_set_sensitive (editor->priv->is_system, pinfo && gda_config_can_modify_system_config () ? TRUE : FALSE); } } else { gtk_image_clear (GTK_IMAGE (editor->priv->icon)); gtk_label_set_text (GTK_LABEL (editor->priv->wname), ""); gdaui_provider_selector_set_provider (GDAUI_PROVIDER_SELECTOR (editor->priv->wprovider), NULL); _gdaui_provider_spec_editor_set_provider (GDAUI_PROVIDER_SPEC_EDITOR (editor->priv->dsn_spec), NULL); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (editor->priv->wdesc)), "", -1); _gdaui_provider_auth_editor_set_provider (GDAUI_PROVIDER_AUTH_EDITOR (editor->priv->dsn_auth), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->is_system), FALSE); gtk_widget_set_sensitive (editor->priv->wprovider, FALSE); gtk_text_view_set_editable (GTK_TEXT_VIEW (editor->priv->wdesc), FALSE); gtk_widget_set_sensitive (editor->priv->dsn_spec, FALSE); gtk_widget_set_sensitive (editor->priv->dsn_auth, FALSE); gtk_widget_set_sensitive (editor->priv->is_system, FALSE); } editor->priv->no_change_signal = FALSE; g_signal_emit (editor, gdaui_dsn_editor_signals[CHANGED], 0, NULL); }
gint play_iter(GtkTreeIter * playiter, gint restart_second) { gchar *subtitle = NULL; gchar *audiofile = NULL; GtkTreePath *path; gchar *uri = NULL; gint count; gint playlist; gchar *title = NULL; gchar *artist = NULL; gchar *album = NULL; gchar *audio_codec; gchar *video_codec = NULL; GtkAllocation alloc; gchar *demuxer = NULL; gboolean playable = TRUE; gint width; gint height; gfloat length_value; gint i; gpointer pixbuf; gchar *buffer = NULL; gchar *message = NULL; MetaData *metadata; #ifdef GTK2_12_ENABLED GtkRecentData *recent_data; #ifdef GIO_ENABLED GFile *file; GFileInfo *file_info; #endif #endif /* if (!(gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_UNKNOWN || gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_QUIT)) { while (gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) != MEDIA_STATE_UNKNOWN) { gtk_main_iteration(); } } */ if (gtk_list_store_iter_is_valid(playliststore, playiter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, ITEM_COLUMN, &uri, DESCRIPTION_COLUMN, &title, LENGTH_VALUE_COLUMN, &length_value, ARTIST_COLUMN, &artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN, &audio_codec, VIDEO_CODEC_COLUMN, &video_codec, VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height, DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf, SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1); if (GTK_IS_TREE_SELECTION(selection)) { path = gtk_tree_model_get_path(GTK_TREE_MODEL(playliststore), playiter); if (path) { gtk_tree_selection_select_path(selection, path); if (GTK_IS_WIDGET(list)) gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list), path, NULL, FALSE, 0, 0); buffer = gtk_tree_path_to_string(path); g_free(buffer); gtk_tree_path_free(path); } } gtk_list_store_set(playliststore, playiter, COUNT_COLUMN, count + 1, -1); } else { if (verbose > 1) printf("iter is invalid, nothing to play\n"); return 0; } if (verbose) { printf("playing - %s\n", uri); printf("is playlist %i\n", playlist); } gmtk_get_allocation(GTK_WIDGET(media), &alloc); if (width == 0 || height == 0) { alloc.width = 16; alloc.height = 16; } else { alloc.width = width; alloc.height = height; } //printf("setting window size to %i x %i\n", alloc.width, alloc.height); gtk_widget_size_allocate(GTK_WIDGET(media), &alloc); while (gtk_events_pending()) gtk_main_iteration(); /* // wait for metadata to be available on this item if (!streaming_media(uri) && !device_name(uri)) { i = 0; if (playable) { while (demuxer == NULL && i < 50) { g_free(title); g_free(artist); g_free(album); g_free(audio_codec); g_free(video_codec); g_free(demuxer); g_free(subtitle); g_free(audiofile); if (gtk_list_store_iter_is_valid(playliststore, playiter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, LENGTH_VALUE_COLUMN, &length_value, DESCRIPTION_COLUMN, &title, ARTIST_COLUMN, &artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN, &audio_codec, VIDEO_CODEC_COLUMN, &video_codec, VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height, DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf, SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1); if (!playable) { if (verbose) printf("%s is not marked as playable (%i)\n", uri, i); play_next(); return 0; } } else { if (verbose) printf("Current iter is not valid\n"); return 1; // error condition } gtk_main_iteration(); i++; if (demuxer == NULL) g_usleep(10000); } } else { if (verbose) printf("%s is not marked as playable\n", uri); play_next(); return 0; } } */ // reset audio meter for (i = 0; i < METER_BARS; i++) { buckets[i] = 0; max_buckets[i] = 0; } gmtk_media_tracker_set_text(tracker, _("Playing")); gmtk_media_tracker_set_position(tracker, (gfloat) restart_second); gmtk_media_tracker_set_length(tracker, length_value); message = g_strdup_printf("<small>\n"); if (title == NULL) { title = g_filename_display_basename(uri); } buffer = g_markup_printf_escaped("\t<big><b>%s</b></big>\n", title); message = g_strconcat(message, buffer, NULL); g_free(buffer); if (artist != NULL) { buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist); message = g_strconcat(message, buffer, NULL); g_free(buffer); } if (album != NULL) { buffer = g_markup_printf_escaped("\t%s\n", album); message = g_strconcat(message, buffer, NULL); g_free(buffer); } //buffer = g_markup_printf_escaped("\n\t%s\n", uri); //message = g_strconcat(message, buffer, NULL); //g_free(buffer); message = g_strconcat(message, "</small>", NULL); // probably not much cover art for random video files if (pixbuf == NULL && video_codec == NULL && !streaming_media(uri) && control_id == 0 && !playlist) { metadata = (MetaData *) g_new0(MetaData, 1); metadata->uri = g_strdup(uri); if (title != NULL) metadata->title = g_strstrip(g_strdup(title)); if (artist != NULL) metadata->artist = g_strstrip(g_strdup(artist)); if (album != NULL) metadata->album = g_strstrip(g_strdup(album)); g_thread_create(get_cover_art, metadata, FALSE, NULL); } else { gtk_image_clear(GTK_IMAGE(cover_art)); } g_strlcpy(idledata->media_info, message, 1024); g_strlcpy(idledata->display_name, title, 1024); g_free(message); message = gm_tempname(NULL, "mplayer-af_exportXXXXXX"); g_strlcpy(idledata->af_export, message, 1024); g_free(message); message = g_strdup(""); if (title == NULL) { title = g_filename_display_basename(uri); } //buffer = g_markup_printf_escaped("\t<b>%s</b>\n", title); //message = g_strconcat(message, buffer, NULL); //g_free(buffer); if (artist != NULL) { buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist); message = g_strconcat(message, buffer, NULL); g_free(buffer); } if (album != NULL) { buffer = g_markup_printf_escaped("\t%s\n", album); message = g_strconcat(message, buffer, NULL); g_free(buffer); } g_strlcpy(idledata->media_notification, message, 1024); g_free(message); if (control_id == 0) { set_media_label(idledata); } else { gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_info), FALSE); } if (subtitles) gtk_container_forall(GTK_CONTAINER(subtitles), remove_langs, NULL); gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_sub_lang), FALSE); if (tracks) gtk_container_forall(GTK_CONTAINER(tracks), remove_langs, NULL); gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_audio_lang), FALSE); lang_group = NULL; audio_group = NULL; if (subtitle != NULL) { gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_SUBTITLE_FILE, subtitle); g_free(subtitle); subtitle = NULL; } if (audiofile != NULL) { gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_AUDIO_TRACK_FILE, audiofile); g_free(audiofile); audiofile = NULL; } /* if (g_ascii_strcasecmp(thread_data->filename, "") != 0) { if (!device_name(thread_data->filename) && !streaming_media(thread_data->filename)) { if (!g_file_test(thread_data->filename, G_FILE_TEST_EXISTS)) { error_msg = g_strdup_printf("%s not found\n", thread_data->filename); dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", error_msg); gtk_window_set_title(GTK_WINDOW(dialog), "GNOME MPlayer Error"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); return 1; } } } */ #ifdef GTK2_12_ENABLED #ifdef GIO_ENABLED // don't put it on the recent list, if it is running in plugin mode if (control_id == 0 && !streaming_media(uri)) { recent_data = (GtkRecentData *) g_new0(GtkRecentData, 1); if (artist != NULL && strlen(artist) > 0) { recent_data->display_name = g_strdup_printf("%s - %s", artist, title); } else { recent_data->display_name = g_strdup(title); } g_strlcpy(idledata->display_name, recent_data->display_name, 1024); file = g_file_new_for_uri(uri); file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (file_info) { recent_data->mime_type = g_strdup(g_file_info_get_content_type(file_info)); g_object_unref(file_info); } g_object_unref(file); recent_data->app_name = g_strdup("gnome-mplayer"); recent_data->app_exec = g_strdup("gnome-mplayer %u"); if (recent_data->mime_type != NULL) { gtk_recent_manager_add_full(recent_manager, uri, recent_data); g_free(recent_data->mime_type); } g_free(recent_data->app_name); g_free(recent_data->app_exec); g_free(recent_data); } #endif #endif g_free(title); g_free(artist); g_free(album); if (demuxer != NULL) { g_strlcpy(idledata->demuxer, demuxer, 64); g_free(demuxer); } else { g_strlcpy(idledata->demuxer, "", 64); } last_x = 0; last_y = 0; idledata->width = width; idledata->height = height; idledata->retry_on_full_cache = FALSE; idledata->cachepercent = -1.0; g_strlcpy(idledata->info, uri, 1024); set_media_info(idledata); streaming = 0; gm_store = gm_pref_store_new("gnome-mplayer"); forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE); gm_pref_store_free(gm_store); if (g_ascii_strcasecmp(uri, "dvdnav://") == 0) { gtk_widget_show(menu_event_box); } else { gtk_widget_hide(menu_event_box); } if (autostart) { g_idle_add(hide_buttons, idledata); js_state = STATE_PLAYING; if (g_str_has_prefix(uri, "mmshttp") || g_str_has_prefix(uri, "http") || g_str_has_prefix(uri, "mms")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK); } else if (g_str_has_prefix(uri, "dvd") || g_str_has_prefix(uri, "dvdnav")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD); } else if (g_str_has_prefix(uri, "cdda")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD); } else if (g_str_has_prefix(uri, "cddb")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD); } else if (g_str_has_prefix(uri, "vcd")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_VCD); } else if (g_str_has_prefix(uri, "tv")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_TV); } else if (g_str_has_prefix(uri, "dvb")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVB); } else if (g_str_has_prefix(uri, "file")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_FILE); } else { // if all else fails it must be a network type gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK); } gmtk_media_player_set_attribute_boolean(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_PLAYLIST, playlist); gmtk_media_player_set_uri(GMTK_MEDIA_PLAYER(media), uri); gmtk_media_player_set_state(GMTK_MEDIA_PLAYER(media), MEDIA_STATE_PLAY); } return 0; }