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;
}
