static void
event_box_realize_cb (GtkWidget *widget, GtkImage *icon)
{
GtkImageType type;
set_drag_cursor (widget);
type = gtk_image_get_storage_type (icon);
if (type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
GdkPixbuf *pixbuf;
gtk_image_get_stock (icon, &stock_id, NULL);
pixbuf = gtk_widget_render_icon (widget, stock_id,
GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else if (type == GTK_IMAGE_ICON_NAME)
{
const gchar *icon_name;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
gint width, height;
GdkPixbuf *pixbuf;
gtk_image_get_icon_name (icon, &icon_name, NULL);
screen = gtk_widget_get_screen (widget);
icon_theme = gtk_icon_theme_get_for_screen (screen);
settings = gtk_settings_get_for_screen (screen);
if (!gtk_icon_size_lookup_for_settings (settings,
GTK_ICON_SIZE_LARGE_TOOLBAR,
&width, &height))
{
width = height = 24;
}
pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name,
MIN (width, height), 0, NULL);
if (G_UNLIKELY (!pixbuf))
return;
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else if (type == GTK_IMAGE_PIXBUF)
{
GdkPixbuf *pixbuf = gtk_image_get_pixbuf (icon);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
}
}
void
panel_launcher_set_dnd_enabled (Launcher *launcher,
gboolean dnd_enabled)
{
GdkPixbuf *pixbuf;
if (dnd_enabled) {
static GtkTargetEntry dnd_targets[] = {
{ (gchar *) "application/x-panel-icon-internal", 0, TARGET_ICON_INTERNAL },
{ (gchar *) "text/uri-list", 0, TARGET_URI_LIST }
};
gtk_widget_set_has_window (launcher->button, TRUE);
gtk_drag_source_set (launcher->button,
GDK_BUTTON1_MASK,
dnd_targets, 2,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
//FIXME: this doesn't work since the pixbuf isn't loaded yet
pixbuf = button_widget_get_pixbuf (BUTTON_WIDGET (launcher->button));
if (pixbuf) {
gtk_drag_source_set_icon_pixbuf (launcher->button,
pixbuf);
g_object_unref (pixbuf);
}
gtk_widget_set_has_window (launcher->button, FALSE);
} else
gtk_drag_source_unset (launcher->button);
}
static void _drag_begin (GtkWidget *pWidget, GdkDragContext *pDragContext, GtkWidget *pMenuItem)
{
// add an icon: the current pixbuf (add it now, once and for all).
if (GLDI_IS_IMAGE_MENU_ITEM (pMenuItem)) // some items don't have any icon.
{
gtk_drag_source_set_icon_pixbuf (pMenuItem,
gtk_image_get_pixbuf (GTK_IMAGE (gldi_menu_item_get_image (pMenuItem)))); // GTK+ retains a reference on the pixbuf; when pMenuItem disappear, it will naturally loose this reference.
}
}
/**
* called when we begin a drag,
* find what cell was under the cursor and change it
*
* \param tree_view
* \param drag_context
* \param null
*
* \return FALSE
* */
gboolean gsb_form_config_drag_begin ( GtkWidget *tree_view,
GdkDragContext *drag_context,
gpointer null )
{
gint x, y;
GtkTreePath *path;
GtkTreeViewColumn *tree_column;
GdkWindow *drawable;
GdkRectangle rectangle;
GdkPixbuf *pixbuf_cursor;
/* get the cell coord */
gdk_window_get_pointer ( gtk_tree_view_get_bin_window ( GTK_TREE_VIEW ( tree_view )),
&x,
&y,
FALSE );
gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW ( tree_view ),
x,
y,
&path,
&tree_column,
NULL, NULL );
if ( !path
||
!tree_column )
return FALSE;
start_drag_column = g_list_index ( gtk_tree_view_get_columns ( GTK_TREE_VIEW ( tree_view )),
tree_column );
start_drag_row = utils_str_atoi ( gtk_tree_path_to_string ( path ));
/* draw the new cursor */
drawable = gtk_tree_view_get_bin_window (GTK_TREE_VIEW ( tree_view ));
gtk_tree_view_get_cell_area ( GTK_TREE_VIEW ( tree_view ),
path,
tree_column,
&rectangle );
pixbuf_cursor = gdk_pixbuf_get_from_drawable ( NULL,
GDK_DRAWABLE (drawable),
gdk_colormap_get_system (),
rectangle.x, rectangle.y,
0, 0,
rectangle.width, rectangle.height );
gtk_drag_source_set_icon_pixbuf ( tree_view,
pixbuf_cursor );
g_object_unref (pixbuf_cursor);
return FALSE;
}
static void
panel_run_dialog_set_icon (PanelRunDialog *dialog,
GIcon *icon,
gboolean force)
{
GdkPixbuf *pixbuf = NULL;
if (!force && g_icon_equal(icon, dialog->icon))
return;
g_clear_object(&(dialog->icon));
if (icon) {
int size;
gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &size, NULL);
GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
GtkIconInfo *icon_info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);
pixbuf = gtk_icon_info_load_icon (icon_info, NULL);
#if GTK_CHECK_VERSION (3, 8, 0)
g_object_unref (icon_info);
#else
gtk_icon_info_free (icon_info);
#endif
}
if (pixbuf) {
dialog->icon = g_object_ref (icon);
/* Don't bother scaling the image if it's too small.
* Scaled looks worse than a smaller image.
*/
gtk_image_set_from_pixbuf (GTK_IMAGE (dialog->pixmap), pixbuf);
//FIXME: it'd be better to set an icon of the correct size,
//(ditto for the drag icon?)
gtk_window_set_icon (GTK_WINDOW (dialog->run_dialog), pixbuf);
#if GTK_CHECK_VERSION (3, 2, 0)
gtk_drag_source_set_icon_gicon (dialog->run_dialog, dialog->icon);
#else
gtk_drag_source_set_icon_pixbuf (dialog->run_dialog, pixbuf);
#endif
g_object_unref (pixbuf);
} else {
panel_run_dialog_set_default_icon (dialog, TRUE);
}
}
static void
event_box_realize_cb (GtkWidget *widget, GtkImage *icon)
{
GtkImageType type;
set_drag_cursor (widget);
type = gtk_image_get_storage_type (icon);
if (type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
GdkPixbuf *pixbuf;
gtk_image_get_stock (icon, &stock_id, NULL);
pixbuf = gtk_widget_render_icon (widget, stock_id,
GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else if (type == GTK_IMAGE_PIXBUF)
{
GdkPixbuf *pixbuf = gtk_image_get_pixbuf (icon);
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
}
}
int
clip_GTK_DRAGSOURCESETICONPIXBUF(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
C_object *cpixbuf = _fetch_cobject(cm, _clip_spar(cm, 2));
CHECKCWID(cwid, GTK_IS_WIDGET);
CHECKCOBJ(cpixbuf, GDK_IS_PIXBUF(cpixbuf->object));
gtk_drag_source_set_icon_pixbuf(GTK_WIDGET(cwid->widget),
GDK_PIXBUF(cpixbuf->object));
return 0;
err:
return 1;
}
static VALUE
rg_m_source_set_icon(int argc, VALUE *argv, VALUE self)
{
VALUE widget, obj, pixmap = Qnil, mask = Qnil;
rb_scan_args(argc, argv, "22", &widget, &obj, &pixmap, &mask);
if (argc == 4){
gtk_drag_source_set_icon(RVAL2WIDGET(widget), GDK_COLORMAP(RVAL2GOBJ(obj)),
GDK_PIXMAP(RVAL2GOBJ(pixmap)),
GDK_BITMAP(RVAL2GOBJ(mask)));
} else if (argc == 2){
if (TYPE(obj) == T_SYMBOL){
gtk_drag_source_set_icon_stock(RVAL2WIDGET(widget), rb_id2name(SYM2ID(obj)));
} else {
gtk_drag_source_set_icon_pixbuf(RVAL2WIDGET(widget), GDK_PIXBUF(RVAL2GOBJ(obj)));
}
} else {
rb_raise(rb_eArgError, "need 2 or 4 arguments");
}
return self;
}
void
cairo_menu_item_set_source (CairoMenuItem *item, gchar * drag_data)
{
CairoMenuItemPrivate * priv = GET_PRIVATE(item);
GtkWidget * image;
if (priv->drag_source_data)
{
g_free(priv->drag_source_data);
priv->drag_source_data = NULL;
}
g_object_get (item,
"image",&image,
NULL);
priv->drag_source_data = g_strdup (drag_data);
gtk_drag_source_set (GTK_WIDGET(item),GDK_BUTTON1_MASK,drop_types,3,GDK_ACTION_COPY);
if (image)
{
if ( gtk_image_get_storage_type (GTK_IMAGE(image))==GTK_IMAGE_PIXBUF)
{
GdkPixbuf * pbuf = gtk_image_get_pixbuf (GTK_IMAGE(image));
if (pbuf)
{
gtk_drag_source_set_icon_pixbuf (GTK_WIDGET(item),pbuf);
}
}
else if (gtk_image_get_storage_type (GTK_IMAGE(image))==GTK_IMAGE_ICON_NAME)
{
gchar * icon_name;
g_object_get (image,
"icon_name",&icon_name,
NULL);
gtk_drag_source_set_icon_name (GTK_WIDGET(item),icon_name);
g_free (icon_name);
}
}
g_signal_connect (item,"drag-data-get",G_CALLBACK(_get_data),NULL);
}
static void
event_box_realize (GtkWidget *widget,
GtkImage *image)
{
GtkImageType type;
GdkPixbuf *pixbuf;
const gchar *icon_name;
_exo_toolbars_set_drag_cursor (widget);
type = gtk_image_get_storage_type (image);
if (type == GTK_IMAGE_ICON_NAME)
{
gtk_image_get_icon_name (image, &icon_name, NULL);
if (icon_name != NULL)
gtk_drag_source_set_icon_name (widget, icon_name);
}
else if (type == GTK_IMAGE_PIXBUF)
{
pixbuf = gtk_image_get_pixbuf (image);
if (G_LIKELY (pixbuf != NULL))
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
}
}
static void
configure_item_cursor (GtkToolItem *item,
EggEditableToolbar *etoolbar)
{
EggEditableToolbarPrivate *priv = etoolbar->priv;
GtkWidget *widget = GTK_WIDGET (item);
if (gtk_widget_get_window (widget) != NULL)
{
if (priv->edit_mode > 0)
{
GdkCursor *cursor;
GdkScreen *screen;
GdkPixbuf *pixbuf = NULL;
screen = gtk_widget_get_screen (GTK_WIDGET (etoolbar));
cursor = gdk_cursor_new_for_display (gdk_screen_get_display (screen),
GDK_HAND2);
gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
gdk_cursor_unref (cursor);
gtk_drag_source_set (widget, GDK_BUTTON1_MASK, dest_drag_types,
G_N_ELEMENTS (dest_drag_types), GDK_ACTION_MOVE);
if (GTK_IS_SEPARATOR_TOOL_ITEM (item))
{
pixbuf = new_separator_pixbuf ();
}
else
{
char *icon_name=NULL;
char *stock_id=NULL;
GtkAction *action;
char *name;
name = g_object_get_data (G_OBJECT (widget), EGG_ITEM_NAME);
action = name ? find_action (etoolbar, name) : NULL;
if (action)
{
g_object_get (action,
"icon-name", &icon_name,
"stock-id", &stock_id,
NULL);
}
if (icon_name)
{
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
gint width, height;
screen = gtk_widget_get_screen (widget);
icon_theme = gtk_icon_theme_get_for_screen (screen);
settings = gtk_settings_get_for_screen (screen);
if (!gtk_icon_size_lookup_for_settings (settings,
GTK_ICON_SIZE_LARGE_TOOLBAR,
&width, &height))
{
width = height = 24;
}
pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name,
MIN (width, height), 0, NULL);
}
else if (stock_id)
{
pixbuf = gtk_widget_render_icon (widget, stock_id,
GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
}
g_free (icon_name);
g_free (stock_id);
}
if (G_UNLIKELY (!pixbuf))
{
return;
}
gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
g_object_unref (pixbuf);
}
else
{
gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET(item)), NULL);
}
}
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *label;
GtkWidget *pixmap;
GtkWidget *button;
GdkPixbuf *drag_icon;
test_init ();
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
table = gtk_table_new (2, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
drag_icon = gdk_pixbuf_new_from_xpm_data (drag_icon_xpm);
trashcan_open = gdk_pixbuf_new_from_xpm_data (trashcan_open_xpm);
trashcan_closed = gdk_pixbuf_new_from_xpm_data (trashcan_closed_xpm);
label = gtk_label_new ("Drop Here\n");
gtk_drag_dest_set (label,
GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1, /* no rootwin */
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (label, "drag_data_received",
G_CALLBACK( label_drag_data_received), NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
label = gtk_label_new ("Popup\n");
gtk_drag_dest_set (label,
GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1, /* no rootwin */
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (label, "drag_motion",
G_CALLBACK (popsite_motion), NULL);
g_signal_connect (label, "drag_leave",
G_CALLBACK (popsite_leave), NULL);
pixmap = gtk_image_new_from_pixbuf (trashcan_closed);
gtk_drag_dest_set (pixmap, 0, NULL, 0, 0);
gtk_table_attach (GTK_TABLE (table), pixmap, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (pixmap, "drag_leave",
G_CALLBACK (target_drag_leave), NULL);
g_signal_connect (pixmap, "drag_motion",
G_CALLBACK (target_drag_motion), NULL);
g_signal_connect (pixmap, "drag_drop",
G_CALLBACK (target_drag_drop), NULL);
g_signal_connect (pixmap, "drag_data_received",
G_CALLBACK (target_drag_data_received), NULL);
/* Drag site */
button = gtk_button_new_with_label ("Drag Here\n");
gtk_drag_source_set (button, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
target_table, n_targets,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_set_icon_pixbuf (button, drag_icon);
g_object_unref (drag_icon);
gtk_table_attach (GTK_TABLE (table), button, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (button, "drag_data_get",
G_CALLBACK (source_drag_data_get), NULL);
g_signal_connect (button, "drag_data_delete",
G_CALLBACK (source_drag_data_delete), NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void
create_music_browser(void) {
GtkWidget * vbox;
GtkWidget * hbox;
GtkWidget * viewport1;
GtkWidget * viewport2;
GtkWidget * scrolled_win1;
GtkWidget * scrolled_win2;
GtkWidget * statusbar_viewport;
GtkWidget * statusbar_scrolledwin;
GtkWidget * statusbar_hbox;
GtkWidget * toolbar_search_button;
GtkWidget * toolbar_collapse_all_button;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GdkPixbuf * pixbuf;
char path[MAXLEN];
GtkTargetEntry target_table[] = {
{ "aqualung-browser-list", GTK_TARGET_SAME_APP, 1 }
};
/* window creating stuff */
browser_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(browser_window), _("Music Store"));
g_signal_connect(G_OBJECT(browser_window), "delete_event", G_CALLBACK(browser_window_close), NULL);
g_signal_connect(G_OBJECT(browser_window), "key_press_event",
G_CALLBACK(browser_window_key_pressed), NULL);
gtk_container_set_border_width(GTK_CONTAINER(browser_window), 2);
gtk_widget_set_size_request(browser_window, 200, 300);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(browser_window), vbox);
if (options.enable_mstore_toolbar) {
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3);
toolbar_search_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_FIND);
gtk_widget_set_can_focus(toolbar_search_button, FALSE);
g_signal_connect(G_OBJECT(toolbar_search_button), "clicked", G_CALLBACK(toolbar__search_cb), NULL);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_search_button, FALSE, TRUE, 3);
aqualung_widget_set_tooltip_text(toolbar_search_button, _("Search..."));
toolbar_collapse_all_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_REFRESH);
gtk_widget_set_can_focus(toolbar_collapse_all_button, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_collapse_all_button, FALSE, TRUE, 3);
g_signal_connect(G_OBJECT(toolbar_collapse_all_button), "pressed", G_CALLBACK(toolbar__collapse_cb), NULL);
aqualung_widget_set_tooltip_text(toolbar_collapse_all_button, _("Collapse all items"));
toolbar_edit_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_EDIT);
gtk_widget_set_can_focus(toolbar_edit_button, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_edit_button, FALSE, TRUE, 3);
g_signal_connect(G_OBJECT(toolbar_edit_button), "pressed", G_CALLBACK(toolbar__edit_cb), NULL);
aqualung_widget_set_tooltip_text(toolbar_edit_button, _("Edit item..."));
toolbar_add_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_ADD);
gtk_widget_set_can_focus(toolbar_add_button, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_add_button, FALSE, TRUE, 3);
g_signal_connect(G_OBJECT(toolbar_add_button), "pressed", G_CALLBACK(toolbar__add_cb), NULL);
aqualung_widget_set_tooltip_text(toolbar_add_button, _("Add item..."));
toolbar_remove_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_REMOVE);
gtk_widget_set_can_focus(toolbar_remove_button, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_remove_button, FALSE, TRUE, 3);
g_signal_connect(G_OBJECT(toolbar_remove_button), "pressed", G_CALLBACK(toolbar__remove_cb), NULL);
aqualung_widget_set_tooltip_text(toolbar_remove_button, _("Remove item..."));
toolbar_save_button = gui_stock_label_button((gchar *)-1, GTK_STOCK_SAVE);
gtk_widget_set_can_focus(toolbar_save_button, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), toolbar_save_button, FALSE, TRUE, 3);
g_signal_connect(G_OBJECT(toolbar_save_button), "pressed", G_CALLBACK(toolbar__save_cb), NULL);
gtk_widget_set_sensitive(toolbar_save_button, FALSE);
aqualung_widget_set_tooltip_text(toolbar_save_button, _("Save all stores"));
}
if (!options.hide_comment_pane) {
browser_paned = gtk_vpaned_new();
gtk_box_pack_start(GTK_BOX(vbox), browser_paned, TRUE, TRUE, 0);
}
/* load tree icons */
if (options.enable_ms_tree_icons) {
sprintf(path, "%s/%s", AQUALUNG_DATADIR, "ms-store.png");
icon_store = gdk_pixbuf_new_from_file (path, NULL);
store_file_load_icons();
#ifdef HAVE_CDDA
store_cdda_load_icons();
#endif /* HAVE_CDDA */
#ifdef HAVE_PODCAST
store_podcast_load_icons();
#endif /* HAVE_PODCAST */
}
/* create music store tree */
if (!music_store) {
music_store = gtk_tree_store_new(MS_COL_COUNT,
G_TYPE_STRING, /* visible name */
G_TYPE_STRING, /* string to sort by */
G_TYPE_INT, /* font weight */
GDK_TYPE_PIXBUF, /* icon */
G_TYPE_POINTER); /* data */
}
music_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(music_store));
gtk_widget_set_name(music_tree, "music_tree");
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(music_tree), FALSE);
g_signal_connect(G_OBJECT(music_tree), "event", G_CALLBACK(music_tree_event_cb), NULL);
if (options.enable_ms_rules_hint) {
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(music_tree), TRUE);
}
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "name");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", MS_COL_ICON);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", MS_COL_NAME);
gtk_tree_view_column_add_attribute(column, renderer, "weight", MS_COL_FONT);
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(music_tree), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(music_tree), FALSE);
viewport1 = gtk_viewport_new(NULL, NULL);
if (!options.hide_comment_pane) {
gtk_paned_pack1(GTK_PANED(browser_paned), viewport1, TRUE, TRUE);
} else {
gtk_box_pack_start(GTK_BOX(vbox), viewport1, TRUE, TRUE, 0);
}
scrolled_win1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrolled_win1, -1, 1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(viewport1), scrolled_win1);
gtk_container_add(GTK_CONTAINER(scrolled_win1), music_tree);
music_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(music_tree));
gtk_tree_selection_set_mode(music_select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(music_select), "changed", G_CALLBACK(tree_selection_changed_cb), NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(music_store), MS_COL_SORT, GTK_SORT_ASCENDING);
music_tree_expand_stores();
/* setup drag and drop */
gtk_drag_source_set(music_tree,
GDK_BUTTON1_MASK,
target_table,
sizeof(target_table) / sizeof(GtkTargetEntry),
GDK_ACTION_COPY);
snprintf(path, MAXLEN-1, "%s/drag.png", AQUALUNG_DATADIR);
if ((pixbuf = gdk_pixbuf_new_from_file(path, NULL)) != NULL) {
gtk_drag_source_set_icon_pixbuf(music_tree, pixbuf);
}
g_signal_connect(G_OBJECT(music_tree), "drag_data_get", G_CALLBACK(browser_drag_data_get), NULL);
g_signal_connect(G_OBJECT(music_tree), "drag_end", G_CALLBACK(browser_drag_end), NULL);
/* create popup menu for blank space */
blank_menu = gtk_menu_new();
register_toplevel_window(blank_menu, TOP_WIN_SKIN);
blank__add = gtk_menu_item_new_with_label(_("Create empty store..."));
blank__search = gtk_menu_item_new_with_label(_("Search..."));
blank__save = gtk_menu_item_new_with_label(_("Save all stores"));
gtk_menu_shell_append(GTK_MENU_SHELL(blank_menu), blank__add);
gtk_menu_shell_append(GTK_MENU_SHELL(blank_menu), blank__search);
gtk_menu_shell_append(GTK_MENU_SHELL(blank_menu), blank__save);
g_signal_connect_swapped(G_OBJECT(blank__add), "activate", G_CALLBACK(store__add_cb), NULL);
g_signal_connect_swapped(G_OBJECT(blank__search), "activate", G_CALLBACK(toolbar__search_cb), NULL);
g_signal_connect_swapped(G_OBJECT(blank__save), "activate", G_CALLBACK(toolbar__save_cb), NULL);
gtk_widget_show(blank__add);
gtk_widget_show(blank__search);
gtk_widget_show(blank__save);
store_file_create_popup_menu();
#ifdef HAVE_CDDA
store_cdda_create_popup_menu();
#endif /* HAVE_CDDA */
#ifdef HAVE_PODCAST
store_podcast_create_popup_menu();
#endif /* HAVE_PODCAST */
/* create text widget for comments */
comment_view = gtk_text_view_new();
gtk_widget_set_name(comment_view, "comment_view");
gtk_text_view_set_editable(GTK_TEXT_VIEW(comment_view), FALSE);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(comment_view), 3);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(comment_view), 3);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(comment_view), 3);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(comment_view), GTK_WRAP_WORD);
scrolled_win2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrolled_win2, -1, 1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win2),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new(NULL, NULL);
if (!options.hide_comment_pane) {
gtk_paned_pack2(GTK_PANED(browser_paned), viewport2, FALSE, TRUE);
}
gtk_container_add(GTK_CONTAINER(viewport2), scrolled_win2);
gtk_container_add(GTK_CONTAINER(scrolled_win2), comment_view);
if (!options.hide_comment_pane) {
gtk_paned_set_position(GTK_PANED(browser_paned), options.browser_paned_pos);
}
store_file_insert_progress_bar(vbox);
if (options.enable_mstore_statusbar) {
statusbar_scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(statusbar_scrolledwin, 1, -1); /* MAGIC */
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statusbar_scrolledwin),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
statusbar_viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_set_name(statusbar_viewport, "info_viewport");
gtk_container_add(GTK_CONTAINER(statusbar_scrolledwin), statusbar_viewport);
gtk_box_pack_start(GTK_BOX(vbox), statusbar_scrolledwin, FALSE, TRUE, 2);
gtk_widget_set_events(statusbar_viewport,
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK);
g_signal_connect(G_OBJECT(statusbar_viewport), "button_press_event",
G_CALLBACK(scroll_btn_pressed), NULL);
g_signal_connect(G_OBJECT(statusbar_viewport), "button_release_event",
G_CALLBACK(scroll_btn_released), (gpointer)statusbar_scrolledwin);
g_signal_connect(G_OBJECT(statusbar_viewport), "motion_notify_event",
G_CALLBACK(scroll_motion_notify), (gpointer)statusbar_scrolledwin);
statusbar_hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(statusbar_hbox), 1);
gtk_container_add(GTK_CONTAINER(statusbar_viewport), statusbar_hbox);
statusbar_ms = gtk_label_new("");
gtk_widget_set_name(statusbar_ms, "label_info");
gtk_box_pack_end(GTK_BOX(statusbar_hbox), statusbar_ms, FALSE, FALSE, 0);
}
music_browser_set_font(options.override_skin_settings);
}
static GtkWidget *
create_emblem_widget_with_pixbuf (CajaEmblemSidebar *emblem_sidebar,
const char *keyword,
const char *display_name,
GdkPixbuf *pixbuf)
{
GtkWidget *image, *event_box;
GdkPixbuf *prelight_pixbuf;
image = eel_labeled_image_new (display_name, pixbuf);
eel_labeled_image_set_fixed_image_height (EEL_LABELED_IMAGE (image),
STANDARD_EMBLEM_HEIGHT);
eel_labeled_image_set_spacing (EEL_LABELED_IMAGE (image),
EMBLEM_LABEL_SPACING);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), image);
prelight_pixbuf = eel_create_spotlight_pixbuf (pixbuf);
gtk_drag_source_set (event_box, GDK_BUTTON1_MASK, drag_types,
G_N_ELEMENTS (drag_types),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_set_icon_pixbuf (event_box, pixbuf);
g_signal_connect (event_box, "button_press_event",
G_CALLBACK (caja_emblem_sidebar_button_press_cb),
emblem_sidebar);
g_signal_connect (event_box, "drag-data-get",
G_CALLBACK (caja_emblem_sidebar_drag_data_get_cb),
emblem_sidebar);
g_signal_connect (event_box, "enter-notify-event",
G_CALLBACK (caja_emblem_sidebar_enter_notify_cb),
emblem_sidebar);
g_signal_connect (event_box, "leave-notify-event",
G_CALLBACK (caja_emblem_sidebar_leave_notify_cb),
emblem_sidebar);
g_object_set_data_full (G_OBJECT (event_box),
"emblem-keyword",
g_strdup (keyword), g_free);
g_object_set_data_full (G_OBJECT (event_box),
"emblem-display-name",
g_strdup (display_name), g_free);
g_object_set_data_full (G_OBJECT (event_box),
"original-pixbuf",
pixbuf, g_object_unref);
g_object_set_data_full (G_OBJECT (event_box),
"prelight-pixbuf",
prelight_pixbuf, g_object_unref);
g_object_set_data (G_OBJECT (event_box),
"labeled-image", image);
return event_box;
}
