bool wxNotebook::SetPageImage( size_t page, int image )
{
/* HvdH 28-12-98: now it works, but it's a bit of a kludge */
wxGtkNotebookPage* nb_page = GetNotebookPage(page);
if (!nb_page) return false;
/* Optimization posibility: return immediately if image unchanged.
* Not enabled because it may break existing (stupid) code that
* manipulates the imagelist to cycle images */
/* if (image == nb_page->m_image) return true; */
/* For different cases:
1) no image -> no image
2) image -> no image
3) no image -> image
4) image -> image */
if (image == -1 && nb_page->m_image == -1)
return true; /* Case 1): Nothing to do. */
GtkWidget *pixmapwid = (GtkWidget*) NULL;
if (nb_page->m_image != -1)
{
/* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */
GList *child = gtk_container_get_children(GTK_CONTAINER(nb_page->m_box));
while (child)
{
if (GTK_IS_IMAGE(child->data))
{
pixmapwid = GTK_WIDGET(child->data);
break;
}
child = child->next;
}
/* We should have the pixmap widget now */
wxASSERT(pixmapwid != NULL);
if (image == -1)
{
/* If there's no new widget, just remove the old from the box */
gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
nb_page->m_image = -1;
return true; /* Case 2) */
}
}
/* Only cases 3) and 4) left */
wxASSERT( m_imageList != NULL ); /* Just in case */
/* Construct the new pixmap */
const wxBitmap *bmp = m_imageList->GetBitmapPtr(image);
if (pixmapwid == NULL)
{
/* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
pixmapwid = gtk_image_new_from_pixbuf(bmp->GetPixbuf());
/* CHECKME: Are these pack flags okay? */
gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
gtk_widget_show(pixmapwid);
}
else
{
/* Case 4) Simply replace the pixmap */
gtk_image_set_from_pixbuf((GtkImage*)pixmapwid, bmp->GetPixbuf());
}
nb_page->m_image = image;
return true;
}
static void messageview_show_cb(GObject *obj, gpointer msgview,
MsgInfo *msginfo, gboolean all_headers)
{
MessageView *messageview;
HeaderView *headerview;
GtkWidget *hbox;
gchar *msg_path;
GtkWidget *copy_btn;
GdkPixbuf* pbuf;
GtkWidget* image;
GtkTooltips *tip;
GList* wl;
gint i;
gboolean bfound = FALSE;
gpointer gdata;
#if DEBUG
g_print("[DEBUG] test: %p: messageview_show (%p), all_headers: %d: %s\n",
obj, msgview, all_headers,
msginfo && msginfo->subject ? msginfo->subject : "");
#endif
if (!msgview) {
g_print("[DEBUG] msgview is NULL\n");
return;
}
messageview = (MessageView*)msgview;
if (!messageview) {
g_print("[DEBUG] messageview is NULL\n");
return;
}
headerview = messageview->headerview;
if (!headerview) {
g_print("[DEBUG] headerview is NULL\n");
return;
}
hbox = headerview->hbox;
if (!hbox) {
g_print("[DEBUG] hbox is NULL\n");
return;
}
wl = gtk_container_get_children(GTK_CONTAINER(hbox));
i = g_list_length(wl)-1;
/* search recently added GtkImage */
while (i >= 0) {
gdata = g_list_nth_data(wl, i);
if (GTK_IS_BUTTON(gdata) && gdata != headerview->image) {
/* remove from hbox */
g_print("[DEBUG] GTK_IS_BUTTON %p\n", gdata);
#if DEBUG
g_print("[DEBUG] remove button: %p\n", gicon);
#endif
gtk_container_remove(GTK_CONTAINER(hbox), GTK_WIDGET(gdata));
}
i--;
}
msg_path = procmsg_get_message_file_path(msginfo);
debug_print("[DEBUG] msg_path:%s\n", msg_path);
if (bfound != TRUE){
copy_btn = gtk_button_new_from_stock(GTK_STOCK_FILE);
gtk_box_pack_end(GTK_BOX(hbox), copy_btn, FALSE, FALSE, 0);
pbuf = gdk_pixbuf_new_from_xpm_data((const char**)page_save);
image = gtk_image_new_from_pixbuf(pbuf);
gtk_button_set_image(GTK_BUTTON(copy_btn), image);
gtk_button_set_label(GTK_BUTTON(copy_btn), "");
tip = gtk_tooltips_new();
gtk_tooltips_set_tip(tip, copy_btn, _("Copy this mail to clipboard."), NULL);
g_signal_connect(G_OBJECT(copy_btn), "clicked",
G_CALLBACK(copy_btn_clicked), msginfo);
gtk_widget_show(image);
gtk_widget_show_all(copy_btn);
debug_print("[DEBUG] copy mail to clipboard icon: %p\n", copy_btn);
}
}
static gboolean
load_dialog (const gchar *filename)
{
GtkWidget *dialog;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GdkPixbuf *preview;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *abox;
GtkWidget *res;
GtkWidget *label;
GtkWidget *spinbutton;
GtkWidget *toggle;
GtkWidget *toggle2;
GtkObject *adj;
gboolean run;
GError *error = NULL;
SvgLoadVals vals =
{
SVG_DEFAULT_RESOLUTION,
- SVG_PREVIEW_SIZE,
- SVG_PREVIEW_SIZE
};
preview = load_rsvg_pixbuf (filename, &vals, &error);
if (!preview)
{
/* Do not rely on librsvg setting GError on failure! */
g_message (_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename),
error ? error->message : _("Unknown reason"));
return FALSE;
}
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* Scalable Vector Graphics is SVG, should perhaps not be translated */
dialog = gimp_dialog_new (_("Render Scalable Vector Graphics"),
PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, LOAD_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* The SVG preview */
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0);
gtk_widget_show (abox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (abox), frame);
gtk_widget_show (frame);
image = gtk_image_new_from_pixbuf (preview);
gtk_container_add (GTK_CONTAINER (frame), image);
gtk_widget_show (image);
size_label = gtk_label_new (NULL);
gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER);
gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4);
gtk_widget_show (size_label);
/* query the initial size after the size label is created */
vals.resolution = load_vals.resolution;
load_rsvg_size (filename, &vals, NULL);
svg_width = vals.width;
svg_height = vals.height;
table = gtk_table_new (7, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2);
gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Width and Height */
label = gtk_label_new (_("Width:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 1, 1, 2);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, FALSE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_SIZE));
gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6);
gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (size));
gimp_size_entry_set_refval_boundaries (size, 0,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval_boundaries (size, 1,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval (size, 0, svg_width);
gimp_size_entry_set_refval (size, 1, svg_height);
gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE);
gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE);
g_signal_connect (size, "value-changed",
G_CALLBACK (load_dialog_size_callback),
NULL);
/* Scale ratio */
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
table2 = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2);
gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4);
gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0);
spinbutton =
gimp_spin_button_new (&xadj,
ratio_x,
(gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_width,
(gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_width,
0.01, 0.1, 1,
0.01, 4);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1);
gtk_widget_show (spinbutton);
g_signal_connect (xadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_X ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
spinbutton =
gimp_spin_button_new (&yadj,
ratio_y,
(gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_height,
(gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_height,
0.01, 0.1, 1,
0.01, 4);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2);
gtk_widget_show (spinbutton);
g_signal_connect (yadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_Y ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
/* the constrain ratio chainbutton */
constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT);
gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2);
gtk_widget_show (constrain);
gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button,
_("Constrain aspect ratio"), NULL);
gtk_widget_show (table2);
/* Resolution */
label = gtk_label_new (_("Resolution:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"),
FALSE, FALSE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_RESOLUTION);
gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6);
gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (res);
/* don't let the resolution become too small, librsvg tends to
crash with very small resolutions */
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0,
5.0, GIMP_MAX_RESOLUTION);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution);
g_signal_connect (res, "value-changed",
G_CALLBACK (load_dialog_resolution_callback),
(gpointer) filename);
/* Path Import */
toggle = gtk_check_button_new_with_mnemonic (_("Import _paths"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 5, 6,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Import path elements of the SVG so they "
"can be used with the GIMP path tool"),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&load_vals.import);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_sensitive_update),
NULL);
toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths"));
gtk_table_attach (GTK_TABLE (table), toggle2, 0, 2, 6, 7,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_set_sensitive (toggle2, load_vals.import);
gtk_widget_show (toggle2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge);
g_signal_connect (toggle2, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&load_vals.merge);
g_object_set_data (G_OBJECT (toggle), "set_sensitive", toggle2);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0));
load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1));
}
gtk_widget_destroy (dialog);
return run;
}
static void
thunar_chooser_button_pressed (ThunarChooserButton *chooser_button,
GtkWidget *button)
{
ThunarVfsMimeApplication *default_application;
ThunarVfsMimeInfo *info;
ThunarIconFactory *icon_factory;
GtkIconTheme *icon_theme;
const gchar *icon_name;
GdkPixbuf *icon;
GtkWidget *image;
GtkWidget *item;
GtkWidget *menu;
GList *applications;
GList *lp;
gint icon_size;
_thunar_return_if_fail (THUNAR_IS_CHOOSER_BUTTON (chooser_button));
_thunar_return_if_fail (chooser_button->button == button);
_thunar_return_if_fail (GTK_IS_BUTTON (button));
/* verify that we have a valid file */
if (G_UNLIKELY (chooser_button->file == NULL))
return;
/* determine the mime info for the file */
info = thunar_file_get_mime_info (chooser_button->file);
/* determine the default application */
default_application = thunar_vfs_mime_database_get_default_application (chooser_button->database, info);
if (G_UNLIKELY (default_application == NULL))
{
/* no default application, just popup the application chooser */
thunar_chooser_button_activate_other (chooser_button);
return;
}
/* determine all applications that claim to be able to handle the file */
applications = thunar_vfs_mime_database_get_applications (chooser_button->database, info);
/* make sure the default application comes first */
lp = g_list_find (applications, default_application);
if (G_LIKELY (lp != NULL))
{
applications = g_list_delete_link (applications, lp);
g_object_unref (G_OBJECT (default_application));
}
applications = g_list_prepend (applications, default_application);
/* allocate a new popup menu */
menu = gtk_menu_new ();
/* determine the icon size for menus */
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size);
/* determine the icon factory for our screen */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (button));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
/* add the other possible applications */
for (lp = applications; lp != NULL; lp = lp->next)
{
item = gtk_image_menu_item_new_with_label (thunar_vfs_mime_handler_get_name (lp->data));
g_object_set_data_full (G_OBJECT (item), I_("thunar-vfs-mime-application"), lp->data, g_object_unref);
g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate), chooser_button);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* setup the icon for the application */
icon_name = thunar_vfs_mime_handler_lookup_icon_name (lp->data, icon_theme);
icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE);
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_widget_show (image);
if (G_LIKELY (icon != NULL))
g_object_unref (icon);
}
/* cleanup */
g_object_unref (G_OBJECT (icon_factory));
/* append a separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* release the applications list */
g_list_free (applications);
/* add the "Other Application..." choice */
item = gtk_image_menu_item_new_with_mnemonic (_("_Other Application..."));
g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate_other), chooser_button);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* make sure the menu has atleast the same width as the chooser */
if (menu->allocation.width < button->allocation.width)
gtk_widget_set_size_request (menu, button->allocation.width, -1);
/* run the menu on the button's screen (takes over the floating reference of menu) */
thunar_gtk_menu_run (GTK_MENU (menu), button, menu_position, button, 0, gtk_get_current_event_time ());
/* yeppa, that's a requirement */
gtk_button_released (GTK_BUTTON (button));
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
int return_value;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
// "Cancel", GTK_RESPONSE_REJECT, // Drop because it is too annoying to support call back this way
NULL);
// The main area for the whole dialog box.
GtkWidget* main_box = gtk_vbox_new(false, 5);
GtkWidget* central_box = gtk_vbox_new(false, 5);
GtkWidget* advanced_box = gtk_vbox_new(false, 5);
GtkWidget* debug_box = gtk_vbox_new(false, 5);
// Grab a logo, to make things look nice.
GdkPixbuf* logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
GtkWidget* logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
GtkWidget* main_table = CreateTableInBox(main_box , NULL , 2 , 2);
GtkWidget* shader_table = CreateTableInBox(central_box , "Custom Shader Settings" , 9 , 2);
GtkWidget* hw_table = CreateTableInBox(central_box , "Hardware Mode Settings" , 7 , 2);
GtkWidget* sw_table = CreateTableInBox(central_box , "Software Mode Settings" , 2 , 2);
GtkWidget* hack_table = CreateTableInBox(advanced_box, "Hacks" , 7 , 2);
GtkWidget* gl_table = CreateTableInBox(advanced_box, "OpenGL Very Advanced Custom Settings" , 6 , 2);
GtkWidget* record_table = CreateTableInBox(debug_box , "Recording Settings" , 4 , 3);
GtkWidget* debug_table = CreateTableInBox(debug_box , "OpenGL / GSdx Debug Settings" , 6 , 3);
// Populate all the tables
populate_main_table(main_table);
populate_shader_table(shader_table);
populate_hw_table(hw_table);
populate_sw_table(sw_table);
populate_hack_table(hack_table);
populate_gl_table(gl_table);
populate_debug_table(debug_table);
populate_record_table(record_table);
// Handle some nice tab
GtkWidget* notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box , gtk_label_new("Global Settings"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advanced_box, gtk_label_new("Advanced Settings"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), debug_box , gtk_label_new("Debug/Recording Settings"));
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), notebook);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
// Compatibility & not supported option
int mode_width = theApp.GetConfig("ModeWidth", 640);
int mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
theApp.SetConfig("msaa", 0);
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return (return_value == GTK_RESPONSE_ACCEPT);
}
void show_about()
{
GtkWidget *window;
GtkWidget *image;
GdkPixbuf *pixbuf;
GtkWidget *vbox;
GtkWidget *notebook;
GtkWidget *scroll;
GtkWidget *textview;
GtkWidget *tablabel;
GtkWidget *action_area;
GtkWidget *button;
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
pixbuf = gdk_pixbuf_new_from_file_at_size(SKIN_DIR"fetion.svg", 40, 40, NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon(GTK_WINDOW(window), pixbuf);
g_object_unref(pixbuf);
gtk_window_set_title(GTK_WINDOW(window), _("About OpenFetion"));
gtk_widget_set_usize(window, 500, 400);
vbox = gtk_vbox_new(FALSE, 5);
pixbuf = gdk_pixbuf_new_from_file_at_size(SKIN_DIR"fetion.svg", 98, 98, NULL);
image = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0);
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 5);
tablabel = gtk_label_new(_("Introduction"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_intro(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("About the author"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_author(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("Contributor"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_contri(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("License"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_gpl(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
action_area = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), action_area, FALSE, FALSE, 5);
button = gtk_button_new_with_label(_("Close"));
gtk_widget_set_usize(button, 90, 0);
gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5);
g_signal_connect(button, "clicked", G_CALLBACK(close_about), window);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
}
static GtkWidget *
get_image (PolkitMateAuthenticationDialog *dialog)
{
GdkPixbuf *pixbuf;
GdkPixbuf *copy_pixbuf;
GdkPixbuf *vendor_pixbuf;
GtkWidget *image;
pixbuf = NULL;
copy_pixbuf = NULL;
vendor_pixbuf = NULL;
if (dialog->priv->icon_name == NULL || strlen (dialog->priv->icon_name) == 0)
{
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
goto out;
}
vendor_pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
dialog->priv->icon_name,
48,
0,
NULL);
if (vendor_pixbuf == NULL)
{
g_warning ("No icon for themed icon with name '%s'", dialog->priv->icon_name);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
goto out;
}
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
GTK_STOCK_DIALOG_AUTHENTICATION,
48,
0,
NULL);
if (pixbuf == NULL)
goto out;
/* need to copy the pixbuf since we're modifying it */
copy_pixbuf = gdk_pixbuf_copy (pixbuf);
if (copy_pixbuf == NULL)
goto out;
/* blend the vendor icon in the bottom right quarter */
gdk_pixbuf_composite (vendor_pixbuf,
copy_pixbuf,
24, 24, 24, 24,
24, 24, 0.5, 0.5,
GDK_INTERP_BILINEAR,
255);
image = gtk_image_new_from_pixbuf (copy_pixbuf);
out:
if (pixbuf != NULL)
g_object_unref (pixbuf);
if (copy_pixbuf != NULL)
g_object_unref (copy_pixbuf);
if (vendor_pixbuf != NULL)
g_object_unref (vendor_pixbuf);
return image;
}
void
_showInGtkWindow (SEXP xx, SEXP caption) {
int nx, ny, nz, width, height;
udata *dat;
SEXP dim;
GdkPixbuf * pxbuf;
GtkWidget *evBox, *winWG, *vboxWG, *tbarWG, *scrollWG,
*btnZoomInWG, *btnZoomOutWG, *btnZoomOneWG,
*btnNextWG, *btnPrevWG;
GtkObject *hAdjustment;
GtkIconSize iSize;
if ( !GTK_OK )
error ( "failed to initialize GTK+, use 'read.image' instead" );
dim = GET_DIM (xx);
nx = INTEGER (dim)[0];
ny = INTEGER (dim)[1];
nz = getNumberOfFrames(xx,1);
dat=g_new(udata,1);
dat->nx=nx;
dat->ny=ny;
dat->nz=nz;
dat->x=0;
dat->y=0;
dat->zoom=1.0;
dat->index=0;
dat->hSlider=NULL;
dat->xx=xx;
// xx is preserved from garbage collection til the windows is closed
R_PreserveObject(xx);
/* create pixbuf from image data */
pxbuf=newPixbufFromSEXP(xx,0);
if ( pxbuf == NULL )
error ( "cannot copy image data to display window" );
/* create imae display */
dat->imgWG = gtk_image_new_from_pixbuf (pxbuf);
g_object_unref (pxbuf);
/* create main window */
winWG = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if ( caption != R_NilValue )
gtk_window_set_title ( GTK_WINDOW(winWG), CHAR( asChar(caption) ) );
else
gtk_window_set_title ( GTK_WINDOW(winWG), "R image display" );
/* set destroy event handler for the window */
g_signal_connect ( G_OBJECT(winWG), "delete-event", G_CALLBACK(onWinDestroy), dat);
/* create controls and set event handlers */
/* create general horizontal lyout with a toolbar and add it to the window */
vboxWG = gtk_vbox_new (FALSE, 0);
gtk_container_add ( GTK_CONTAINER(winWG), vboxWG);
/* create toolbar and push it to layout */
tbarWG = gtk_toolbar_new ();
gtk_box_pack_start ( GTK_BOX(vboxWG), tbarWG, FALSE, FALSE, 0);
// add a horizontal slider
if (nz>1) {
hAdjustment=gtk_adjustment_new(1,1,nz,1,1,0);
dat->hSlider=gtk_hscale_new(GTK_ADJUSTMENT(hAdjustment));
gtk_scale_set_digits(GTK_SCALE(dat->hSlider),0);
gtk_box_pack_start(GTK_BOX(vboxWG), dat->hSlider, FALSE,FALSE, 0);
gtk_signal_connect(GTK_OBJECT(dat->hSlider),"value-changed", GTK_SIGNAL_FUNC(onSlide), dat);
}
/* create scrollbox that occupies and extends and push it to layout */
scrollWG = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start ( GTK_BOX(vboxWG), scrollWG, TRUE, TRUE, 5);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrollWG), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* add image to event box */
evBox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(evBox), dat->imgWG);
/* add image to scroll */
gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW(scrollWG), evBox);
gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat);
gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat);
/* create status bar and push it to layout */
dat->stbarWG = gtk_statusbar_new ();
gtk_box_pack_start ( GTK_BOX(vboxWG), dat->stbarWG, FALSE, FALSE, 0);
/* add zoom buttons */
iSize = gtk_toolbar_get_icon_size ( GTK_TOOLBAR(tbarWG) );
btnZoomInWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-in", iSize), "Zoom in" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomInWG);
g_signal_connect ( G_OBJECT(btnZoomInWG), "clicked", G_CALLBACK(onZoomInPress), dat);
btnZoomOutWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-out", iSize), "Zoom out" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOutWG);
g_signal_connect ( G_OBJECT(btnZoomOutWG), "clicked", G_CALLBACK(onZoomOutPress), dat);
btnZoomOneWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-yes", iSize), "1:1");
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOneWG);
g_signal_connect ( G_OBJECT(btnZoomOneWG), "clicked", G_CALLBACK(onZoomOnePress), dat);
/* add browsing buttons */
if ( nz > 1 ) {
btnPrevWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-back", iSize), "Previous" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnPrevWG);
g_signal_connect ( G_OBJECT(btnPrevWG), "clicked", G_CALLBACK(onPrevImPress), dat);
btnNextWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-forward", iSize), "Next" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnNextWG);
g_signal_connect ( G_OBJECT(btnNextWG), "clicked", G_CALLBACK(onNextImPress), dat);
}
gtk_signal_connect( GTK_OBJECT(evBox), "motion-notify-event", GTK_SIGNAL_FUNC(onMouseMove), dat);
gtk_widget_set_events(evBox, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK );
/* resize to fit image */
width = gdk_screen_get_width ( gdk_screen_get_default() );
height = gdk_screen_get_height ( gdk_screen_get_default () );
width = ( nx + 20 < width - 20 ) ? ( nx + 20 ) : ( width - 20 );
height = ( ny + 80 < height - 20 ) ? ( ny + 80 ) : ( height - 20 );
if ( width < 150 ) width = 150;
if ( height < 100 ) height = 100;
gtk_window_resize ( GTK_WINDOW(winWG), width, height);
/* show window */
gtk_widget_show_all (winWG);
updateStatusBar(dat);
gdk_flush();
}
GtkWidget* ShortcutsListDlg::create_dialog (GtkWidget* parent)
{
GtkWidget *shortcuts_dialog;
GtkWidget *dialog_vbox8;
GtkWidget *hbox3;
GtkWidget *label33;
GtkWidget *label34;
GtkWidget *combobox4;
GtkWidget *scrolledwindow5;
GtkWidget *treeview3;
GtkWidget *label35;
GtkWidget *dialog_action_area8;
GtkWidget *cancelbutton8;
GtkWidget *okbutton8;
GtkWidget *clearall_btn;
GtkWidget *resetall_btn;
shortcuts_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (shortcuts_dialog), _("Shortcut editor"));
gtk_window_set_type_hint (GTK_WINDOW (shortcuts_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(shortcuts_dialog), 420, 450);
gtk_window_set_modal (GTK_WINDOW (shortcuts_dialog), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (shortcuts_dialog), TRUE);
#ifndef _WIN32 //TOFIX API is buggy on Win32 (kills modal dialog state)
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (shortcuts_dialog), TRUE);
#endif
gtk_window_set_skip_pager_hint (GTK_WINDOW (shortcuts_dialog), TRUE);
gtk_window_set_transient_for(GTK_WINDOW (shortcuts_dialog), GTK_WINDOW(window1)); //set parent
dialog_vbox8 = GTK_DIALOG (shortcuts_dialog)->vbox;
gtk_widget_show (dialog_vbox8);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox3, FALSE, TRUE, 0);
label33 = gtk_label_new (_("Context:"));
gtk_widget_show (label33);
gtk_box_pack_start (GTK_BOX (hbox3), label33, FALSE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label33), 0, 0.5);
combobox4 = gtk_combo_box_new_text ();
gtk_widget_show (combobox4);
gtk_box_pack_start (GTK_BOX (hbox3), combobox4, TRUE, TRUE, 2);
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Global"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Tree widget"));
gtk_combo_box_set_active (GTK_COMBO_BOX(combobox4), 0);
g_signal_connect(combobox4, "changed", G_CALLBACK (on_context_combo_selected), this);
label34 = gtk_label_new ("");
gtk_widget_show (label34);
gtk_box_pack_start (GTK_BOX (hbox3), label34, FALSE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label34), 1.0, 0.5);
scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow5);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), scrolledwindow5, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_SHADOW_IN);
// create shortcuts list
GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
treeview3 = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (G_OBJECT (store)); //tree now holds reference
gtk_widget_show (treeview3);
gtk_container_add (GTK_CONTAINER (scrolledwindow5), treeview3);
g_signal_connect (treeview3, "key_press_event", G_CALLBACK (treeview_keyboard_handler), this);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Action"));
gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 300);
// g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Shortcut"));
gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 50);
// g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col);
GtkWidget *hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox1, FALSE, TRUE, 5);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)&bulb);
GtkWidget *icon = gtk_image_new_from_pixbuf (pixbuf);
gtk_widget_show (icon);
gtk_box_pack_start (GTK_BOX (hbox1), icon, FALSE, TRUE, 2);
label35 = gtk_label_new (_("Use mouse click to select an action, and then press key combination to assign the shortcut to it. Some actions are listed in more than one context so they can have more than one shortcut attached."));
gtk_widget_show (label35);
gtk_box_pack_start (GTK_BOX (hbox1), label35, TRUE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label35), 0.5, 0.5);
gtk_label_set_line_wrap(GTK_LABEL(label35), true);
#if GTK_CHECK_VERSION(2,10,0) //minimal version for this api
gtk_label_set_line_wrap_mode(GTK_LABEL(label35), PANGO_WRAP_WORD_CHAR);
#endif
//action area
dialog_action_area8 = GTK_DIALOG (shortcuts_dialog)->action_area;
gtk_widget_show (dialog_action_area8);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END);
clearall_btn = gtk_button_new_with_mnemonic(_("Clear All"));
gtk_widget_show (clearall_btn);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), clearall_btn);
GTK_WIDGET_SET_FLAGS (clearall_btn, GTK_CAN_DEFAULT);
g_signal_connect(clearall_btn, "clicked", G_CALLBACK (on_clear_all_clicked), this);
resetall_btn = gtk_button_new_with_mnemonic(_("Reset All"));
gtk_widget_show (resetall_btn);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), resetall_btn);
GTK_WIDGET_SET_FLAGS (resetall_btn, GTK_CAN_DEFAULT);
g_signal_connect(resetall_btn, "clicked", G_CALLBACK (on_reset_all_clicked), this);
cancelbutton8 = gtk_button_new_with_mnemonic (_("Cancel"));
gtk_widget_show (cancelbutton8);
gtk_dialog_add_action_widget (GTK_DIALOG (shortcuts_dialog), cancelbutton8, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton8, GTK_CAN_DEFAULT);
g_signal_connect(cancelbutton8, "clicked", G_CALLBACK (on_cancel_clicked), this);
okbutton8 = gtk_button_new_with_mnemonic (_("OK"));
gtk_widget_show (okbutton8);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), okbutton8);
GTK_WIDGET_SET_FLAGS (okbutton8, GTK_CAN_DEFAULT);
g_signal_connect(okbutton8, "clicked", G_CALLBACK (on_ok_clicked), this);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, shortcuts_dialog, "shortcuts_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_vbox8, "dialog_vbox8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, label33, "label33");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, label34, "label34");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, combobox4, "combobox4");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, scrolledwindow5, "scrolledwindow5");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, treeview3, "treeview3");
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_action_area8, "dialog_action_area8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, cancelbutton8, "cancelbutton8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, okbutton8, "okbutton8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, resetall_btn, "resetall_btn");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, clearall_btn, "clearall_btn");
return shortcuts_dialog;
}
static GtkImage* CreateImage(const nall::image &image, bool scale = false) {
GdkPixbuf *pixbuf = CreatePixbuf(image, scale);
GtkImage *gtkImage = (GtkImage*)gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
return gtkImage;
}
int
main (int argc, char **argv)
{
GtkWidget *window, *grid;
GtkWidget *label, *image, *box;
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
GtkIconSet *iconset;
GtkIconSource *iconsource;
gchar *icon_name = "gnome-terminal";
gchar *anim_filename = NULL;
GIcon *icon;
GFile *file;
gtk_init (&argc, &argv);
if (argc > 1)
icon_name = argv[1];
if (argc > 2)
anim_filename = argv[2];
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
label = gtk_label_new ("symbolic size");
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
label = gtk_label_new ("fixed size");
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
label = gtk_label_new ("GTK_IMAGE_PIXBUF");
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
theme = gtk_icon_theme_get_default ();
pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48, 0, NULL);
image = gtk_image_new_from_pixbuf (pixbuf);
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), image);
gtk_grid_attach (GTK_GRID (grid), box, 2, 1, 1, 1);
gtk_drag_source_set (box, GDK_BUTTON1_MASK,
NULL, 0,
GDK_ACTION_COPY);
gtk_drag_source_add_image_targets (box);
g_signal_connect (box, "drag_begin", G_CALLBACK (drag_begin), image);
g_signal_connect (box, "drag_data_get", G_CALLBACK (drag_data_get), image);
gtk_drag_dest_set (box,
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP,
NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_image_targets (box);
g_signal_connect (box, "drag_data_received",
G_CALLBACK (drag_data_received), image);
label = gtk_label_new ("GTK_IMAGE_STOCK");
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
image = gtk_image_new_from_stock (GTK_STOCK_REDO, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1);
label = gtk_label_new ("GTK_IMAGE_ICON_SET");
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
iconsource = gtk_icon_source_new ();
gtk_icon_source_set_icon_name (iconsource, icon_name);
iconset = gtk_icon_set_new ();
gtk_icon_set_add_source (iconset, iconsource);
image = gtk_image_new_from_icon_set (iconset, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 3, 1, 1);
G_GNUC_END_IGNORE_DEPRECATIONS;
label = gtk_label_new ("GTK_IMAGE_ICON_NAME");
gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 4, 1, 1);
label = gtk_label_new ("GTK_IMAGE_GICON");
gtk_grid_attach (GTK_GRID (grid), label, 0, 5, 1, 1);
icon = g_themed_icon_new_with_default_fallbacks ("folder-remote");
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_grid_attach (GTK_GRID (grid), image, 1, 5, 1, 1);
file = g_file_new_for_path ("apple-red.png");
icon = g_file_icon_new (file);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 5, 1, 1);
if (anim_filename)
{
label = gtk_label_new ("GTK_IMAGE_ANIMATION (from file)");
gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1);
image = gtk_image_new_from_file (anim_filename);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 6, 1, 1);
/* produce high load */
g_signal_connect_after (image, "draw",
G_CALLBACK (anim_image_draw),
NULL);
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
gint gui_contact_open_by_dial(const gchar *dial)
{
debug("gui_contact_open_by_dial\n");
store_contact_struct *contact=NULL;
store_contact_match(&contact,dial);
if(!contact)
return -1;
store_contact_load_details(contact);
GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
if(contact->name)
gtk_window_set_title(GTK_WINDOW(window),contact->name);
else
gtk_window_set_title(GTK_WINDOW(window),"<Unknown>");
gtk_window_set_default_size(GTK_WINDOW(window),400,220);
GtkWidget *notebook=gtk_notebook_new();
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *title_bar=gtk_hbox_new(FALSE,0);
GdkPixbuf *pixbuf=NULL;
if(contact->name==NULL && contact->picture==NULL)
pixbuf=utils_get_photo_unknown();
else if(contact->picture==NULL)
pixbuf=utils_get_photo_default();
else
pixbuf=utils_get_photo(contact->picture);
GtkWidget *picture=gtk_image_new_from_pixbuf(pixbuf);
GtkWidget *name;
if(contact->name){
name=gtk_label_new (contact->name);
}else{
name=gtk_label_new ("<Unknown>");
}
gtk_box_pack_start(GTK_BOX(title_bar), picture, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(title_bar), name, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(v1), title_bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), gtk_hseparator_new(), FALSE, FALSE, 5);
GList *dials=contact->dials;
debug("Dials %p\n",dials);
while(dials){
gchar *dial=((store_dial_struct*)dials->data)->dial;
GtkWidget *label=gtk_label_new(dial);
GtkWidget *button_sms=gtk_button_new ();
GtkWidget *button_voice=gtk_button_new ();
GtkWidget *h_dial=gtk_hbox_new(FALSE,0);
GtkWidget *sms=gtk_image_new_from_pixbuf(utils_get_icon("sms.png"));
GtkWidget *voice=gtk_image_new_from_pixbuf(utils_get_icon("voice.png"));
g_signal_connect(G_OBJECT(button_sms),"clicked", G_CALLBACK(gui_contact_send_sms_callback),label);
g_signal_connect(G_OBJECT(button_voice),"clicked", G_CALLBACK(gui_contact_dial_callback),label);
gtk_container_add (GTK_CONTAINER(button_sms),sms);
gtk_container_add (GTK_CONTAINER(button_voice),voice);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
debug("gui_contact_open_by_dial add dial %d\n",dial);
gtk_box_pack_start(GTK_BOX(h_dial), label, TRUE, TRUE, 20);
gtk_box_pack_start(GTK_BOX(h_dial), button_sms, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(h_dial), button_voice, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(v1), h_dial, FALSE, FALSE, 0);
dials=g_list_next(dials);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Details"));
// Call history
GtkWidget *scroll;
GtkWidget *calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_STATUS, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Duration", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_DURACTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
//g_signal_connect_after(G_OBJECT(g_gui_calls.dials_view),"cursor-changed", G_CALLBACK(gui_dialer_book_click_callback),NULL);
SphoneStoreTreeModel *calls;
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),scroll,gtk_label_new("Calls"));
// SMS history
v1=gtk_vbox_new(FALSE,0);
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Messages"));
gtk_container_add(GTK_CONTAINER(window),notebook);
gtk_widget_show_all(window);
store_contact_free(contact);
return 0;
}
bool ConfigDialog::createWindow ()
{
// Create the dialog window
mDialog = gtk_dialog_new_with_buttons (
"OGRE Engine Setup", NULL, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
mOKButton = gtk_dialog_add_button (GTK_DIALOG (mDialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_position (GTK_WINDOW (mDialog), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (mDialog), FALSE);
gtk_widget_show (GTK_DIALOG (mDialog)->vbox);
GtkWidget *vbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (mDialog)->vbox), vbox, TRUE, TRUE, 0);
// Unpack the image and create a GtkImage object from it
try
{
static String imgType ("png");
Image img;
MemoryDataStream *imgStream;
DataStreamPtr imgStreamPtr;
imgStream = new MemoryDataStream (GLX_backdrop_data, sizeof (GLX_backdrop_data), false);
imgStreamPtr = DataStreamPtr (imgStream);
img.load (imgStreamPtr, imgType);
PixelBox src = img.getPixelBox (0, 0);
size_t width = img.getWidth ();
size_t height = img.getHeight ();
// Convert and copy image -- must be allocated with malloc
uint8 *data = (uint8 *)malloc (width * height * 4);
// Keep in mind that PixelBox does not free the data - this is ok
// as gtk takes pixel data ownership in gdk_pixbuf_new_from_data
PixelBox dst (src, PF_A8B8G8R8, data);
PixelUtil::bulkPixelConversion (src, dst);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data (
(const guchar *)dst.data, GDK_COLORSPACE_RGB,
true, 8, width, height, width * 4,
backdrop_destructor, NULL);
GtkWidget *ogre_logo = gtk_image_new_from_pixbuf (pixbuf);
gdk_pixbuf_unref (pixbuf);
gtk_widget_show (ogre_logo);
gtk_box_pack_start (GTK_BOX (vbox), ogre_logo, FALSE, FALSE, 0);
}
catch (Exception &e)
{
// Could not decode image; never mind
LogManager::getSingleton().logMessage("WARNING: Failed to decode Ogre logo image");
}
GtkWidget *rs_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), rs_hbox, FALSE, TRUE, 0);
GtkWidget *rs_label = gtk_label_new ("Rendering subsystem:");
gtk_widget_show (rs_label);
gtk_box_pack_start (GTK_BOX (rs_hbox), rs_label, TRUE, TRUE, 5);
gtk_label_set_justify (GTK_LABEL (rs_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (rs_label), 1, 0.5);
GtkWidget *rs_cb = gtk_combo_box_new_text ();
gtk_widget_show (rs_cb);
gtk_box_pack_start (GTK_BOX (rs_hbox), rs_cb, TRUE, TRUE, 5);
g_signal_connect (G_OBJECT (rs_cb), "changed", G_CALLBACK (rendererChanged), this);
// Add all available renderers to the combo box
const RenderSystemList &renderers = Root::getSingleton ().getAvailableRenderers ();
uint idx = 0, sel_renderer_idx = 0;
for (RenderSystemList::const_iterator r = renderers.begin(); r != renderers.end (); r++, idx++)
{
gtk_combo_box_append_text (GTK_COMBO_BOX (rs_cb), (*r)->getName ().c_str ());
if (mSelectedRenderSystem == *r)
sel_renderer_idx = idx;
}
// Don't show the renderer choice combobox if there's just one renderer
if (idx > 1)
gtk_widget_show (rs_hbox);
GtkWidget *ro_frame = gtk_frame_new (NULL);
gtk_widget_show (ro_frame);
gtk_box_pack_start (GTK_BOX (vbox), ro_frame, TRUE, TRUE, 0);
GtkWidget *ro_label = gtk_label_new ("Renderer options:");
gtk_widget_show (ro_label);
gtk_frame_set_label_widget (GTK_FRAME (ro_frame), ro_label);
gtk_label_set_use_markup (GTK_LABEL (ro_label), TRUE);
mParamTable = gtk_table_new (0, 0, FALSE);
gtk_widget_show (mParamTable);
gtk_container_add (GTK_CONTAINER (ro_frame), mParamTable);
gtk_combo_box_set_active (GTK_COMBO_BOX (rs_cb), sel_renderer_idx);
return true;
}
bool wxNotebook::InsertPage( size_t position,
wxNotebookPage* win,
const wxString& text,
bool select,
int imageId )
{
wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") );
wxCHECK_MSG( win->GetParent() == this, false,
wxT("Can't add a page whose parent is not the notebook!") );
wxCHECK_MSG( position <= GetPageCount(), false,
_T("invalid page index in wxNotebookPage::InsertPage()") );
// Hack Alert! (Part II): See above in wxInsertChildInNotebook callback
// why this has to be done. NOTE: using gtk_widget_unparent here does not
// work as it seems to undo too much and will cause errors in the
// gtk_notebook_insert_page below, so instead just clear the parent by
// hand here.
win->m_widget->parent = NULL;
if (m_themeEnabled)
win->SetThemeEnabled(true);
GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
wxGtkNotebookPage *nb_page = new wxGtkNotebookPage();
if ( position == GetPageCount() )
m_pagesData.Append( nb_page );
else
m_pagesData.Insert( position, nb_page );
m_pages.Insert(win, position);
// set the label image and text
// this must be done before adding the page, as GetPageText
// and GetPageImage will otherwise return wrong values in
// the page-changed event that results from inserting the
// first page.
nb_page->m_image = imageId;
nb_page->m_text = wxStripMenuCodes(text);
nb_page->m_box = gtk_hbox_new( FALSE, 1 );
gtk_container_set_border_width((GtkContainer*)nb_page->m_box, 2);
g_signal_connect (win->m_widget, "size_allocate",
G_CALLBACK (gtk_page_size_callback), win);
gtk_notebook_insert_page(notebook, win->m_widget, nb_page->m_box, position);
nb_page->m_page = gtk_notebook_get_nth_page(notebook, position);
if (imageId != -1)
{
wxASSERT( m_imageList != NULL );
const wxBitmap *bmp = m_imageList->GetBitmapPtr(imageId);
GtkWidget* pixmapwid = gtk_image_new_from_pixbuf(bmp->GetPixbuf());
gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
gtk_widget_show(pixmapwid);
}
/* set the label text */
nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) );
gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding );
/* apply current style */
GtkRcStyle *style = CreateWidgetStyle();
if ( style )
{
gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style);
gtk_rc_style_unref(style);
}
/* show the label */
gtk_widget_show( GTK_WIDGET(nb_page->m_label) );
if (select && (m_pagesData.GetCount() > 1))
{
SetSelection( position );
}
InvalidateBestSize();
return true;
}
void
gwy_app_splash_create(void)
{
GtkWidget *image, *vbox, *frame, *lab;
GdkPixbuf *pixbuf;
char *p, *version;
gwy_debug("");
g_return_if_fail(window == NULL);
if (!enable_splash)
return;
window = gtk_window_new(GTK_WINDOW_POPUP);
p = g_strconcat(_("Starting "), g_get_application_name(), NULL);
gtk_window_set_title(GTK_WINDOW(window), p);
gtk_window_set_wmclass(GTK_WINDOW(window), "splash",
g_get_application_name());
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(window),
GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
g_signal_connect_swapped(window, "delete-event",
G_CALLBACK(exit), GINT_TO_POINTER(0));
/* we don't want the splash screen to send the startup notification */
gtk_window_set_auto_startup_notification(FALSE);
g_signal_connect(window, "map", G_CALLBACK(splash_map), NULL);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT);
gtk_container_add(GTK_CONTAINER(window), frame);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
version = g_strdup_printf("%d.%d", GWY_VERSION_MAJOR, GWY_VERSION_MINOR);
pixbuf = compose_splash(version);
g_free(version);
if (pixbuf) {
image = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
}
else
image = gtk_image_new_from_stock(GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0);
label = gtk_label_new(p);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(label), 6, 4);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
g_free(p);
lab = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), lab, FALSE, FALSE, 0);
p = g_strconcat("<small>", PACKAGE_NAME,
_(" is free software released under GNU GPL."), "</small>",
NULL);
lab = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(lab), p);
gtk_misc_set_alignment(GTK_MISC(lab), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(lab), 5, 3);
gtk_box_pack_start(GTK_BOX(vbox), lab, FALSE, FALSE, 0);
g_free(p);
gtk_widget_show_all(window);
while (gtk_events_pending())
gtk_main_iteration();
}
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;
}
static void
set_columns_type (GtkTreeView *tree_view, ColumnsType type)
{
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
GdkPixbuf *pixbuf;
GtkWidget *image;
GtkAdjustment *adjustment;
current_column_type = type;
col = gtk_tree_view_get_column (tree_view, 0);
while (col)
{
gtk_tree_view_remove_column (tree_view, col);
col = gtk_tree_view_get_column (tree_view, 0);
}
switch (type)
{
case COLUMNS_NONE:
break;
case COLUMNS_LOTS:
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 1",
rend,
"text", 1,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (col, "Column 2");
rend = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
rend = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, rend, TRUE);
gtk_tree_view_column_add_attribute (col, rend, "text", 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
gtk_tree_view_set_expander_column (tree_view, col);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 3",
rend,
"active", BOOL_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_tree_view_column_set_widget (col, image);
rend = gtk_cell_renderer_toggle_new ();
/* you could also set this per-row by tying it to a column
* in the model of course.
*/
g_object_set (rend, "radio", TRUE, NULL);
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 4",
rend,
"active", BOOL_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_spin_new ();
adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
g_object_set (rend, "editable", TRUE, NULL);
g_object_set (rend, "adjustment", adjustment, NULL);
g_signal_connect (rend, "edited",
G_CALLBACK (edited_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 5",
rend,
"text", 4,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#if 0
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 6",
rend,
"text", 4,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 7",
rend,
"text", 5,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 8",
rend,
"text", 6,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 9",
rend,
"text", 7,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 10",
rend,
"text", 8,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#endif
/* FALL THRU */
case COLUMNS_ONE:
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 0",
rend,
"text", 0,
NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
default:
break;
}
}
static void
file_list_ready_cb (GList *files, gpointer user_data)
{
MarlinFileConflictDialog *fcd = MARLIN_FILE_CONFLICT_DIALOG (user_data);
GOFFile *src, *dest, *dest_dir;
gboolean should_show_type;
MarlinFileConflictDialogDetails *details;
char *primary_text, *message, *secondary_text;
const gchar *message_extra;
char *label_text;
GdkPixbuf *pixbuf;
GtkWidget *label;
GString *str;
PangoFontDescription *desc;
details = fcd->details;
details->handle = NULL;
dest_dir = g_list_nth_data (files, 0);
dest = g_list_nth_data (files, 1);
src = g_list_nth_data (files, 2);
const gchar *src_ftype = gof_file_get_ftype (src);
const gchar *dest_ftype = gof_file_get_ftype (dest);
should_show_type = strcmp(src_ftype, dest_ftype);
const gchar *dest_display_name = gof_file_get_display_name (dest);
const gchar *dest_dir_display_name = gof_file_get_display_name (dest_dir);
/* Set up the right labels */
if (dest->is_directory) {
if (src->is_directory) {
primary_text = g_strdup_printf (_("Merge folder \"%s\"?"), dest_display_name);
message_extra =
_("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (src->modified > dest->modified) {
message = g_strdup_printf (
_("An older folder with the same name already exists in \"%s\"."),
dest_dir_display_name);
} else if (src->modified < dest->modified) {
message = g_strdup_printf (
_("A newer folder with the same name already exists in \"%s\"."),
dest_dir_display_name);
} else {
message = g_strdup_printf (
_("Another folder with the same name already exists in \"%s\"."),
dest_dir_display_name);
}
} else {
message_extra =
_("Replacing it will remove all files in the folder.");
primary_text = g_strdup_printf
(_("Replace folder \"%s\"?"), dest_display_name);
message = g_strdup_printf
(_("A folder with the same name already exists in \"%s\"."),
dest_dir_display_name);
}
} else {
primary_text = g_strdup_printf
(_("Replace file \"%s\"?"), dest_display_name);
message_extra = _("Replacing it will overwrite its content.");
if (src->modified > dest->modified) {
message = g_strdup_printf (
_("An older file with the same name already exists in \"%s\"."),
dest_dir_display_name);
} else if (src->modified < dest->modified) {
message = g_strdup_printf (
_("A newer file with the same name already exists in \"%s\"."),
dest_dir_display_name);
} else {
message = g_strdup_printf (
_("Another file with the same name already exists in \"%s\"."),
dest_dir_display_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
g_free (message);
label = gtk_label_new (primary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_modify_font (label, NULL);
desc = pango_font_description_new ();
pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size (desc,
pango_font_description_get_size (gtk_widget_get_style (label)->font_desc) * PANGO_SCALE_LARGE);
gtk_widget_modify_font (label, desc);
pango_font_description_free (desc);
gtk_widget_show (label);
label = gtk_label_new (secondary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (primary_text);
g_free (secondary_text);
/* Set up file icons */
pixbuf = gof_file_get_icon_pixbuf (dest, FILE_ICON_SIZE_LARGE,
TRUE, GOF_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->dest_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
details->dest_image, FALSE, FALSE, 0);
gtk_widget_show (details->dest_image);
g_object_unref (pixbuf);
pixbuf = gof_file_get_icon_pixbuf (src, FILE_ICON_SIZE_LARGE,
TRUE, GOF_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->src_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
details->src_image, FALSE, FALSE, 0);
gtk_widget_show (details->src_image);
g_object_unref (pixbuf);
/* Set up labels */
label = gtk_label_new (NULL);
str = g_string_new (NULL);
g_string_append_printf (str, "<b>%s</b>\n", _("Original file"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), dest->format_size);
if (should_show_type) {
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), dest_ftype);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), dest->formated_modified);
label_text = str->str;
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_string_erase (str, 0, -1);
/* Second label */
label = gtk_label_new (NULL);
g_string_append_printf (str, "<b>%s</b>\n", _("Replace with"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), src->format_size);
if (should_show_type) {
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), src_ftype);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), src->formated_modified);
label_text = g_string_free (str, FALSE);
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (label_text);
/* Populate the entry */
details->conflict_name = g_strdup (dest_display_name);
gtk_entry_set_text (GTK_ENTRY (details->entry), details->conflict_name);
if (src->is_directory && dest->is_directory) {
gtk_button_set_label (GTK_BUTTON (details->replace_button),
_("Merge"));
}
//TODO
//marlin_file_monitor_add (src, fcd, MARLIN_FILE_ATTRIBUTES_FOR_ICON);
//marlin_file_monitor_add (dest, fcd, MARLIN_FILE_ATTRIBUTES_FOR_ICON);
details->src_handler_id = g_signal_connect (src, "changed",
G_CALLBACK (file_icons_changed), fcd);
details->dest_handler_id = g_signal_connect (dest, "changed",
G_CALLBACK (file_icons_changed), fcd);
}
static GtkWidget *
create_add_emblems_dialog (CajaEmblemSidebar *emblem_sidebar,
GSList *emblems)
{
GtkWidget *dialog, *label, *table, *image;
GtkWidget *first_entry, *entry, *scroller, *hbox;
Emblem *emblem;
GSList *list;
int num_emblems;
first_entry = NULL;
dialog = gtk_dialog_new_with_buttons (_("Add Emblems..."),
NULL,
0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
/* FIXME: make a better message */
if (g_slist_length (emblems) > 1)
{
label = gtk_label_new (_("Enter a descriptive name next to each emblem. This name will be used in other places to identify the emblem."));
}
else
{
label = gtk_label_new (_("Enter a descriptive name next to the emblem. This name will be used in other places to identify the emblem."));
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
label, FALSE, FALSE, 8);
gtk_widget_show (label);
scroller = eel_scrolled_wrap_table_new (TRUE, GTK_SHADOW_NONE, &table);
eel_wrap_table_set_x_spacing (EEL_WRAP_TABLE (table), 8);
eel_wrap_table_set_y_spacing (EEL_WRAP_TABLE (table), 8);
num_emblems=0;
list = emblems;
while (list != NULL)
{
/* walk through the list of emblems, and create an image
* and entry for each one
*/
emblem = (Emblem *)list->data;
list = list->next;
image = gtk_image_new_from_pixbuf (emblem->pixbuf);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
g_signal_connect (entry, "changed",
G_CALLBACK (emblem_name_entry_changed_cb),
emblem);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (table), hbox);
if (num_emblems == 0)
{
first_entry = entry;
}
num_emblems++;
}
gtk_container_set_border_width (GTK_CONTAINER (dialog), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
scroller, TRUE, TRUE, 8);
gtk_widget_show_all (scroller);
gtk_widget_grab_focus (first_entry);
/* we expand the window to hold up to about 4 emblems, but after that
* let the scroller do its thing. Is there a better way to do this?
*/
gtk_window_set_default_size (GTK_WINDOW (dialog), 400,
MIN (120+(60*num_emblems), 350));
g_object_set_data_full (G_OBJECT (dialog), "emblems-to-add",
emblems, (GDestroyNotify)destroy_emblem_list);
return dialog;
}
static GtkWidget *create_window(void)
{
GtkWidget *startwin;
GtkWidget *hlayout;
GtkWidget *banner;
GtkWidget *vlayout;
GtkWidget *tabs;
GtkWidget *configvlayout;
GtkWidget *configlayout;
GtkWidget *vmode3dlabel;
GtkWidget *vmode3dcombo;
GtkWidget *fullscreencheck;
GtkWidget *alwaysshowcheck;
GtkWidget *configtab;
GtkWidget *messagesscroll;
GtkWidget *messagestext;
GtkWidget *messagestab;
GtkWidget *buttons;
GtkWidget *cancelbutton;
GtkWidget *cancelbuttonalign;
GtkWidget *cancelbuttonlayout;
GtkWidget *cancelbuttonicon;
GtkWidget *cancelbuttonlabel;
GtkWidget *startbutton;
GtkWidget *startbuttonalign;
GtkWidget *startbuttonlayout;
GtkWidget *startbuttonicon;
GtkWidget *startbuttonlabel;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
// Basic window
startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
hlayout = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hlayout);
gtk_container_add(GTK_CONTAINER(startwin), hlayout);
// Banner
{
GdkPixbuf *pixbuf = load_banner();
banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_widget_show(banner);
gtk_box_pack_start(GTK_BOX(hlayout), banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
vlayout = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vlayout);
gtk_box_pack_start(GTK_BOX(hlayout), vlayout, TRUE, TRUE, 0);
// Tab control
tabs = gtk_notebook_new();
gtk_widget_show(tabs);
gtk_box_pack_start(GTK_BOX(vlayout), tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(tabs), 4);
// Vertical layout of config page main body
configvlayout = gtk_vbox_new(FALSE, 0);
gtk_widget_show(configvlayout);
gtk_container_add(GTK_CONTAINER(tabs), configvlayout);
// Fixed-position layout of config page controls
configlayout = gtk_fixed_new();
gtk_widget_show(configlayout);
gtk_box_pack_start(GTK_BOX(configvlayout), configlayout, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(configlayout), 6);
// 3D video mode label
vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:");
gtk_widget_show(vmode3dlabel);
gtk_fixed_put(GTK_FIXED(configlayout), vmode3dlabel, 0, 0);
gtk_widget_set_size_request(vmode3dlabel, 88, 29);
gtk_misc_set_alignment(GTK_MISC(vmode3dlabel), 0, 0.5);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL);
}
gtk_widget_show(vmode3dcombo);
gtk_fixed_put(GTK_FIXED(configlayout), vmode3dcombo, 88, 0);
gtk_widget_set_size_request(vmode3dcombo, 150, 29);
gtk_widget_add_accelerator(vmode3dcombo, "grab_focus", accel_group,
GDK_V, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Fullscreen checkbox
fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_widget_show(fullscreencheck);
gtk_fixed_put(GTK_FIXED(configlayout), fullscreencheck, 248, 0);
gtk_widget_set_size_request(fullscreencheck, 85, 29);
gtk_widget_add_accelerator(fullscreencheck, "grab_focus", accel_group,
GDK_F, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Always show config checkbox
alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show configuration on start");
gtk_widget_show(alwaysshowcheck);
gtk_box_pack_start(GTK_BOX(configvlayout), alwaysshowcheck, FALSE, FALSE, 0);
gtk_widget_add_accelerator(alwaysshowcheck, "grab_focus", accel_group,
GDK_A, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Configuration tab
configtab = gtk_label_new("Configuration");
gtk_widget_show(configtab);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(tabs), 0), configtab);
// Messages scrollable area
messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(messagesscroll);
gtk_container_add(GTK_CONTAINER(tabs), messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
messagestext = gtk_text_view_new();
gtk_widget_show(messagestext);
gtk_container_add(GTK_CONTAINER(messagesscroll), messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(messagestext), 2);
// Messages tab
messagestab = gtk_label_new("Messages");
gtk_widget_show(messagestab);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(tabs), 1), messagestab);
// Dialogue box buttons layout
buttons = gtk_hbutton_box_new();
gtk_widget_show(buttons);
gtk_box_pack_start(GTK_BOX(vlayout), buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(buttons), GTK_BUTTONBOX_END);
// Cancel button
cancelbutton = gtk_button_new();
gtk_widget_show(cancelbutton);
gtk_container_add(GTK_CONTAINER(buttons), cancelbutton);
GTK_WIDGET_SET_FLAGS(cancelbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(cancelbutton, "grab_focus", accel_group,
GDK_C, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(cancelbutton, "clicked", accel_group,
GDK_Escape, 0,
GTK_ACCEL_VISIBLE);
cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(cancelbuttonalign);
gtk_container_add(GTK_CONTAINER(cancelbutton), cancelbuttonalign);
cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_widget_show(cancelbuttonlayout);
gtk_container_add(GTK_CONTAINER(cancelbuttonalign), cancelbuttonlayout);
cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(cancelbuttonicon);
gtk_box_pack_start(GTK_BOX(cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0);
cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_widget_show(cancelbuttonlabel);
gtk_box_pack_start(GTK_BOX(cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
startbutton = gtk_button_new();
gtk_widget_show(startbutton);
gtk_container_add(GTK_CONTAINER(buttons), startbutton);
GTK_WIDGET_SET_FLAGS(startbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(startbutton, "grab_focus", accel_group,
GDK_S, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(startbutton, "clicked", accel_group,
GDK_Return, 0,
GTK_ACCEL_VISIBLE);
startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(startbuttonalign);
gtk_container_add(GTK_CONTAINER(startbutton), startbuttonalign);
startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_widget_show(startbuttonlayout);
gtk_container_add(GTK_CONTAINER(startbuttonalign), startbuttonlayout);
startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(startbuttonicon);
gtk_box_pack_start(GTK_BOX(startbuttonlayout), startbuttonicon, FALSE, FALSE, 0);
startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_widget_show(startbuttonlabel);
gtk_box_pack_start(GTK_BOX(startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
g_signal_connect((gpointer) alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(vmode3dlabel), vmode3dcombo);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF(startwin, startwin, "startwin");
GLADE_HOOKUP_OBJECT(startwin, hlayout, "hlayout");
GLADE_HOOKUP_OBJECT(startwin, banner, "banner");
GLADE_HOOKUP_OBJECT(startwin, vlayout, "vlayout");
GLADE_HOOKUP_OBJECT(startwin, tabs, "tabs");
GLADE_HOOKUP_OBJECT(startwin, configvlayout, "configvlayout");
GLADE_HOOKUP_OBJECT(startwin, configlayout, "configlayout");
GLADE_HOOKUP_OBJECT(startwin, vmode3dlabel, "vmode3dlabel");
GLADE_HOOKUP_OBJECT(startwin, vmode3dcombo, "vmode3dcombo");
GLADE_HOOKUP_OBJECT(startwin, fullscreencheck, "fullscreencheck");
GLADE_HOOKUP_OBJECT(startwin, alwaysshowcheck, "alwaysshowcheck");
GLADE_HOOKUP_OBJECT(startwin, configtab, "configtab");
GLADE_HOOKUP_OBJECT(startwin, messagesscroll, "messagesscroll");
GLADE_HOOKUP_OBJECT(startwin, messagestext, "messagestext");
GLADE_HOOKUP_OBJECT(startwin, messagestab, "messagestab");
GLADE_HOOKUP_OBJECT(startwin, buttons, "buttons");
GLADE_HOOKUP_OBJECT(startwin, cancelbutton, "cancelbutton");
GLADE_HOOKUP_OBJECT(startwin, cancelbuttonalign, "cancelbuttonalign");
GLADE_HOOKUP_OBJECT(startwin, cancelbuttonlayout, "cancelbuttonlayout");
GLADE_HOOKUP_OBJECT(startwin, cancelbuttonicon, "cancelbuttonicon");
GLADE_HOOKUP_OBJECT(startwin, cancelbuttonlabel, "cancelbuttonlabel");
GLADE_HOOKUP_OBJECT(startwin, startbutton, "startbutton");
GLADE_HOOKUP_OBJECT(startwin, startbuttonalign, "startbuttonalign");
GLADE_HOOKUP_OBJECT(startwin, startbuttonlayout, "startbuttonlayout");
GLADE_HOOKUP_OBJECT(startwin, startbuttonicon, "startbuttonicon");
GLADE_HOOKUP_OBJECT(startwin, startbuttonlabel, "startbuttonlabel");
gtk_window_add_accel_group(GTK_WINDOW(startwin), accel_group);
return startwin;
}
void create_startwin(void)
{
GtkWidget *banner, *label, *content, *scroll;
GtkWidget *hbox1, *fixed1;
GdkPixbuf *startbanner_pixbuf;
startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (startwin), apptitle);
gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (startwin), hbox1);
startbanner_pixbuf = gdk_pixbuf_from_pixdata(&startbanner_pixdata, FALSE, NULL);
banner = gtk_image_new_from_pixbuf(startbanner_pixbuf);
g_object_unref((gpointer)startbanner_pixbuf);
gtk_widget_show (banner);
gtk_box_pack_start (GTK_BOX (hbox1), banner, FALSE, FALSE, 0);
fixed1 = gtk_fixed_new ();
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (hbox1), fixed1, TRUE, TRUE, 0);
gtk_widget_set_size_request (fixed1, 390, -1);
label = gtk_label_new (startwin_labeltext);
gtk_widget_show (label);
gtk_fixed_put (GTK_FIXED (fixed1), label, 6, 6);
gtk_widget_set_size_request (label, 378, 16);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scroll);
gtk_fixed_put (GTK_FIXED (fixed1), scroll, 6, 28);
gtk_widget_set_size_request (scroll, 378, 248);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
content = gtk_text_view_new ();
gtk_widget_show (content);
gtk_container_add (GTK_CONTAINER(scroll), content);
//gtk_fixed_put (GTK_FIXED (fixed1), content, 6, 28);
gtk_widget_set_size_request (content, 378, 248);
gtk_text_view_set_editable (GTK_TEXT_VIEW (content), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (content), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (content), FALSE);
g_signal_connect ((gpointer) startwin, "delete_event",
G_CALLBACK (on_startwin_delete_event),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin");
GLADE_HOOKUP_OBJECT (startwin, banner, "banner");
GLADE_HOOKUP_OBJECT (startwin, label, "label");
GLADE_HOOKUP_OBJECT (startwin, scroll, "scroll");
GLADE_HOOKUP_OBJECT (startwin, content, "content");
g_signal_connect((gpointer)startwin, "destroy", G_CALLBACK(gtk_widget_destroyed), (gpointer)&startwin);
gtk_widget_show (startwin);
gtk_main_iteration_do (FALSE);
}
static void
deskmenu_construct_item (DeskmenuObject *dm_object)
{
DeskmenuItem *item = dm_object->current_item;
GtkWidget *menu_item, *submenu;
gchar *name, *icon, *command, *vpicon;
gboolean images;
gint w, h;
//constructs the items in menu
switch (item->type)
{
case DESKMENU_ITEM_LAUNCHER:
if (item->name_exec)
{
GtkWidget *label;
GHook *hook;
name = g_strstrip (item->name->str);
menu_item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (menu_item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (item->name)
name = g_strstrip (item->name->str);
else
name = "";
menu_item = gtk_image_menu_item_new_with_mnemonic (name);
}
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
if (item->command_pipe)
{
command = g_strstrip (item->command->str);
if (item->cache_output)
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("yes"));
}
else
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("no"));
}
g_object_set_data(G_OBJECT(menu_item), "menu", dm_object);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (pipe_menu_recreate), g_strdup(command));
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
}
else
{
if (item->command)
{
command = g_strstrip (item->command->str);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (launcher_activated), g_strdup (command));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
#if HAVE_WNCK
case DESKMENU_ITEM_WINDOWLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Windows");
images = FALSE;
gboolean this_vp = FALSE;
gboolean mini_only = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->thisvp
&& strcmp (g_strstrip (item->thisvp->str), "true") == 0)
this_vp = TRUE;
if (item->mini_only
&& strcmp (g_strstrip (item->mini_only->str), "true") == 0)
mini_only = TRUE;
g_object_set_data(G_OBJECT(menu_item), "windowlist", deskmenu_windowlist_initialize (images, this_vp, mini_only));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_windowlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_DESKTOPLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Desktops");
gboolean file;
images = FALSE;
file = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "dplist", deskmenu_dplist_initialize (images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_desktoplist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_VIEWPORTLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Viewports");
gboolean wrap;
wrap = FALSE;
images = FALSE;
file = FALSE;
if (item->wrap && strcmp (g_strstrip (item->wrap->str), "true") == 0)
wrap = TRUE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "vplist", deskmenu_vplist_initialize (wrap, images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_viewportlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
#endif
case DESKMENU_ITEM_RELOAD:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Reload");
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (quit), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
case DESKMENU_ITEM_DOCUMENTS:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Recent Doc_uments");
gint limit, age;
gchar *sort_type;
images = FALSE;
sort_type = "least used";
age = 25;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->age)
{
age = atoi(g_strstrip (item->age->str));
}
if (item->sort_type)
{
sort_type = g_strstrip (item->sort_type->str);
}
if (item->quantity)
{
limit = atoi(g_strstrip (item->quantity->str));
}
else
{
limit = -1;
}
if (item->command)
{
command = g_strstrip (item->command->str);
}
else
{
command = g_strdup ("xdg-open");
}
GtkWidget *docs = make_recent_documents_list(images, command, limit, age, sort_type);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
docs);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
default:
break;
}
}
static void
asgtk_image_view_make_parts (ASGtkImageView * iv, Bool horizontal)
{
iv->frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, 1.0, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (iv->frame), GTK_SHADOW_NONE);
gtk_widget_show (iv->frame);
colorize_gtk_widget (iv->frame, get_colorschemed_style_normal ());
iv->scrolled_window =
ASGTK_SCROLLED_WINDOW (GTK_POLICY_NEVER, GTK_POLICY_NEVER,
GTK_SHADOW_NONE);
ASGTK_CONTAINER_ADD (iv->frame, iv->scrolled_window);
if (!get_flags
(iv->flags,
ASGTK_IMAGE_VIEW_SCALE_TO_VIEW | ASGTK_IMAGE_VIEW_TILE_TO_VIEW)) {
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
(iv->scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
}
colorize_gtk_widget (GTK_WIDGET (iv->scrolled_window),
get_colorschemed_style_normal ());
iv->view = gtk_image_new_from_pixbuf (NULL);
gtk_widget_show (GTK_WIDGET (iv->view));
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
(iv->scrolled_window),
GTK_WIDGET (iv->view));
colorize_gtk_widget (GTK_WIDGET (iv->view),
get_colorschemed_style_normal ());
g_signal_connect ((gpointer) iv->scrolled_window, "size-allocate",
G_CALLBACK (asgtk_imview_view_size_alloc), iv);
iv->details_label = gtk_label_new (NO_IMAGE_TEXT);
gtk_widget_show (iv->details_label);
iv->details_frame = gtk_frame_new (NULL);
gtk_widget_show (iv->details_frame);
gtk_container_set_border_width (GTK_CONTAINER (iv->details_frame), 1);
gtk_frame_set_shadow_type (GTK_FRAME (iv->details_frame), GTK_SHADOW_IN);
colorize_gtk_widget (iv->details_frame,
get_colorschemed_style_normal ());
iv->tools_hbox =
horizontal ? gtk_vbox_new (FALSE, 0) : gtk_hbutton_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (iv->tools_hbox), 0);
if (GTK_IS_BUTTON_BOX (iv->tools_hbox))
gtk_button_box_set_layout (GTK_BUTTON_BOX (iv->tools_hbox),
GTK_BUTTONBOX_END /*SPREAD*/);
gtk_widget_show (iv->tools_hbox);
iv->details_hbox =
horizontal ? gtk_vbutton_box_new () : gtk_hbutton_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (iv->details_hbox), 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (iv->details_hbox),
GTK_BUTTONBOX_EDGE);
gtk_widget_show (iv->details_hbox);
gtk_container_add (GTK_CONTAINER (iv->details_frame), iv->details_hbox);
gtk_box_pack_end (GTK_BOX (iv->details_hbox), iv->details_label, TRUE,
TRUE, 0);
}
static void
start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attr_names,
const gchar **attr_values,
gpointer user_data,
GError **error)
{
DeskmenuObject *dm_object = user_data;
DeskmenuElementType element_type;
const gchar **ncursor = attr_names, **vcursor = attr_values;
GtkWidget *item, *menu;
gint w, h;
element_type = GPOINTER_TO_INT (g_hash_table_lookup
(element_hash, element_name));
if ((dm_object->menu && !dm_object->current_menu)
|| (!dm_object->menu && element_type != DESKMENU_ELEMENT_MENU))
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num, &char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element '%s' declared outside of "
"toplevel menu element", line_num, char_num, element_name);
return;
}
switch (element_type)
{
case DESKMENU_ELEMENT_MENU:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
if (!dm_object->menu)
{
/*if (strcmp (*ncursor, "size") == 0) {
deskmenu->w = g_strdup (*vcursor);
deskmenu->h = g_strdup (*vcursor);
}
else {
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, deskmenu->w, deskmenu->h);
}*/
dm_object->menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (dm_object->menu), "parent menu",
NULL);
dm_object->current_menu = dm_object->menu;
}
else
{
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
name = g_strdup (*vcursor);
else if (strcmp (*ncursor, "icon") == 0)
icon = g_strdup (*vcursor);
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (name_exec)
{
GtkWidget *label;
GHook *hook;
item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (name)
item = gtk_image_menu_item_new_with_mnemonic (name);
else
item = gtk_image_menu_item_new_with_mnemonic ("");
}
if (icon)
{
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL)));
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "parent menu",
dm_object->current_menu);
dm_object->current_menu = menu;
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
dm_object->current_menu);
if (!dm_object->make_from_pipe)
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
dm_object->pin_items = g_slist_prepend (dm_object->pin_items, pin);
}
else
{
if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu)))
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
}
}
g_free (name);
g_free (icon);
}
break;
case DESKMENU_ELEMENT_SEPARATOR:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
else {
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
gboolean decorate = FALSE;
gint w, h;
item = gtk_separator_menu_item_new();
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
{
name = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if (strcmp (*ncursor, "icon") == 0)
{
icon = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (decorate)
{
GtkWidget *box = gtk_hbox_new (FALSE, 3);
gtk_container_add (GTK_CONTAINER(item), GTK_WIDGET(box));
if (name_exec)
{
GtkWidget *label;
GHook *hook;
label = gtk_label_new_with_mnemonic (NULL);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_box_pack_end (GTK_BOX(box), label, TRUE, FALSE, 0);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
gtk_box_pack_end (GTK_BOX(box), gtk_label_new_with_mnemonic (name), TRUE, FALSE, 0);
}
if (icon)
{
GtkWidget *image;
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
image = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL));
}
else {
image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
}
gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 0);
}
gtk_widget_set_state (item, GTK_STATE_PRELIGHT); /*derive colors from menu hover*/
g_free (name);
g_free (icon);
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
}
break;
case DESKMENU_ELEMENT_ITEM:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'item' cannot be nested "
"inside of another item element", line_num, char_num);
return;
}
dm_object->current_item = g_slice_new0 (DeskmenuItem);
while (*ncursor)
{
if (strcmp (*ncursor, "type") == 0)
dm_object->current_item->type = GPOINTER_TO_INT
(g_hash_table_lookup (item_hash, *vcursor));
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
break;
case DESKMENU_ELEMENT_NAME:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
dm_object->current_item->name_exec = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_ICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->icon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_VPICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->vpicon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_COMMAND:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode2") == 0)
&& (strcmp (*vcursor, "pipe") == 0))
dm_object->current_item->command_pipe = TRUE;
if (dm_object->current_item->command_pipe == TRUE
&& (strcmp (*ncursor, "cache") == 0)
&& (strcmp (*vcursor, "true") == 0))
dm_object->current_item->cache_output = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_WRAP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_THISVP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_MINIONLY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_QUANTITY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_SORT:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_AGE:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
default:
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
"Unknown element: %s", element_name);
break;
}
}
bool wxNotebook::InsertPage( size_t position,
wxNotebookPage* win,
const wxString& text,
bool select,
int imageId )
{
wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") );
wxCHECK_MSG( win->GetParent() == this, false,
wxT("Can't add a page whose parent is not the notebook!") );
wxCHECK_MSG( position <= GetPageCount(), false,
wxT("invalid page index in wxNotebookPage::InsertPage()") );
// Hack Alert! (Part II): See above in wxNotebook::AddChildGTK
// why this has to be done.
gtk_widget_unparent(win->m_widget);
if (m_themeEnabled)
win->SetThemeEnabled(true);
GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
wxGtkNotebookPage* pageData = new wxGtkNotebookPage;
m_pages.Insert(win, position);
m_pagesData.Insert(position, pageData);
// set the label image and text
// this must be done before adding the page, as GetPageText
// and GetPageImage will otherwise return wrong values in
// the page-changed event that results from inserting the
// first page.
pageData->m_imageIndex = imageId;
pageData->m_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
#ifndef __WXGTK3__
gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2);
#endif
pageData->m_image = NULL;
if (imageId != -1)
{
if (HasImageList())
{
const wxBitmap* bitmap = GetImageList()->GetBitmapPtr(imageId);
pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
gtk_box_pack_start(GTK_BOX(pageData->m_box),
pageData->m_image, false, false, m_padding);
}
else
{
wxFAIL_MSG("invalid notebook imagelist");
}
}
/* set the label text */
pageData->m_label = gtk_label_new(wxGTK_CONV(wxStripMenuCodes(text)));
gtk_box_pack_end(GTK_BOX(pageData->m_box),
pageData->m_label, false, false, m_padding);
gtk_widget_show_all(pageData->m_box);
gtk_notebook_insert_page(notebook, win->m_widget, pageData->m_box, position);
/* apply current style */
#ifdef __WXGTK3__
GTKApplyStyle(pageData->m_label, NULL);
#else
GtkRcStyle *style = GTKCreateWidgetStyle();
if ( style )
{
gtk_widget_modify_style(pageData->m_label, style);
g_object_unref(style);
}
#endif
if (select && GetPageCount() > 1)
{
SetSelection( position );
}
InvalidateBestSize();
return true;
}
int main( int argc, char *argv[] )
{
//g_thread_init (NULL);
GtkWidget *window, *vbox, *hbox;
//Init gtk + gegl:
gtk_init(&argc, &argv);
gegl_init(&argc,&argv);
//Create graph:
geglGraph = create_graph();
//Build GUI:
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 1100, 600);
gtk_window_set_title(GTK_WINDOW(window), "gtkapp");
hbox = gtk_hpaned_new();
gtk_paned_set_position(GTK_PANED(hbox), 600);
gtk_container_add(GTK_CONTAINER(window),hbox);
vbox = gtk_vbox_new(FALSE,0);
gtk_paned_pack1(GTK_PANED(hbox), vbox, TRUE, FALSE);
//Add graph editor to right column of hbox:
GtkWidget* scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_paned_pack2(GTK_PANED(hbox), scrolledWindow, TRUE, TRUE);
//Add viewport to make a scroll effect!
GtkWidget* viewport = gtk_viewport_new (NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolledWindow), viewport);
GtkWidget* vbox_editor = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(viewport), vbox_editor);
//Add GimpNodeEditor:
GtkWidget *gimp_editor = gimp_node_editor_new(geglGraph->graph,geglGraph->node_pixbuf);
gtk_box_pack_start(GTK_BOX(vbox_editor), gimp_editor, TRUE, TRUE, 0);
/* MENU BAR */
GtkWidget *menubar;
GtkWidget *file_menu;
GtkWidget *file;
GtkWidget *graph_menu;
GtkWidget *graph;
GtkWidget *add_operation;
menubar = gtk_menu_bar_new();
//File Menu
file_menu = gtk_menu_new();
file = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), file_menu);
//Graph Menu
graph_menu = gtk_menu_new();
graph = gtk_menu_item_new_with_label("Graph");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(graph), graph_menu);
add_operation = gtk_menu_item_new_with_label("Add Operation");
// g_signal_connect(add_operation, "activate", (GCallback)add_operation_activated, layer);
gtk_menu_shell_append(GTK_MENU_SHELL(graph_menu), add_operation);
//Add menues to menu bar
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), graph);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
//Add scrolled window for image view
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledWindow, TRUE, TRUE, 0);
//Add viewport to make a scroll effect!
viewport = gtk_viewport_new (NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolledWindow), viewport);
//Add image view:
GtkWidget *image = gtk_image_new_from_pixbuf(geglGraph->pixbuf);
gtk_container_add(GTK_CONTAINER(viewport), image);
//Add frame for buttons:
GtkWidget* frameButtons = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox), frameButtons, FALSE, FALSE, 0);
//Add vbox to frameButtons for buttons:
GtkWidget* vboxButtons = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(frameButtons), vboxButtons);
//Add blur settings:
GtkObject *adj_blure = gtk_adjustment_new(0.0,0.0,1000.0, 0.1,1.0,0.0);
GtkWidget *spn_blure = gtk_spin_button_new(GTK_ADJUSTMENT(adj_blure),10.0,2);
gtk_box_pack_end(GTK_BOX(vboxButtons),spn_blure,TRUE,TRUE,6);
g_signal_connect(adj_blure, "value-changed",
G_CALLBACK (image_update), (gpointer)image);
g_signal_connect(window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect(GIMP_NODE_EDITOR(gimp_editor), "updated",
G_CALLBACK (image_update), (gpointer)image);
gtk_widget_show_all(window);
gtk_main();
g_object_unref(geglGraph->graph);
gegl_exit();
g_free(geglGraph);
return (EXIT_SUCCESS);
}
/* Add notification action */
void
add_notification_action(GtkWindow *nw, const char *text, const char *key,
ActionInvokedCb cb)
{
WindowData *windata = g_object_get_data(G_OBJECT(nw), "windata");
GtkWidget *label;
GtkWidget *button;
GtkWidget *hbox;
GdkPixbuf *pixbuf;
char *buf;
g_assert(windata != NULL);
if (!GTK_WIDGET_VISIBLE(windata->actions_box))
{
GtkWidget *alignment;
gtk_widget_show(windata->actions_box);
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_end(GTK_BOX(windata->actions_box), alignment,
FALSE, TRUE, 0);
windata->pie_countdown = gtk_drawing_area_new();
gtk_widget_show(windata->pie_countdown);
gtk_container_add(GTK_CONTAINER(alignment), windata->pie_countdown);
gtk_widget_set_size_request(windata->pie_countdown,
PIE_WIDTH, PIE_HEIGHT);
g_signal_connect(G_OBJECT(windata->pie_countdown), "expose_event",
G_CALLBACK(countdown_expose_cb), windata);
}
button = gtk_button_new();
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(windata->actions_box), button, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_container_add(GTK_CONTAINER(button), hbox);
/* Try to be smart and find a suitable icon. */
buf = g_strdup_printf("stock_%s", key);
pixbuf = gtk_icon_theme_load_icon(
gtk_icon_theme_get_for_screen(
gdk_drawable_get_screen(GTK_WIDGET(nw)->window)),
buf, 16, GTK_ICON_LOOKUP_USE_BUILTIN, NULL);
g_free(buf);
if (pixbuf != NULL)
{
GtkWidget *image = gtk_image_new_from_pixbuf(pixbuf);
gtk_widget_show(image);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.5);
}
label = gtk_label_new(NULL);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
buf = g_strdup_printf("<small>%s</small>", text);
gtk_label_set_markup(GTK_LABEL(label), buf);
g_free(buf);
g_object_set_data(G_OBJECT(button), "_nw", nw);
g_object_set_data_full(G_OBJECT(button),
"_action_key", g_strdup(key), g_free);
g_signal_connect(G_OBJECT(button), "button-release-event",
G_CALLBACK(action_clicked_cb), cb);
}
static void
file_list_ready_cb (GList *files,
gpointer user_data)
{
CajaFileConflictDialog *fcd = user_data;
CajaFile *src, *dest, *dest_dir;
time_t src_mtime, dest_mtime;
gboolean source_is_dir, dest_is_dir, should_show_type;
CajaFileConflictDialogDetails *details;
char *primary_text, *message, *secondary_text;
const gchar *message_extra;
char *dest_name, *dest_dir_name, *edit_name;
char *label_text;
char *size, *date, *type = NULL;
GdkPixbuf *pixbuf;
GtkWidget *label;
GString *str;
PangoFontDescription *desc;
details = fcd->details;
details->handle = NULL;
dest_dir = g_list_nth_data (files, 0);
dest = g_list_nth_data (files, 1);
src = g_list_nth_data (files, 2);
src_mtime = caja_file_get_mtime (src);
dest_mtime = caja_file_get_mtime (dest);
dest_name = caja_file_get_display_name (dest);
dest_dir_name = caja_file_get_display_name (dest_dir);
source_is_dir = caja_file_is_directory (src);
dest_is_dir = caja_file_is_directory (dest);
type = caja_file_get_mime_type (dest);
should_show_type = !caja_file_is_mime_type (src, type);
g_free (type);
type = NULL;
/* Set up the right labels */
if (dest_is_dir)
{
if (source_is_dir)
{
primary_text = g_strdup_printf
(_("Merge folder \"%s\"?"),
dest_name);
message_extra =
_("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
message_extra =
_("Replacing it will remove all files in the folder.");
primary_text = g_strdup_printf
(_("Replace folder \"%s\"?"), dest_name);
message = g_strdup_printf
(_("A folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
primary_text = g_strdup_printf
(_("Replace file \"%s\"?"), dest_name);
message_extra = _("Replacing it will overwrite its content.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another file with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
g_free (message);
label = gtk_label_new (primary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_modify_font (label, NULL);
desc = pango_font_description_new ();
pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size (desc,
pango_font_description_get_size (gtk_widget_get_style (label)->font_desc) * PANGO_SCALE_LARGE);
gtk_widget_modify_font (label, desc);
pango_font_description_free (desc);
gtk_widget_show (label);
label = gtk_label_new (secondary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (primary_text);
g_free (secondary_text);
/* Set up file icons */
pixbuf = caja_file_get_icon_pixbuf (dest,
CAJA_ICON_SIZE_LARGE,
TRUE,
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->dest_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
details->dest_image, FALSE, FALSE, 0);
gtk_widget_show (details->dest_image);
g_object_unref (pixbuf);
pixbuf = caja_file_get_icon_pixbuf (src,
CAJA_ICON_SIZE_LARGE,
TRUE,
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->src_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
details->src_image, FALSE, FALSE, 0);
gtk_widget_show (details->src_image);
g_object_unref (pixbuf);
/* Set up labels */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (dest,
"date_modified");
size = caja_file_get_string_attribute (dest, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (dest, "type");
}
str = g_string_new (NULL);
g_string_append_printf (str, "<b>%s</b>\n", _("Original file"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size);
if (should_show_type)
{
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date);
label_text = str->str;
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (type);
g_free (date);
g_string_erase (str, 0, -1);
/* Second label */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (src,
"date_modified");
size = caja_file_get_string_attribute (src, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (src, "type");
}
g_string_append_printf (str, "<b>%s</b>\n", _("Replace with"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size);
if (should_show_type)
{
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date);
label_text = g_string_free (str, FALSE);
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (date);
g_free (type);
g_free (label_text);
/* Populate the entry */
edit_name = caja_file_get_edit_name (dest);
details->conflict_name = edit_name;
gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name);
if (source_is_dir && dest_is_dir)
{
gtk_button_set_label (GTK_BUTTON (details->replace_button),
_("Merge"));
}
/* If meld is installed, and source and destination arent binary
* files, show the diff button
*/
gtk_widget_hide (details->diff_button);
if (!source_is_dir && !dest_is_dir)
{
gchar *meld_found = g_find_program_in_path ("meld");
if (meld_found) {
g_free (meld_found);
gboolean src_is_binary;
gboolean dest_is_binary;
src_is_binary = caja_file_is_binary (details->source);
dest_is_binary = caja_file_is_binary (details->destination);
if (!src_is_binary && !dest_is_binary)
gtk_widget_show (details->diff_button);
}
}
caja_file_monitor_add (src, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
caja_file_monitor_add (dest, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
details->src_handler_id = g_signal_connect (src, "changed",
G_CALLBACK (file_icons_changed), fcd);
details->dest_handler_id = g_signal_connect (dest, "changed",
G_CALLBACK (file_icons_changed), fcd);
}
void wxTaskBarIcon::Private::SetIcon()
{
#if GTK_CHECK_VERSION(2,10,0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,10,0) == NULL)
{
if (m_statusIcon)
gtk_status_icon_set_from_pixbuf(m_statusIcon, m_bitmap.GetPixbuf());
else
{
m_statusIcon = gtk_status_icon_new_from_pixbuf(m_bitmap.GetPixbuf());
g_signal_connect(m_statusIcon, "activate",
G_CALLBACK(icon_activate), m_taskBarIcon);
g_signal_connect(m_statusIcon, "popup_menu",
G_CALLBACK(status_icon_popup_menu), m_taskBarIcon);
}
}
else
#endif
{
#ifndef __WXGTK3__
m_size = 0;
if (m_eggTrayIcon)
{
GtkWidget* image = gtk_bin_get_child(GTK_BIN(m_eggTrayIcon));
gtk_image_set_from_pixbuf(GTK_IMAGE(image), m_bitmap.GetPixbuf());
}
else
{
m_eggTrayIcon = GTK_WIDGET(egg_tray_icon_new("wxTaskBarIcon"));
gtk_widget_add_events(m_eggTrayIcon, GDK_BUTTON_PRESS_MASK);
g_signal_connect(m_eggTrayIcon, "size_allocate",
G_CALLBACK(icon_size_allocate), this);
g_signal_connect(m_eggTrayIcon, "destroy",
G_CALLBACK(icon_destroy), this);
g_signal_connect(m_eggTrayIcon, "button_press_event",
G_CALLBACK(icon_button_press_event), m_taskBarIcon);
g_signal_connect(m_eggTrayIcon, "popup_menu",
G_CALLBACK(icon_popup_menu), m_taskBarIcon);
GtkWidget* image = gtk_image_new_from_pixbuf(m_bitmap.GetPixbuf());
gtk_container_add(GTK_CONTAINER(m_eggTrayIcon), image);
gtk_widget_show_all(m_eggTrayIcon);
}
#endif
}
#if wxUSE_TOOLTIPS
const char *tip_text = NULL;
if (!m_tipText.empty())
tip_text = m_tipText.utf8_str();
#if GTK_CHECK_VERSION(2,10,0)
if (m_statusIcon)
{
#if GTK_CHECK_VERSION(2,16,0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,16,0) == NULL)
gtk_status_icon_set_tooltip_text(m_statusIcon, tip_text);
else
#endif
{
#ifndef __WXGTK3__
gtk_status_icon_set_tooltip(m_statusIcon, tip_text);
#endif
}
}
else
#endif // GTK_CHECK_VERSION(2,10,0)
{
#ifndef __WXGTK3__
if (tip_text && m_tooltips == NULL)
{
m_tooltips = gtk_tooltips_new();
g_object_ref(m_tooltips);
gtk_object_sink(GTK_OBJECT(m_tooltips));
}
if (m_tooltips)
gtk_tooltips_set_tip(m_tooltips, m_eggTrayIcon, tip_text, "");
#endif
}
#endif // wxUSE_TOOLTIPS
}
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
GtkWidget *menuItem;
GtkWidget* prevRadio = m_prevRadio;
m_prevRadio = NULL;
switch (mitem->GetKind())
{
case wxITEM_SEPARATOR:
menuItem = gtk_separator_menu_item_new();
break;
case wxITEM_CHECK:
menuItem = gtk_check_menu_item_new_with_label("");
break;
case wxITEM_RADIO:
{
GSList* group = NULL;
if (prevRadio)
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio));
menuItem = gtk_radio_menu_item_new_with_label(group, "");
m_prevRadio = menuItem;
}
break;
default:
wxFAIL_MSG("unexpected menu item kind");
// fall through
case wxITEM_NORMAL:
const wxBitmap& bitmap = mitem->GetBitmap();
const char* stockid;
if (bitmap.IsOk())
{
// always use pixbuf, because pixmap mask does not
// work with disabled images in some themes
GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
menuItem = gtk_image_menu_item_new_with_label("");
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
}
else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
// use stock bitmap for this item if available on the assumption
// that it never hurts to follow GTK+ conventions more closely
menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
else
menuItem = gtk_menu_item_new_with_label("");
break;
}
mitem->SetMenuItem(menuItem);
gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
gtk_widget_show( menuItem );
if ( !mitem->IsSeparator() )
{
mitem->SetGtkLabel();
g_signal_connect (menuItem, "select",
G_CALLBACK(menuitem_select), mitem);
g_signal_connect (menuItem, "deselect",
G_CALLBACK(menuitem_deselect), mitem);
if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
{
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
gtk_widget_show( mitem->GetSubMenu()->m_menu );
}
else
{
g_signal_connect(menuItem, "can_activate_accel",
G_CALLBACK(can_activate_accel), this);
g_signal_connect (menuItem, "activate",
G_CALLBACK(menuitem_activate),
mitem);
}
}
return true;
}
