int
main (int argc, char **argv)
{
char *text;
GtkWidget *window;
GtkWidget *scrollwin;
GtkWidget *vbox, *hbox;
GtkWidget *frame;
GtkWidget *checkbutton;
gtk_init (&argc, &argv);
if (argc != 2)
{
fprintf (stderr, "Usage: %s FILE\n", g_get_prgname ());
exit(1);
}
/* Create the list of paragraphs from the supplied file
*/
text = read_file (argv[1]);
if (!text)
exit(1);
context = pango_win32_get_context ();
paragraphs = split_paragraphs (text);
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family(font_description, "sans");
pango_font_description_set_size(font_description, 16 * PANGO_SCALE);
#if 0 /* default init ok? */
font_description.style = PANGO_STYLE_NORMAL;
font_description.variant = PANGO_VARIANT_NORMAL;
font_description.weight = 500;
font_description.stretch = PANGO_STRETCH_NORMAL;
#endif
pango_context_set_font_description (context, font_description);
/* Create the user interface
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = make_font_selector ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrollwin, TRUE, TRUE, 0);
layout = gtk_layout_new (NULL, NULL);
gtk_widget_set_events (layout, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_app_paintable (layout, TRUE);
gtk_signal_connect (GTK_OBJECT (layout), "size_allocate",
GTK_SIGNAL_FUNC (size_allocate), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
GTK_SIGNAL_FUNC (expose), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "draw",
GTK_SIGNAL_FUNC (draw), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "button_press_event",
GTK_SIGNAL_FUNC (button_press), paragraphs);
#if GTK_CHECK_VERSION (1,3,2)
gtk_widget_set_double_buffered (layout, FALSE);
#endif
gtk_container_add (GTK_CONTAINER (scrollwin), layout);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
message_label = gtk_label_new ("Current char:");
gtk_misc_set_padding (GTK_MISC (message_label), 1, 1);
gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), message_label);
checkbutton = gtk_check_button_new_with_label ("Use RTL global direction");
gtk_signal_connect (GTK_OBJECT (checkbutton), "toggled",
GTK_SIGNAL_FUNC (checkbutton_toggled), NULL);
gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
// Create and handle the plugin's dialog
gboolean dialog(PluginData *pd)
{
gimp_ui_init (PLUG_IN_BINARY, FALSE);
GtkWidget *dialog, *main_hbox, *hbox_buttons, *preview, *graph, *vbox, *preview_button, *preview_hd_checkbox;
dialog = gimp_dialog_new ("Frequency Curves", PLUG_IN_BINARY,
NULL, (GtkDialogFlags)0,
gimp_standard_help_func, PLUG_IN_NAME,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
gtk_container_add (GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), main_hbox);
curve_init(&pd->curve_user);
curve_copy(&pd->curve_user, &pd->curve_fft);
pd->preview = gimp_drawable_preview_new (pd->drawable, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), pd->preview, TRUE, TRUE, 0);
gtk_widget_show (pd->preview);
g_signal_connect_swapped (pd->preview, "invalidated", G_CALLBACK (preview_invalidated), pd);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_container_add (GTK_CONTAINER(main_hbox), vbox);
gtk_widget_show(vbox);
graph = pd->graph = gtk_drawing_area_new();
pd->graph_pixmap = NULL;
gtk_widget_set_size_request (graph, GRAPH_WIDTH, GRAPH_HEIGHT);
gtk_widget_set_events (graph, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK | GDK_ENTER_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON1_MOTION_MASK);
gtk_container_add (GTK_CONTAINER (vbox), graph);
gtk_widget_show (graph);
g_signal_connect (graph, "event", G_CALLBACK (graph_events), pd);
hbox_buttons = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox_buttons), 12);
gtk_container_add (GTK_CONTAINER(vbox), hbox_buttons);
gtk_widget_show(hbox_buttons);
preview_button = gtk_button_new_with_mnemonic ("HD _Preview");
gtk_box_pack_start (GTK_BOX (hbox_buttons), preview_button, FALSE, FALSE, 0);
gtk_widget_show (preview_button);
g_signal_connect (preview_button, "clicked", G_CALLBACK (preview_hd), pd);
preview_hd_checkbox = gtk_check_button_new_with_label("Always preview HD");
gtk_box_pack_start (GTK_BOX (hbox_buttons), preview_hd_checkbox, FALSE, FALSE, 0);
gtk_widget_show (preview_hd_checkbox);
pd->do_preview_hd = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(preview_hd_checkbox), FALSE);
g_signal_connect (preview_hd_checkbox, "toggled", G_CALLBACK (preview_hd_toggled), pd);
gtk_widget_show(main_hbox);
gtk_widget_show(dialog);
fft_prepare(pd);
histogram_generate(pd);
wavelet_prepare(pd);
gboolean run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
// set the region mode to actual writing
gimp_pixel_rgn_init(&pd->region, pd->drawable, 0, 0, pd->image_width, pd->image_height, TRUE, TRUE);
fft_apply(pd);
gimp_pixel_rgn_set_rect(&pd->region, pd->img_pixels, 0, 0, pd->image_width, pd->image_height);
// show the result
gimp_drawable_flush(pd->drawable);
gimp_drawable_merge_shadow(pd->drawable->drawable_id, TRUE);
gimp_drawable_update(pd->drawable->drawable_id, pd->selection_offset_x, pd->selection_offset_y, pd->selection_width, pd->selection_height);
gimp_displays_flush();
}
fft_destroy(pd);
wavelet_destroy(pd);
gtk_widget_destroy (dialog);
return run;
}
AppletInfo *
mate_panel_applet_register (GtkWidget *applet,
gpointer data,
GDestroyNotify data_destroy,
PanelWidget *panel,
gboolean locked,
gint pos,
gboolean exactpos,
PanelObjectType type,
const char *id)
{
AppletInfo *info;
gchar *path;
gchar *locked_changed;
g_return_val_if_fail (applet != NULL && panel != NULL, NULL);
if (gtk_widget_get_has_window (applet))
gtk_widget_set_events (applet, (gtk_widget_get_events (applet) |
APPLET_EVENT_MASK) &
~( GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK));
info = g_new0 (AppletInfo, 1);
info->type = type;
info->widget = applet;
info->menu = NULL;
info->data = data;
info->data_destroy = data_destroy;
info->user_menu = NULL;
info->move_item = NULL;
info->id = g_strdup (id);
path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", id);
info->settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path);
g_free (path);
g_object_set_data (G_OBJECT (applet), "applet_info", info);
if (type != PANEL_OBJECT_APPLET)
panel_lockdown_notify_add (G_CALLBACK (mate_panel_applet_recreate_menu),
info);
locked_changed = g_strdup_printf ("changed::%s", PANEL_OBJECT_LOCKED_KEY);
g_signal_connect (info->settings,
locked_changed,
G_CALLBACK (mate_panel_applet_locked_change_notify),
G_OBJECT (applet));
g_free (locked_changed);
if (type == PANEL_OBJECT_DRAWER) {
Drawer *drawer = data;
PanelWidget *assoc_panel;
assoc_panel = panel_toplevel_get_panel_widget (drawer->toplevel);
g_object_set_data (G_OBJECT (applet),
MATE_PANEL_APPLET_ASSOC_PANEL_KEY, assoc_panel);
assoc_panel->master_widget = applet;
g_object_add_weak_pointer (
G_OBJECT (applet), (gpointer *) &assoc_panel->master_widget);
}
g_object_set_data (G_OBJECT (applet),
MATE_PANEL_APPLET_FORBIDDEN_PANELS, NULL);
registered_applets = g_slist_append (registered_applets, info);
if (panel_widget_add (panel, applet, locked, pos, exactpos) == -1 &&
panel_widget_add (panel, applet, locked, 0, TRUE) == -1) {
GSList *l;
for (l = panels; l; l = l->next) {
panel = PANEL_WIDGET (l->data);
if (panel_widget_add (panel, applet, locked, 0, TRUE) != -1)
break;
}
if (!l) {
g_warning (_("Cannot find an empty spot"));
panel_profile_delete_object (info);
return NULL;
}
}
if (BUTTON_IS_WIDGET (applet) ||
gtk_widget_get_has_window (applet)) {
g_signal_connect (applet, "button_press_event",
G_CALLBACK (applet_button_press),
info);
g_signal_connect (applet, "popup_menu",
G_CALLBACK (applet_popup_menu),
info);
}
g_signal_connect (applet, "destroy",
G_CALLBACK (mate_panel_applet_destroy),
info);
mate_panel_applet_set_dnd_enabled (info, !locked);
gtk_widget_show_all (applet);
orientation_change (info, panel);
size_change (info, panel);
back_change (info, panel);
if (type != PANEL_OBJECT_APPLET)
gtk_widget_grab_focus (applet);
else
gtk_widget_child_focus (applet, GTK_DIR_TAB_FORWARD);
return info;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *drawing_area;
GtkWidget *vbox;
GtkWidget *button;
gtk_init (&argc, &argv);
current_device = gdk_device_get_core_pointer ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (window, "Test Input");
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
g_signal_connect (window, "destroy",
G_CALLBACK (quit), NULL);
/* Create the drawing area */
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/* Signals used to handle backing pixmap */
g_signal_connect (drawing_area, "expose_event",
G_CALLBACK (expose_event), NULL);
g_signal_connect (drawing_area, "configure_event",
G_CALLBACK (configure_event), NULL);
/* Event signals */
g_signal_connect (drawing_area, "motion_notify_event",
G_CALLBACK (motion_notify_event), NULL);
g_signal_connect (drawing_area, "button_press_event",
G_CALLBACK (button_press_event), NULL);
g_signal_connect (drawing_area, "key_press_event",
G_CALLBACK (key_press_event), NULL);
g_signal_connect (drawing_area, "leave_notify_event",
G_CALLBACK (leave_notify_event), NULL);
g_signal_connect (drawing_area, "proximity_out_event",
G_CALLBACK (proximity_out_event), NULL);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_KEY_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_PROXIMITY_OUT_MASK);
/* The following call enables tracking and processing of extension
events for the drawing area */
gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_ALL);
GTK_WIDGET_SET_FLAGS (drawing_area, GTK_CAN_FOCUS);
gtk_widget_grab_focus (drawing_area);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Input Dialog");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (create_input_dialog), NULL);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
void init_stuff (int argc, char *argv[])
{
GtkWidget *w;
GList *dev_list;
GdkDevice *device;
GdkScreen *screen;
int i, j;
struct Brush *b;
gboolean can_xinput, success;
gchar *tmppath, *tmpfn;
// create some data structures needed to populate the preferences
ui.default_page.bg = g_new(struct Background, 1);
// initialize config file names
tmppath = g_build_filename(g_get_home_dir(), CONFIG_DIR, NULL);
mkdir(tmppath, 0700); // safer (MRU data may be confidential)
ui.mrufile = g_build_filename(tmppath, MRU_FILE, NULL);
ui.configfile = g_build_filename(tmppath, CONFIG_FILE, NULL);
g_free(tmppath);
// initialize preferences
init_config_default();
load_config_from_file();
ui.font_name = g_strdup(ui.default_font_name);
ui.font_size = ui.default_font_size;
ui.hiliter_alpha_mask = 0xffffff00 + (guint)(255*ui.hiliter_opacity);
// we need an empty canvas prior to creating the journal structures
canvas = GNOME_CANVAS (gnome_canvas_new_aa ());
// initialize data
ui.default_page.bg->canvas_item = NULL;
ui.layerbox_length = 0;
if (argc > 2 || (argc == 2 && argv[1][0] == '-')) {
printf(_("Invalid command line parameters.\n"
"Usage: %s [filename.xoj]\n"), argv[0]);
gtk_exit(0);
}
undo = NULL; redo = NULL;
journal.pages = NULL;
bgpdf.status = STATUS_NOT_INIT;
new_journal();
ui.cur_item_type = ITEM_NONE;
ui.cur_item = NULL;
ui.cur_path.coords = NULL;
ui.cur_path_storage_alloc = 0;
ui.cur_path.ref_count = 1;
ui.cur_widths = NULL;
ui.cur_widths_storage_alloc = 0;
ui.selection = NULL;
ui.cursor = NULL;
ui.pen_cursor_pix = ui.hiliter_cursor_pix = NULL;
ui.cur_brush = &(ui.brushes[0][ui.toolno[0]]);
for (j=0; j<=NUM_BUTTONS; j++)
for (i=0; i < NUM_STROKE_TOOLS; i++) {
b = &(ui.brushes[j][i]);
b->tool_type = i;
if (b->color_no>=0) {
b->color_rgba = predef_colors_rgba[b->color_no];
if (i == TOOL_HIGHLIGHTER) {
b->color_rgba &= ui.hiliter_alpha_mask;
}
}
b->thickness = predef_thickness[i][b->thickness_no];
}
for (i=0; i<NUM_STROKE_TOOLS; i++)
g_memmove(ui.default_brushes+i, &(ui.brushes[0][i]), sizeof(struct Brush));
ui.cur_mapping = 0;
ui.which_unswitch_button = 0;
ui.in_proximity = FALSE;
ui.warned_generate_fontconfig = FALSE;
reset_recognizer();
// initialize various interface elements
gtk_window_set_default_size(GTK_WINDOW (winMain), ui.window_default_width, ui.window_default_height);
if (ui.maximize_at_start) gtk_window_maximize(GTK_WINDOW (winMain));
update_toolbar_and_menu();
update_font_button();
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalApplyAllPages")), ui.bg_apply_all_pages);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalNewPageKeepsBG")), ui.new_page_bg_from_pdf);
if (ui.fullscreen) {
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), TRUE);
gtk_toggle_tool_button_set_active(
GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), TRUE);
gtk_window_fullscreen(GTK_WINDOW(winMain));
}
gtk_button_set_relief(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")), GTK_RELIEF_NONE);
allow_all_accels();
add_scroll_bindings();
// prevent interface items from stealing focus
// glade doesn't properly handle can_focus, so manually set it
gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(GET_COMPONENT("comboLayer")), FALSE);
g_signal_connect(GET_COMPONENT("spinPageNo"), "activate",
G_CALLBACK(handle_activate_signal), NULL);
gtk_container_forall(GTK_CONTAINER(winMain), unset_flags, (gpointer)GTK_CAN_FOCUS);
GTK_WIDGET_SET_FLAGS(GTK_WIDGET(canvas), GTK_CAN_FOCUS);
GTK_WIDGET_SET_FLAGS(GTK_WIDGET(GET_COMPONENT("spinPageNo")), GTK_CAN_FOCUS);
// install hooks on button/key/activation events to make the spinPageNo lose focus
gtk_container_forall(GTK_CONTAINER(winMain), install_focus_hooks, NULL);
// set up and initialize the canvas
gtk_widget_show (GTK_WIDGET (canvas));
w = GET_COMPONENT("scrolledwindowMain");
gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (canvas));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_events (GTK_WIDGET (canvas),
GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_PROXIMITY_IN_MASK | GDK_PROXIMITY_OUT_MASK);
gnome_canvas_set_pixels_per_unit (canvas, ui.zoom);
gnome_canvas_set_center_scroll_region (canvas, TRUE);
gtk_layout_get_hadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment;
gtk_layout_get_vadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment;
// set up the page size and canvas size
update_page_stuff();
g_signal_connect ((gpointer) canvas, "button_press_event",
G_CALLBACK (on_canvas_button_press_event),
NULL);
g_signal_connect ((gpointer) canvas, "button_release_event",
G_CALLBACK (on_canvas_button_release_event),
NULL);
g_signal_connect ((gpointer) canvas, "enter_notify_event",
G_CALLBACK (on_canvas_enter_notify_event),
NULL);
g_signal_connect ((gpointer) canvas, "leave_notify_event",
G_CALLBACK (on_canvas_leave_notify_event),
NULL);
g_signal_connect ((gpointer) canvas, "proximity_in_event",
G_CALLBACK (on_canvas_proximity_event),
NULL);
g_signal_connect ((gpointer) canvas, "proximity_out_event",
G_CALLBACK (on_canvas_proximity_event),
NULL);
g_signal_connect ((gpointer) canvas, "expose_event",
G_CALLBACK (on_canvas_expose_event),
NULL);
g_signal_connect ((gpointer) canvas, "key_press_event",
G_CALLBACK (on_canvas_key_press_event),
NULL);
g_signal_connect ((gpointer) canvas, "motion_notify_event",
G_CALLBACK (on_canvas_motion_notify_event),
NULL);
g_signal_connect ((gpointer) gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)),
"value-changed", G_CALLBACK (on_vscroll_changed),
NULL);
g_signal_connect ((gpointer) gtk_layout_get_hadjustment(GTK_LAYOUT(canvas)),
"value-changed", G_CALLBACK (on_hscroll_changed),
NULL);
g_object_set_data (G_OBJECT (winMain), "canvas", canvas);
screen = gtk_widget_get_screen(winMain);
ui.screen_width = gdk_screen_get_width(screen);
ui.screen_height = gdk_screen_get_height(screen);
can_xinput = FALSE;
dev_list = gdk_devices_list();
while (dev_list != NULL) {
device = (GdkDevice *)dev_list->data;
if (device != gdk_device_get_core_pointer() && device->num_axes >= 2) {
/* get around a GDK bug: map the valuator range CORRECTLY to [0,1] */
#ifdef ENABLE_XINPUT_BUGFIX
gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE);
gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE);
#endif
gdk_device_set_mode(device, GDK_MODE_SCREEN);
if (g_strrstr(device->name, "raser"))
gdk_device_set_source(device, GDK_SOURCE_ERASER);
can_xinput = TRUE;
}
dev_list = dev_list->next;
}
if (!can_xinput)
gtk_widget_set_sensitive(GET_COMPONENT("optionsUseXInput"), FALSE);
ui.use_xinput = ui.allow_xinput && can_xinput;
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsProgressiveBG")), ui.progressive_bg);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPrintRuling")), ui.print_ruling);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoloadPdfXoj")), ui.autoload_pdf_xoj);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutosaveXoj")), ui.autosave_enabled);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLeftHanded")), ui.left_handed);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsShortenMenus")), ui.shorten_menus);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoSavePrefs")), ui.auto_save_prefs);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonSwitchMapping")), ui.button_switch_mapping);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPenCursor")), ui.pen_cursor);
hide_unimplemented();
update_undo_redo_enabled();
update_copy_paste_enabled();
update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]);
gtk_widget_grab_focus(GTK_WIDGET(canvas));
// show everything...
gtk_widget_show (winMain);
update_cursor();
/* this will cause extension events to get enabled/disabled, but
we need the windows to be mapped first */
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsUseXInput")), ui.use_xinput);
/* fix a bug in GTK+ 2.16 and 2.17: scrollbars shouldn't get extended
input events from pointer motion when cursor moves into main window */
if (!gtk_check_version(2, 16, 0)) {
g_signal_connect (
GET_COMPONENT("menubar"),
"event", G_CALLBACK (filter_extended_events),
NULL);
g_signal_connect (
GET_COMPONENT("toolbarMain"),
"event", G_CALLBACK (filter_extended_events),
NULL);
g_signal_connect (
GET_COMPONENT("toolbarPen"),
"event", G_CALLBACK (filter_extended_events),
NULL);
g_signal_connect (
GET_COMPONENT("statusbar"),
"event", G_CALLBACK (filter_extended_events),
NULL);
g_signal_connect (
(gpointer)(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(w))),
"event", G_CALLBACK (filter_extended_events),
NULL);
g_signal_connect (
(gpointer)(gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(w))),
"event", G_CALLBACK (filter_extended_events),
NULL);
}
// load the MRU
init_mru();
// and finally, open a file specified on the command line
// (moved here because display parameters weren't initialized yet...)
if (argc == 1) return;
set_cursor_busy(TRUE);
if (g_path_is_absolute(argv[1]))
tmpfn = g_strdup(argv[1]);
else {
tmppath = g_get_current_dir();
tmpfn = g_build_filename(tmppath, argv[1], NULL);
g_free(tmppath);
}
success = open_journal(tmpfn);
g_free(tmpfn);
set_cursor_busy(FALSE);
if (!success) {
w = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), argv[1]);
gtk_dialog_run(GTK_DIALOG(w));
gtk_widget_destroy(w);
}
}
/*********************************************
* AddReferenceImage関数 *
* 参考用画像の表示を追加 *
* 引数 *
* reference : 参考用画像表示ウィンドウの情報 *
* file_name : 追加するファイル名 *
* pixels : 画像のピクセルデータ *
* width : 画像の幅 *
* height : 画像の高さ *
* stride : 画像の1行分のバイト数 *
* channel : 画像のチャンネル数 *
*********************************************/
static void AddReferenceImage(
REFERENCE_WINDOW* reference,
const char* file_name,
uint8* pixels,
int width,
int height,
int stride,
int channel
)
{
GtkWidget *tab_label;
GtkWidget *alignment;
cairo_format_t format = (stride / width == 4) ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24;
REFERENCE_IMAGE *image;
image = reference->data->images[reference->data->num_image] =
(REFERENCE_IMAGE*)MEM_ALLOC_FUNC(sizeof(**reference->data->images));
image->pixels = pixels;
image->width = width;
image->height = height;
image->stride = stride;
image->channel = (uint8)channel;
image->surface_p = cairo_image_surface_create_for_data(image->pixels,
format, image->width, image->height, image->stride);
image->zoom = image->rev_zoom = 1;
image->app = reference->app;
image->draw_area = gtk_drawing_area_new();
gtk_widget_set_size_request(image->draw_area, image->width, image->height);
gtk_widget_set_events(image->draw_area, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
(void)g_signal_connect(G_OBJECT(image->draw_area), "destroy",
G_CALLBACK(OnDestroyReferenceImageDrawArea), image);
#if GTK_MAJOR_VERSION <= 2
(void)g_signal_connect(G_OBJECT(image->draw_area), "expose_event",
G_CALLBACK(DisplayReferenceImage), image);
#else
(void)g_signal_connect(G_OBJECT(image->draw_area), "draw",
G_CALLBACK(DisplayReferenceImage), image);
#endif
(void)g_signal_connect(G_OBJECT(image->draw_area), "button_press_event",
G_CALLBACK(ReferenceImageButtonPress), image);
alignment = gtk_alignment_new(0.5f, 0.5f, 0.0f, 0.0f);
gtk_container_add(GTK_CONTAINER(alignment), image->draw_area);
image->scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(image->scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(image->scroll), alignment);
tab_label = CreateNotebookLabel(file_name, reference->data->note_book, reference->data->num_image,
OnCloseReferenceImage, reference);
gtk_notebook_append_page(GTK_NOTEBOOK(reference->data->note_book), image->scroll, tab_label);
gtk_widget_show_all(image->scroll);
gtk_widget_set_sensitive(reference->data->scale, TRUE);
reference->data->active_image = reference->data->num_image;
#if GTK_MAJOR_VERSION <= 2
gtk_notebook_set_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image);
#else
gtk_notebook_set_current_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image);
#endif
reference->data->num_image++;
}
int main( int argc,char *argv[] )
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget* menubar;
GtkWidget* main_toolbar;
GtkWidget* tools_toolbar;
GtkWidget* colortable;
GtkWidget* frame;
gtk_init (&argc, &argv);
modified=0;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Illuminati");
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (delete_event), NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
/*To create the menu bar*/
menubar = get_menubar_menu (window);
gtk_box_pack_start (GTK_BOX(vbox),menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
main_toolbar=get_main_toolbar();
/* to make it nice we'll put the toolbar into the handle box,
* so that it can be detached from the main window */
mainhandlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (vbox),mainhandlebox, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (mainhandlebox), main_toolbar);
gtk_widget_show (main_toolbar);
gtk_widget_show (mainhandlebox);
/*hbox for tools_toolbar and drawing area*/
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox),hbox, FALSE, FALSE, 0);
tools_toolbar=get_tools_toolbar();
toolhandlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX(hbox),toolhandlebox, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (toolhandlebox), tools_toolbar);
gtk_widget_show (tools_toolbar);
gtk_widget_show (toolhandlebox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (GTK_WIDGET (scrolled_win),400,400);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_win, TRUE, TRUE, 0);
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (drawing_area),800,600);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),drawing_area);
gtk_widget_show (drawing_area);
gtk_widget_show (scrolled_win);
gtk_widget_show (hbox);
/* Signals used to handle backing pixmap */
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
g_signal_connect (G_OBJECT (drawing_area),"configure_event",
G_CALLBACK (configure_event), NULL);
/* Event signals */
g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
G_CALLBACK (motion_notify_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
G_CALLBACK (button_press_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "button_release_event",
G_CALLBACK(button_release_event),NULL);
gtk_widget_set_events (drawing_area,GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_RELEASE_MASK);
hbox = gtk_hbox_new (FALSE,0);
gtk_box_pack_start(GTK_BOX (vbox),hbox, FALSE, FALSE, 2);
frame=get_fgbgframe();
gtk_box_pack_start(GTK_BOX (hbox),frame, FALSE, FALSE, 2);
gtk_widget_show(frame);
colortable=get_system_color_table();
frame=gtk_frame_new("select color");
gtk_widget_set_size_request (GTK_WIDGET (frame),400,75);
gtk_box_pack_start(GTK_BOX (hbox),frame, TRUE, TRUE, 2);
gtk_container_add(GTK_CONTAINER(frame),colortable);
gtk_widget_show (colortable);
gtk_widget_show(frame);
gtk_widget_show (hbox);
gtk_widget_show(vbox);
gtk_widget_show(window);
/*Initial tool set to PENCIL */
display=gdk_display_get_default();
cursor=gdk_cursor_new(GDK_PENCIL);
gdk_window_set_cursor(drawing_area->window,cursor);
tool=PENCIL;
gtk_button_set_relief(GTK_BUTTON(pencil_button),GTK_RELIEF_NORMAL);
filename=g_strdup("Untitled.jpeg");
pixmap = gdk_pixmap_new (drawing_area->window,
drawing_area->allocation.width,
drawing_area->allocation.height,
-1);
gdk_draw_rectangle (pixmap,
drawing_area->style->white_gc,
TRUE,
0, 0,
drawing_area->allocation.width,
drawing_area->allocation.height);
gtk_main ();
return 0;
}
GtkWidget *
do_drawingarea (GtkWidget *do_widget)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *da;
GtkWidget *label;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Drawing Area");
g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
/*
* Create the checkerboard area
*/
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Checkerboard pattern</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
da = gtk_drawing_area_new ();
/* set a minimum size */
gtk_widget_set_size_request (da, 100, 100);
gtk_container_add (GTK_CONTAINER (frame), da);
g_signal_connect (da, "expose-event",
G_CALLBACK (checkerboard_expose), NULL);
/*
* Create the scribble area
*/
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Scribble area</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
da = gtk_drawing_area_new ();
/* set a minimum size */
gtk_widget_set_size_request (da, 100, 100);
gtk_container_add (GTK_CONTAINER (frame), da);
/* Signals used to handle backing pixmap */
g_signal_connect (da, "expose-event",
G_CALLBACK (scribble_expose_event), NULL);
g_signal_connect (da,"configure-event",
G_CALLBACK (scribble_configure_event), NULL);
/* Event signals */
g_signal_connect (da, "motion-notify-event",
G_CALLBACK (scribble_motion_notify_event), NULL);
g_signal_connect (da, "button-press-event",
G_CALLBACK (scribble_button_press_event), NULL);
/* Ask to receive events the drawing area doesn't normally
* subscribe to
*/
gtk_widget_set_events (da, gtk_widget_get_events (da)
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_collect_t *d = (dt_lib_collect_t *)malloc(sizeof(dt_lib_collect_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 5);
gtk_widget_set_size_request(self->widget, 100, -1);
d->active_rule = 0;
d->params = (dt_lib_collect_params_t*)malloc(sizeof(dt_lib_collect_params_t));
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_COLLECTION_CHANGED,
G_CALLBACK(collection_updated),
self);
GtkBox *box;
GtkWidget *w;
GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL);
GtkTreeView *view = GTK_TREE_VIEW(gtk_tree_view_new());
d->view = view;
GtkListStore *liststore;
for(int i=0; i<MAX_RULES; i++)
{
d->rule[i].num = i;
box = GTK_BOX(gtk_hbox_new(FALSE, 5));
d->rule[i].hbox = GTK_WIDGET(box);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
w = gtk_combo_box_new_text();
d->rule[i].combo = GTK_COMBO_BOX(w);
for(int k=0; k<dt_lib_collect_string_cnt; k++)
gtk_combo_box_append_text(GTK_COMBO_BOX(w), _(dt_lib_collect_string[k]));
g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(combo_changed), d->rule + i);
gtk_box_pack_start(box, w, FALSE, FALSE, 0);
w = gtk_entry_new();
dt_gui_key_accel_block_on_focus(w);
d->rule[i].text = w;
gtk_widget_add_events(w, GDK_FOCUS_CHANGE_MASK);
g_signal_connect(G_OBJECT(w), "focus-in-event", G_CALLBACK(entry_focus_in_callback), d->rule + i);
/* xgettext:no-c-format */
g_object_set(G_OBJECT(w), "tooltip-text", _("type your query, use `%' as wildcard"), (char *)NULL);
gtk_widget_add_events(w, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(changed_callback), d->rule + i);
g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), d->rule + i);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
w = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
d->rule[i].button = w;
gtk_widget_set_events(w, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "button-press-event", G_CALLBACK(popup_button_callback), d->rule + i);
gtk_box_pack_start(box, w, FALSE, FALSE, 0);
gtk_widget_set_size_request(w, 13, 13);
}
d->scrolledwindow = GTK_SCROLLED_WINDOW(sw);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(view));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(sw), TRUE, TRUE, 0);
gtk_tree_view_set_headers_visible(view, FALSE);
liststore = gtk_list_store_new(DT_LIB_COLLECT_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, col);
gtk_widget_set_size_request(GTK_WIDGET(view), -1, 300);
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", DT_LIB_COLLECT_COL_TEXT);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(view, GTK_TREE_MODEL(liststore));
g_signal_connect(G_OBJECT (view), "row-activated", G_CALLBACK (row_activated), d);
/* setup proxy */
darktable.view_manager->proxy.module_collect.module = self;
darktable.view_manager->proxy.module_collect.update = _lib_collect_gui_update;
_lib_collect_gui_update(self);
}
void create_mainwindow (GooCanvasItem *rootitem)
{
GtkWidget *wdrawareagrande;
GtkWidget *wdrawareapetite;
/* GCompris : suppression of all menus */
g_assert(rootitem != NULL);
wdrawareagrande = gtk_drawing_area_new ();
gtk_widget_set_name (wdrawareagrande, "wdrawareagrande");
//gtk_widget_set_size_request (wdrawareagrande,
// WIDTH_BIGAREA,
// WIDTH_BIGAREA
// );
//gtk_container_add (GTK_CONTAINER (aspectframe1), wdrawareagrande);
gtk_widget_set_events (wdrawareagrande, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_STRUCTURE_MASK);
/* Gcompris */
goo_canvas_widget_new ( rootitem,
wdrawareagrande,
X_BASE_BIGAREA,
Y_BASE_BIGAREA,
WIDTH_BIGAREA,
WIDTH_BIGAREA,
NULL
);
gtk_widget_show (wdrawareagrande);
wdrawareapetite = gtk_drawing_area_new ();
gtk_widget_set_name (wdrawareapetite, "wdrawareapetite");
gtk_widget_set_events (wdrawareapetite, GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK);
/* Gcompris */
goo_canvas_widget_new ( rootitem,
wdrawareapetite,
X_BASE_SMALLAREA,
Y_BASE_SMALLAREA,
WIDTH_SMALLAREA,
WIDTH_SMALLAREA,
NULL
);
gtk_widget_show (wdrawareapetite);
g_signal_connect (GTK_OBJECT (wdrawareagrande), "expose_event",
GTK_SIGNAL_FUNC (on_wdrawareagrande_expose_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareagrande), "configure_event",
GTK_SIGNAL_FUNC (on_wdrawareagrande_configure_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareagrande), "button_press_event",
GTK_SIGNAL_FUNC (on_wdrawareagrande_button_press_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareagrande), "button_release_event",
GTK_SIGNAL_FUNC (on_wdrawareagrande_button_release_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareagrande), "motion_notify_event",
GTK_SIGNAL_FUNC (on_wdrawareagrande_motion_notify_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareapetite), "configure_event",
GTK_SIGNAL_FUNC (on_wdrawareapetite_configure_event),
NULL);
g_signal_connect (GTK_OBJECT (wdrawareapetite), "expose_event",
GTK_SIGNAL_FUNC (on_wdrawareapetite_expose_event),
NULL);
/* Gcompris */
/* add here buttons */
GdkPixbuf *pixmap_show = NULL;
GdkPixbuf *pixmap_outline = NULL;
GdkPixbuf *pixmap_symetry = NULL;
GooCanvasItem *previous_figure, *next_figure;
GooCanvasItem *show_figure, *outline_figure, *symetry;
previous_figure = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#PREVIOUS",
NULL);
SET_ITEM_LOCATION_CENTER(previous_figure,
X_BASE_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 30);
next_figure = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#NEXT",
NULL);
SET_ITEM_LOCATION_CENTER(next_figure,
X_BASE_SMALLAREA + WIDTH_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 30);
g_signal_connect(previous_figure, "button_press_event",
(GCallback) on_arrow_clicked,
(gpointer) FALSE);
gc_item_focus_init(previous_figure, NULL);
g_signal_connect(next_figure, "button_press_event",
(GCallback) on_arrow_clicked,
(gpointer) TRUE);
gc_item_focus_init(next_figure, NULL);
pixmap_show = gc_pixmap_load("tangram/gtans_show.png");
pixmap_outline = gc_pixmap_load("tangram/gtans_outline.png");
show_figure = goo_canvas_image_new (rootitem,
pixmap_show,
X_BASE_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 80,
NULL);
outline_figure = goo_canvas_image_new (rootitem,
pixmap_outline,
X_BASE_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 130,
NULL);
g_signal_connect(outline_figure, "button_press_event",
(GCallback) on_outline_clicked,
NULL);
g_signal_connect(show_figure, "button_press_event",
(GCallback) on_show_clicked,
NULL);
gc_item_focus_init(outline_figure, NULL);
gc_item_focus_init(show_figure, NULL);
pixmap_symetry = gc_pixmap_load("tangram/tool-flip.png");
symetry = goo_canvas_image_new (rootitem,
pixmap_symetry,
X_BASE_SMALLAREA + WIDTH_SMALLAREA - 50,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 180,
NULL);
g_signal_connect(symetry, "button_press_event",
(GCallback) on_symetry_clicked,
NULL);
gc_item_focus_init(symetry, NULL);
/* rotation buttons */
GdkPixbuf *right_rot = NULL;
GdkPixbuf *left_rot = NULL;
GdkPixbuf *right_rot_big = NULL;
GdkPixbuf *left_rot_big = NULL;
GooCanvasItem *l_rot_s, *r_rot_s, *l_rot_b, *r_rot_b;
right_rot = gc_pixmap_load("tangram/gtans_rotate.png");
left_rot = gc_pixmap_load("tangram/gtans_rotate-left.png");
r_rot_s = goo_canvas_image_new (rootitem,
right_rot,
X_BASE_SMALLAREA + WIDTH_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 60,
NULL);
l_rot_s = goo_canvas_image_new (rootitem,
left_rot,
X_BASE_SMALLAREA + WIDTH_SMALLAREA - 100,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 60,
NULL);
#if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24
gdk_pixbuf_unref(right_rot);
gdk_pixbuf_unref(left_rot);
#else
g_object_unref(right_rot);
g_object_unref(left_rot);
#endif
right_rot_big = gc_pixmap_load("tangram/gtans_2x-rotate.png");
left_rot_big = gc_pixmap_load("tangram/gtans_2x-rotate-left.png");
r_rot_b = goo_canvas_image_new (rootitem,
right_rot_big,
X_BASE_SMALLAREA + WIDTH_SMALLAREA,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 120,
NULL);
l_rot_b = goo_canvas_image_new (rootitem,
left_rot_big,
X_BASE_SMALLAREA + WIDTH_SMALLAREA - 100,
Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 120,
NULL);
#if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24
gdk_pixbuf_unref(right_rot_big);
gdk_pixbuf_unref(left_rot_big);
#else
g_object_unref(right_rot_big);
g_object_unref(left_rot_big);
#endif
g_signal_connect(r_rot_s, "button_press_event",
(GCallback) on_rotation_clicked,
(gpointer) 0);
gc_item_focus_init(r_rot_s, NULL);
g_signal_connect(l_rot_s, "button_press_event",
(GCallback) on_rotation_clicked,
(gpointer) 1);
gc_item_focus_init(l_rot_s, NULL);
g_signal_connect(r_rot_b, "button_press_event",
(GCallback) on_rotation_clicked,
(gpointer) 2);
gc_item_focus_init(r_rot_b, NULL);
g_signal_connect(l_rot_b, "button_press_event",
(GCallback) on_rotation_clicked,
(gpointer) 3);
gc_item_focus_init(l_rot_b, NULL);
}
void gui_init ()
{
GtkWidget *hbox = NULL, *vbox = NULL, *vbox1 = NULL, *frame = NULL;
GtkWidget *separator;
GtkAccelGroup *ag;
GtkItemFactoryEntry game_items [num_games+1];
GtkItemFactoryEntry items[] =
{
#if GTK_MAJOR_VERSION == 1
/* { "/_File", NULL, NULL, 0, "<Branch>" },
{ "/File/_Load game", "<control>L", menu_load_file_dialog, 0, "" },
{ "/File/_Save game", NULL, NULL, 0, "" },
{ "/File/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "" },
*/
{ "/_Game", NULL, NULL, 0, "<Branch>" },
{ "/Game/Select _Game", NULL, NULL, 0, "<LastBranch>" },
{ "/Game/_Levels", NULL, NULL, 0, "<Branch>"},
{ "/Game/Sep1", NULL, NULL, 0, "<Separator>" },
{ "/Game/_New", "<control>N", menu_start_stop_game, MENU_RESET_GAME, "" },
{ "/Game/_Start", "<control>G", menu_start_stop_game, MENU_START_GAME, "" },
{ "/Game/_Pause", "<control>P", menu_start_stop_game, MENU_STOP_GAME, "" },
{ "/Game/Sep2", NULL, NULL, 0, "<Separator>" },
{ "/Game/_Highscores", NULL, prefs_show_scores, 0, ""},
{ "/Game/_Zap Highscores", NULL, prefs_zap_highscores, 0, ""},
{ "/Game/Sep3", NULL, NULL, 0, "<Separator>" },
{ "/Game/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "" },
{ "/_Move", NULL, NULL, 0, "<Branch>" },
{ "/Move/_Back", "<control>B", menu_back_forw, MENU_BACK, "" },
{ "/Move/_Forward", "<control>F", menu_back_forw, MENU_FORW, "" },
{ "/Move/Sep1", NULL, NULL, 0, "<Separator>" },
{ "/Move/_Move Now", "<control>M",
(GtkItemFactoryCallback) ui_move_now_cb, 0, "" },
#else
/* { "/_File", NULL, NULL, 0, "<Branch>" },
{ "/File/_Load game", "<control>L", menu_load_file_dialog, 0,
"<StockItem>", GTK_STOCK_OPEN },
{ "/File/_Save game", NULL, menu_save_file_dialog, 0,
"<StockItem>", GTK_STOCK_SAVE },
{ "/File/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0,
"<StockItem>", GTK_STOCK_QUIT },
*/
{ "/_Game", NULL, NULL, 0, "<Branch>" },
{ "/Game/Select _Game", NULL, NULL, 0, "<LastBranch>" },
{ "/Game/Levels", NULL, NULL, 0, "<Branch>"},
{ "/Game/Sep1", NULL, NULL, 0, "<Separator>" },
{ "/Game/_New", "<control>N", menu_start_stop_game, MENU_RESET_GAME,
"<StockItem>", GTK_STOCK_NEW },
{ "/Game/_Start", "<control>G", menu_start_stop_game, MENU_START_GAME,
"<StockItem>", GTK_STOCK_YES },
{ "/Game/_Pause", "<control>P", menu_start_stop_game, MENU_STOP_GAME,
"<StockItem>", GTK_STOCK_STOP },
{ "/Game/Sep2", NULL, NULL, 0, "<Separator>" },
//FIXME: there's a scores stock item but I can't seem to find it
{ "/Game/_Highscores", NULL, prefs_show_scores, 0, ""},
{ "/Game/_Zap Highscores", NULL, prefs_zap_highscores, 0, ""},
{ "/Game/Sep3", NULL, NULL, 0, "<Separator>" },
{ "/Game/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0,
"<StockItem>", GTK_STOCK_QUIT },
{ "/_Move", NULL, NULL, 0, "<Branch>" },
{ "/Move/_Back", "<control>B", menu_back_forw, 1,
"<StockItem>", GTK_STOCK_GO_BACK },
{ "/Move/_Forward", "<control>F", menu_back_forw, 2,
"<StockItem>", GTK_STOCK_GO_FORWARD },
{ "/Move/Sep1", NULL, NULL, 0, "<Separator>" },
{ "/Move/_Move Now", "<control>M",
(GtkItemFactoryCallback) ui_move_now_cb, 0, "" },
#endif
{ "/_Settings", NULL, NULL, 0, "<Branch>" },
{ "/Settings/_Player", NULL, NULL, 0, "<Branch>" },
{ "/Settings/Player/File", NULL, NULL, 0, "<RadioItem>" },
{ "/Settings/Player/Human-Human", NULL, menu_set_player, 1, "/Settings/Player/File" },
{ "/Settings/Player/Human-Machine", NULL, menu_set_player, 2,
"/Settings/Player/File" },
{ "/Settings/Player/Machine-Human", NULL, menu_set_player, 3,
"/Settings/Player/File" },
{ "/Settings/Player/Machine-Machine", NULL, menu_set_player, 4,
"/Settings/Player/File" },
// { "/Settings/_Eval function", NULL, NULL, 0, "<Branch>" },
// { "/Settings/_Eval function/_White", NULL, NULL, 0, "<Branch>" },
// { "/Settings/_Eval function/_Black", NULL, NULL, 0, "<Branch>" },
{ "/Settings/_Flip Board", "<control>T", menu_board_flip_cb, 0, "" },
{ "/Settings/_Enable Sound", NULL, menu_enable_sound_cb, 1, ""},
{ "/Settings/_Disable Sound", NULL, menu_enable_sound_cb, 0, ""},
{ "/Settings/_Time per move", NULL, NULL, 0, "<Branch>" },
{ "/Settings/_Time per move/Default", NULL,
menu_set_delay_cb, DEF_TIME_PER_MOVE, "<RadioItem>" },
{ "/Settings/_Time per move/100 milliseconds", NULL,
menu_set_delay_cb, 100, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/200 milliseconds", NULL,
menu_set_delay_cb, 200, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/500 milliseconds", NULL,
menu_set_delay_cb, 500, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/1 second", NULL,
menu_set_delay_cb, 1000, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/2 seconds", NULL,
menu_set_delay_cb, 2000, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/5 seconds", NULL,
menu_set_delay_cb, 5000, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/10 seconds", NULL,
menu_set_delay_cb, 10000, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/30 seconds", NULL,
menu_set_delay_cb, 30000, "/Settings/Time per move/Default" },
{ "/Settings/Time per move/1 minute", NULL,
menu_set_delay_cb, 600000, "/Settings/Time per move/Default" },
{ "/_Help", NULL, NULL, 0, "<Branch>" },
{ "/Help/_About", NULL, menu_show_about_dialog, 0, ""},
#ifdef HAVE_GNOME
{ "/Help/_Home Page", NULL, menu_help_home_page, 0, "<StockItem>", GTK_STOCK_HOME},
#endif
// TODO: implement context help
// { "/Help/_Context help", NULL, ui_set_context_help, 0, ""},
};
int i;
gdk_rgb_init ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy (GTK_WINDOW (main_window), FALSE, FALSE, TRUE);
gtk_signal_connect (GTK_OBJECT (main_window), "delete_event",
GTK_SIGNAL_FUNC(ui_cleanup), NULL);
gtk_window_set_title (GTK_WINDOW (main_window), "Gtkboard");
ag = gtk_accel_group_new();
menu_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", ag);
gtk_window_add_accel_group (GTK_WINDOW (main_window), ag);
gtk_item_factory_create_items (menu_factory,
sizeof (items) / sizeof (items[0]), items, NULL);
for (i=0; i<=num_games; i++)
{
if (i==0)
game_items[i].path = "/Game/Select Game/none";
else
{
if (games[i-1]->group)
{
GtkItemFactoryEntry group_item = {NULL, NULL, NULL, 0, "<Branch>"};
group_item.path = g_strdup_printf ("/Game/Select Game/%s",
games[i-1]->group);
// FIXME: this is O(N^2) where N is the number of games
if (gtk_item_factory_get_widget (menu_factory, group_item.path) == NULL)
gtk_item_factory_create_item (menu_factory, &group_item, NULL, 1);
game_items[i].path = g_strdup_printf ("/Game/Select Game/%s/%s",
games[i-1]->group ? games[i-1]->group : "", games[i-1]->name);
}
else
game_items[i].path = g_strdup_printf ("/Game/Select Game/%s",
games[i-1]->name);
}
game_items[i].accelerator = NULL;
game_items[i].callback = menu_set_game;
game_items[i].callback_action = i-1;
game_items[i].item_type = (i == 0 ? "<RadioItem>": "/Game/Select Game/none");
}
gtk_item_factory_create_items (menu_factory,
num_games+1, game_items, NULL);
// ugly hack to create a group of radio button with no button selected by default
gtk_item_factory_delete_item (menu_factory, "/Game/Select Game/none");
menu_main = gtk_item_factory_get_widget (menu_factory, "<main>");
gtk_widget_set_state (gtk_item_factory_get_widget (menu_factory,
"/Settings/Player/File"), GTK_STATE_INSENSITIVE);
for (i=1; i<=NUM_RECENT_GAMES; i++)
{
gchar *tmp;
gchar *gamename;
gamename = prefs_get_config_val (tmp = g_strdup_printf ("recent_game_%d", i));
g_free (tmp);
if (gamename && gamename[0] != '\0')
menu_insert_game_item (gamename, i);
}
menu_set_eval_function ();
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox), menu_main, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
{
GtkWidget *innerframe;
board_colbox = gtk_vbox_new (FALSE, 0);
board_area = gtk_drawing_area_new ();
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), board_colbox, FALSE, FALSE, 0);
vbox1 = gtk_vbox_new (FALSE, 0);
board_rowbox = gtk_hbox_new (FALSE, 0);
innerframe = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (innerframe), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (vbox1), innerframe);
gtk_container_add (GTK_CONTAINER (innerframe), board_area);
gtk_container_add (GTK_CONTAINER (vbox1), board_rowbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, TRUE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_signal_connect (GTK_OBJECT (board_area), "expose_event",
GTK_SIGNAL_FUNC (board_redraw), NULL);
gtk_widget_set_events(board_area,
gtk_widget_get_events (board_area)
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK
| GDK_LEAVE_NOTIFY_MASK
);
gtk_signal_connect (GTK_OBJECT (board_area), "leave_notify_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
gtk_signal_connect (GTK_OBJECT (board_area), "motion_notify_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
gtk_signal_connect (GTK_OBJECT (board_area), "button_release_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
gtk_signal_connect (GTK_OBJECT (board_area), "button_press_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
gtk_signal_connect (GTK_OBJECT (main_window), "key_press_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
gtk_signal_connect (GTK_OBJECT (main_window), "key_release_event",
GTK_SIGNAL_FUNC (board_signal_handler), NULL);
menu_info_bar = hbox = gtk_hbox_new (FALSE, 0);
sb_game_label = gtk_label_new (opt_game ? opt_game->name : NULL);
gtk_box_pack_start (GTK_BOX (hbox), sb_game_label, FALSE, FALSE, 3);
sb_game_separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), sb_game_separator, FALSE, FALSE, 0);
sb_player_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), sb_player_label, FALSE, FALSE, 3);
sb_player_separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), sb_player_separator, FALSE, FALSE, 0);
sb_who_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), sb_who_label, FALSE, FALSE, 3);
sb_who_separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), sb_who_separator, FALSE, FALSE, 0);
sb_score_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), sb_score_label, FALSE, FALSE, 3);
sb_score_separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), sb_score_separator, FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION == 2
sb_turn_image = gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_MENU);
gtk_box_pack_end (GTK_BOX (hbox), sb_turn_image, FALSE, FALSE, 0);
sb_turn_separator = gtk_vseparator_new ();
gtk_box_pack_end (GTK_BOX (hbox), sb_turn_separator, FALSE, FALSE, 0);
#endif
sb_time_label = gtk_label_new (NULL);
gtk_box_pack_end (GTK_BOX (hbox), sb_time_label, FALSE, FALSE, 0);
sb_time_separator = gtk_vseparator_new ();
gtk_box_pack_end (GTK_BOX (hbox), sb_time_separator, FALSE, FALSE, 0);
}
menu_info_separator = separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
menu_warning_bar = gtk_label_new ("Warning: this game has not yet been completely implemented.");
gtk_box_pack_start (GTK_BOX (vbox), menu_warning_bar, FALSE, FALSE, 0);
sb_warning_separator = separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
sb_message_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (sb_message_label), 0, 0.5);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), sb_message_label, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), vbox);
// FIXME: board_init() needs show() to be called to get a gc, but
// leads to the whole window not popping up at once
gtk_widget_show_all (main_window);
if (!opt_game) board_init ();
gtk_timeout_add (100, sb_update_periodic, NULL);
// this should be called before setting state_gui_active = TRUE
if (opt_game) menu_put_game ();
state_gui_active = TRUE;
if (opt_game) menu_start_game ();
menu_put_player (TRUE);
// if (!opt_game) sb_message ("Select a game from the Game menu", FALSE);
sb_update ();
}
void
gkrellm_panel_create(GtkWidget *vbox, GkrellmMonitor *mon, GkrellmPanel *p)
{
GtkWidget *hbox;
GkrellmPiximage piximage;
GtkWidget *top_win = gkrellm_get_top_window();
if (!vbox || !mon || !p)
return;
p->monitor = (gpointer) mon;
if (!p->style) /* gkrellm_panel_configure() may not have been called. */
setup_panel_style(p, mon->privat->panel_style);
if (!p->bg_piximage_override)
{
if (mon->privat->style_type == CHART_PANEL_TYPE)
p->bg_piximage = gkrellm_bg_panel_piximage(mon->privat->style_id);
else
p->bg_piximage = gkrellm_bg_meter_piximage(mon->privat->style_id);
}
p->bg_piximage_override = FALSE;
/* If not being called from rebuild or after a panel destroy, then panel
| still has a height that must be accounted for.
*/
if (p->h && p->shown)
gkrellm_monitor_height_adjust(- p->h);
p->h = p->h_configure;
p->w = _GK.chart_width;
if (p->hbox == NULL)
{
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER(vbox), hbox);
p->hbox = hbox;
p->drawing_area = gtk_drawing_area_new();
p->layout = gtk_widget_create_pango_layout(top_win, NULL);
gtk_widget_set_events (p->drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
| GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK);
gtk_box_pack_start(GTK_BOX(p->hbox), p->drawing_area,
FALSE, FALSE, 0);
gtk_widget_show(p->drawing_area);
gtk_widget_show(hbox);
p->shown = TRUE;
gtk_widget_realize(hbox);
gtk_widget_realize(p->drawing_area);
panel_list = g_list_append(panel_list, p);
p->y_mapped = -1;
g_signal_connect(G_OBJECT (p->drawing_area), "size_allocate",
G_CALLBACK(cb_panel_size_allocate), p);
}
gtk_widget_set_size_request(p->drawing_area, p->w, p->h);
if (_GK.frame_left_panel_overlap > 0 || _GK.frame_right_panel_overlap > 0)
{
piximage.pixbuf = gdk_pixbuf_new_subpixbuf(p->bg_piximage->pixbuf,
_GK.frame_left_panel_overlap, 0,
gdk_pixbuf_get_width(p->bg_piximage->pixbuf)
- _GK.frame_left_panel_overlap
- _GK.frame_right_panel_overlap,
gdk_pixbuf_get_height(p->bg_piximage->pixbuf));
piximage.border = p->bg_piximage->border;
gkrellm_border_adjust(&piximage.border,
-_GK.frame_left_panel_overlap, -_GK.frame_right_panel_overlap,
0, 0);
// gkrellm_scale_piximage_to_pixmap(&piximage, &p->bg_clean_pixmap,
// &p->bg_mask, p->w, p->h);
gkrellm_scale_theme_background(&piximage, &p->bg_clean_pixmap,
&p->bg_mask, p->w, p->h);
g_object_unref(G_OBJECT(piximage.pixbuf));
}
else
gkrellm_scale_theme_background(p->bg_piximage, &p->bg_clean_pixmap,
&p->bg_mask, p->w, p->h);
// gkrellm_scale_piximage_to_pixmap(p->bg_piximage, &p->bg_clean_pixmap,
// &p->bg_mask, p->w, p->h);
if (p->bg_text_layer_pixmap)
g_object_unref(G_OBJECT(p->bg_text_layer_pixmap));
p->bg_text_layer_pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1);
if (p->bg_pixmap)
g_object_unref(G_OBJECT(p->bg_pixmap));
p->bg_pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1);
if (p->pixmap)
g_object_unref(G_OBJECT(p->pixmap));
p->pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1);
if (p->shown)
{
gkrellm_monitor_height_adjust(p->h);
gkrellm_pack_side_frames();
}
p->need_decal_overlap_check = TRUE;
draw_panel(p, FALSE);
gkrellm_panel_button_signals_connect(p);
}
int main(int argc, char *argv[])
{
gnome_init(VERSION, VERSION, argc, argv);
/* Set up to draw from card class */
GtkWidget *vbox, *vbox1, *vbox2, *vbox3;
GtkWidget *tbar;
GtkWidget *setbutton, *nosetbutton;
GdkColor white, black, blue;
/* Done setting up */
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Set Game");
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_container_border_width(GTK_CONTAINER(window), 0);
vbox= gtk_vbox_new(FALSE, 0);
vbox1 = gtk_vbox_new(FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
vbox3 = gtk_vbox_new(FALSE, 0);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_events(drawing_area,
GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK);
gtk_widget_set_events(window, GDK_KEY_PRESS_MASK);
gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event",
GTK_SIGNAL_FUNC(expose_event), 0);
gtk_signal_connect(GTK_OBJECT(drawing_area), "button_press_event",
GTK_SIGNAL_FUNC(button_event), 0);
GnomeUIInfo toolbar[ ] = {
GNOMEUIINFO_ITEM_STOCK ("New Game", "Start new Game", newgame, GNOME_STOCK_PIXMAP_NEW),
GNOMEUIINFO_ITEM_STOCK ("High Scores", "Shows High scores", gtk_main_quit, GNOME_STOCK_PIXMAP_SCORES),
GNOMEUIINFO_ITEM_STOCK ("End Game", "Ends Current Game", gtk_main_quit, GNOME_STOCK_PIXMAP_STOP),
GNOMEUIINFO_ITEM_STOCK ("Exit", "Exit the application", gtk_main_quit, GNOME_STOCK_PIXMAP_EXIT),
GNOMEUIINFO_END
};
tbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gnome_app_fill_toolbar(GTK_TOOLBAR(tbar), toolbar, gtk_accel_group_new());
gtk_box_pack_start(GTK_BOX(vbox1), tbar, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox3, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), drawing_area, TRUE, TRUE, 5);
gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area), SPACE_INTER+CARD_WS*4, SPACE_INTER+CARD_HS*3);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Player"), TRUE, TRUE, 1);
playerscore = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(vbox3), playerscore, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Computer"), TRUE, TRUE, 1);
computerscore = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(vbox3), computerscore, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Cards Remaining"), TRUE, TRUE, 1);
cards_remain = gtk_label_new("81");
gtk_box_pack_start(GTK_BOX(vbox3), cards_remain, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
gtk_idle_add( myidle, NULL);
/************************ Start Deck Setup *************************/
unsigned char *pixmap_data[] = {
bean_e_bits,
bean_s_bits,
bean_f_bits,
blob_e_bits,
blob_s_bits,
blob_f_bits,
diamond_e_bits,
diamond_s_bits,
diamond_f_bits
};
int i, j;
GdkWindow *wn = window->window;
GdkColor col[4];
GdkColormap *cmap = gdk_window_get_colormap(wn);
GdkGC *gc;
GtkStyle *style = gtk_widget_get_style(window);
col[0].red = 54000; col[0].green = col[0].blue = 0;
col[1].green = 40000; col[1].red = col[1].blue = 0;
col[2].red = col[2].blue = 32000; col[2].green = 0;
gdk_color_white(cmap, &white);
gdk_color_black(cmap, &black);
blue.red = blue.green = 0; blue.blue = 48000;
gdk_color_alloc(cmap, &blue);
for (i=0; i<3; i++)
gdk_color_alloc(cmap, &col[i]);
for (i=0; i<9; i++)
for (j=0; j<3; j++)
card_pixmap[i*3+j] = gdk_pixmap_create_from_data(wn, (gchar*) pixmap_data[i],
SHAPE_W, SHAPE_H, -1, &col[j], &white);
/* free colors? !! */
gc = gdk_gc_new(wn);
/*** cards in normal state ***/
card_bkg = gdk_pixmap_new(wn, CARD_WIDTH, CARD_HEIGHT, -1);
/* clear the card */
gdk_gc_set_foreground(gc, &style->bg[GTK_STATE_NORMAL]);
gdk_draw_rectangle(card_bkg, gc, 1, 0, 0, CARD_WIDTH, CARD_HEIGHT);
/* draw corner arcs */
gdk_gc_set_foreground(gc, &white);
gdk_draw_arc(card_bkg, gc, 1, 0, 0,
2*ARC_SIZE, 2*ARC_SIZE, 90*64, 90*64);
gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE, 0,
2*ARC_SIZE, 2*ARC_SIZE, 0, 90*64);
gdk_draw_arc(card_bkg, gc, 1, 0, CARD_HEIGHT-2*ARC_SIZE,
2*ARC_SIZE, 2*ARC_SIZE, 180*64, 90*64);
gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE,
CARD_HEIGHT-2*ARC_SIZE, 2*ARC_SIZE, 2*ARC_SIZE, 270*64, 90*64);
/* draw the rest */
gdk_draw_rectangle(card_bkg, gc, 1, ARC_SIZE, 0, CARD_WIDTH-2*ARC_SIZE, CARD_HEIGHT);
gdk_draw_rectangle(card_bkg, gc, 1, 0, ARC_SIZE, CARD_WIDTH, CARD_HEIGHT-2*ARC_SIZE);
gdk_gc_destroy(gc);
/************************ End Deck Setup *************************/
/* done setting up for once
to draw
wn = drawing_area->window;
gc-gdk_gc_new(wn);
card1.draw();
.............draw();
gdk_gc_destroy();
Card(int colr, int shp, int num, int shdng);
*/
mytable.Draw();
gtk_main();
return 0;
}
GtkWidget *ic_loading_panel_new()
{
GtkWidget *window;
GtkWidget *titlebar;
GtkWidget *vbox;
GtkWidget *cancel_button;
GtkWidget *align;
GtkWidget *label2;
GtkWidget *image1, *image2, *image3;
GdkPixbuf *pixbuf1, *pixbuf2, *new_pixbuf;
GdkScreen *scr;
gint pic_width, pic_height;
gint new_width, new_height;
gint scr_width;
GdkScreen *screen;
GdkVisual *visual;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated (GTK_WINDOW(window), FALSE);
gtk_window_set_default_size(GTK_WINDOW(window), 280, 580);
gtk_window_set_keep_above (GTK_WINDOW(window), TRUE);
screen = gtk_widget_get_screen(window);
visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(window, visual);
GdkColor color = {0, 30313, 51153, 63408};
gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &color);
scr = gdk_screen_get_default();
scr_width = gdk_screen_get_width(scr);
gtk_window_move(GTK_WINDOW(window), scr_width-350, 50);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
titlebar = ic_titlebar_new ();
gtk_box_pack_start (GTK_BOX(vbox), titlebar, FALSE, FALSE, 0);
/*label1 = gtk_label_new("\niChat");
PangoFontDescription *font_desc = pango_font_description_from_string("Purisa Bold 25");
gtk_widget_modify_font(label1, font_desc);
pango_font_description_free(font_desc);
gtk_widget_set_size_request(label1, 100, 25);
gtk_box_pack_start(GTK_BOX(vbox), label1, FALSE, FALSE, 0);
*/
image3 = gtk_image_new_from_file(RESDIR"images/ichat.png");
gtk_box_pack_start(GTK_BOX(vbox), image3, FALSE, FALSE, 0);
pixbuf1 = gdk_pixbuf_new_from_file(RESDIR"images/loading/loading-01.png", NULL);
image1 = gtk_image_new_from_pixbuf(pixbuf1);
gtk_box_pack_start(GTK_BOX(vbox), image1, FALSE, FALSE, 0);
pixbuf2 = gdk_pixbuf_new_from_file(RESDIR"images/gtk.png", NULL);
pic_width = gdk_pixbuf_get_width(pixbuf2);
pic_height = gdk_pixbuf_get_height(pixbuf2);
new_width = 150;
new_height = ((float)new_width/pic_width)*pic_height;
new_pixbuf = gdk_pixbuf_scale_simple (pixbuf2, new_width, new_height, GDK_INTERP_BILINEAR);
image2 = gtk_image_new_from_pixbuf(new_pixbuf);
gtk_box_pack_start(GTK_BOX(vbox), image2, FALSE, FALSE, 5);
gchar str[30];
memset(str, 0, sizeof(str));
strcat(str, user_name);
strcat(str, "正在登录");
label2 = gtk_label_new(str);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, FALSE, 5);
align = gtk_alignment_new(0.5, 0.5, 0, 0);
cancel_button = gtk_button_new_with_label(" 取 消 ");
gtk_container_add(GTK_CONTAINER(align), cancel_button);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_set_events(window, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
g_signal_connect(G_OBJECT(window), "button_press_event",
G_CALLBACK(on_mouse_press_event), NULL);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
g_timeout_add(100, (GSourceFunc)timer, (gpointer)image1);
gtk_container_add(GTK_CONTAINER(window), vbox);
return window;
}
int main (int argc, char *argv[])
{
GtkWidget *label;
GdkPixbuf *icon_pixbuf;
GError *err = NULL;
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
srand (time(NULL));
gnome_program_init (APPID, APPVERSION, LIBGNOMEUI_MODULE,
argc, argv, GNOME_PARAM_POPT_TABLE, options,
GNOME_PARAM_NONE);
textbox_setup (); /* needs to be done before text boxes are created */
/* Initialize the GConf library */
if (!gconf_init (argc, argv, &err))
{
fprintf (stderr, _("Failed to init GConf: %s\n"), err->message);
g_error_free (err);
err = NULL;
}
/* Start a GConf client */
gconf_client = gconf_client_get_default ();
/* Add the GTetrinet directories to the list of directories that GConf client must watch */
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/sound",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/themes",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/keys",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/partyline",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
/* Request notification of change for these gconf keys */
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/midi_player",
(GConfClientNotifyFunc) sound_midi_player_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/enable_sound",
(GConfClientNotifyFunc) sound_enable_sound_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/enable_midi",
(GConfClientNotifyFunc) sound_enable_midi_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/themes/theme_dir",
(GConfClientNotifyFunc) themes_theme_dir_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/down",
(GConfClientNotifyFunc) keys_down_changed, NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/left",
(GConfClientNotifyFunc) keys_left_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/right",
(GConfClientNotifyFunc) keys_right_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/rotate_left",
(GConfClientNotifyFunc) keys_rotate_left_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/rotate_right",
(GConfClientNotifyFunc) keys_rotate_right_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/drop",
(GConfClientNotifyFunc) keys_drop_changed, NULL,
NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/message",
(GConfClientNotifyFunc) keys_message_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/discard",
(GConfClientNotifyFunc) keys_discard_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special1",
(GConfClientNotifyFunc) keys_special1_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special2",
(GConfClientNotifyFunc) keys_special2_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special3",
(GConfClientNotifyFunc) keys_special3_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special4",
(GConfClientNotifyFunc) keys_special4_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special5",
(GConfClientNotifyFunc) keys_special5_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special6",
(GConfClientNotifyFunc) keys_special6_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special_self",
(GConfClientNotifyFunc) keys_special_self_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/partyline/enable_timestamps",
(GConfClientNotifyFunc) partyline_enable_timestamps_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/partyline/enable_channel_list",
(GConfClientNotifyFunc) partyline_enable_channel_list_changed,
NULL, NULL, NULL);
/* load settings */
config_loadconfig ();
/* initialise some stuff */
fields_init ();
if (!g_thread_supported()) g_thread_init (NULL);
/* first set up the display */
/* create the main window */
app = gnome_app_new (APPID, APPNAME);
g_signal_connect (G_OBJECT(app), "destroy",
GTK_SIGNAL_FUNC(destroymain), NULL);
keypress_signal = g_signal_connect (G_OBJECT(app), "key-press-event",
GTK_SIGNAL_FUNC(keypress), NULL);
g_signal_connect (G_OBJECT(app), "key-release-event",
GTK_SIGNAL_FUNC(keyrelease), NULL);
gtk_widget_set_events (app, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
/* create and set the window icon */
icon_pixbuf = gdk_pixbuf_new_from_file (PIXMAPSDIR "/gtetrinet.png", NULL);
if (icon_pixbuf)
{
gtk_window_set_icon (GTK_WINDOW (app), icon_pixbuf);
gdk_pixbuf_unref (icon_pixbuf);
}
/* create the notebook */
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_TOP);
/* put it in the main window */
gnome_app_set_contents (GNOME_APP(app), notebook);
/* make menus + toolbar */
make_menus (GNOME_APP(app));
/* create the pages in the notebook */
fieldswidget = fields_page_new ();
gtk_widget_set_sensitive (fieldswidget, TRUE);
gtk_widget_show (fieldswidget);
pfields = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pfields), 0);
gtk_container_add (GTK_CONTAINER(pfields), fieldswidget);
gtk_widget_show (pfields);
g_object_set_data (G_OBJECT(fieldswidget), "title", "Playing Fields"); // FIXME
label = pixmapdata_label (fields_xpm, _("Playing Fields"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pfields, label);
partywidget = partyline_page_new ();
gtk_widget_show (partywidget);
pparty = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pparty), 0);
gtk_container_add (GTK_CONTAINER(pparty), partywidget);
gtk_widget_show (pparty);
g_object_set_data (G_OBJECT(partywidget), "title", "Partyline"); // FIXME
label = pixmapdata_label (partyline_xpm, _("Partyline"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pparty, label);
winlistwidget = winlist_page_new ();
gtk_widget_show (winlistwidget);
pwinlist = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pwinlist), 0);
gtk_container_add (GTK_CONTAINER(pwinlist), winlistwidget);
gtk_widget_show (pwinlist);
g_object_set_data (G_OBJECT(winlistwidget), "title", "Winlist"); // FIXME
label = pixmapdata_label (winlist_xpm, _("Winlist"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pwinlist, label);
/* add signal to focus the text entry when switching to the partyline page*/
g_signal_connect_after(G_OBJECT (notebook), "switch-page",
GTK_SIGNAL_FUNC (switch_focus),
NULL);
gtk_widget_show (notebook);
g_object_set (G_OBJECT (notebook), "can-focus", FALSE, NULL);
partyline_show_channel_list (list_enabled);
gtk_widget_show (app);
// gtk_widget_set_size_request (partywidget, 480, 360);
// gtk_widget_set_size_request (winlistwidget, 480, 360);
/* initialise some stuff */
commands_checkstate ();
/* check command line params */
#ifdef DEBUG
printf ("option_connect: %s\n"
"option_nick: %s\n"
"option_team: %s\n"
"option_pass: %s\n"
"option_spec: %i\n",
option_connect, option_nick, option_team,
option_pass, option_spec);
#endif
if (option_nick) GTET_O_STRCPY(nick, option_nick);
if (option_team) GTET_O_STRCPY(team, option_team);
if (option_pass) GTET_O_STRCPY(specpassword, option_pass);
if (option_spec) spectating = TRUE;
if (option_connect) {
client_init (option_connect, nick);
}
/* Don't schedule if data is ready, glib should do this itself,
* but welcome to anything that works... */
g_main_context_set_poll_func(NULL, gtetrinet_poll_func);
/* gtk_main() */
gtk_main ();
client_disconnect ();
/* cleanup */
fields_cleanup ();
sound_stopmidi ();
return 0;
}
int display_init(GtkWindow *window)
{
/* Retrieve widgets */
display_window = window;
display_label_mouse = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_mouse"));
gtk_label_set_use_markup(display_label_mouse, TRUE);
display_label_pixel = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_pixel"));
display_label_selection = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_selection"));
gtk_label_set_use_markup(display_label_selection, TRUE);
/* Display refresh management */
display_refresh_init(window);
/* Pattern display management */
display_pattern_init();
display_button_pattern = GTK_TOOL_BUTTON(lookup_widget(GTK_WIDGET(window), "button_pattern"));
gtk_signal_connect_object(GTK_OBJECT(display_button_pattern), "clicked",
GTK_SIGNAL_FUNC(display_pattern_popup), NULL);
/* Screenshot grab management */
display_screenshot_init(window);
/* Connect drawing area events */
display_darea = GTK_DRAWING_AREA(lookup_widget(GTK_WIDGET(window), "drawing_area"));
display_darea_scroll = -1;
gtk_signal_connect(GTK_OBJECT(display_darea), "expose_event",
GTK_SIGNAL_FUNC(display_event_expose), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "enter_notify_event",
GTK_SIGNAL_FUNC(display_event_crossing), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "leave_notify_event",
GTK_SIGNAL_FUNC(display_event_crossing), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "motion_notify_event",
GTK_SIGNAL_FUNC(display_event_motion), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "button_press_event",
GTK_SIGNAL_FUNC(display_event_button), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "button_release_event",
GTK_SIGNAL_FUNC(display_event_button), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "key_press_event",
GTK_SIGNAL_FUNC(display_event_key), NULL);
gtk_signal_connect(GTK_OBJECT(display_darea), "key_release_event",
GTK_SIGNAL_FUNC(display_event_key), NULL);
gtk_widget_set_events(GTK_WIDGET(display_darea),
GDK_EXPOSURE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
/* Record/playback management */
display_record_init(window);
/* Setup selection box GC */
gtk_widget_realize(GTK_WIDGET(display_darea));
display_sel_init(display_darea);
/* Init desktop selection */
display_desktop_init(window);
/* Setup mouse/keyboard input management */
display_cursor_init(window, GTK_WIDGET(display_darea));
display_input_enabled = 0;
display_input_focus = 0;
display_button_input = GTK_TOGGLE_TOOL_BUTTON(lookup_widget(GTK_WIDGET(window), "button_input"));
gtk_signal_connect_object(GTK_OBJECT(display_button_input), "clicked",
GTK_SIGNAL_FUNC(display_input_clicked), NULL);
gtk_toggle_tool_button_set_active(display_button_input, 0);
gtk_widget_set_sensitive(GTK_WIDGET(display_button_input), 0);
display_input_clicked();
/* Manual command entry */
display_command_init(window);
return 0;
}
static GtkWidget *new_button(void){
GtkWidget *ev=gtk_event_box_new();
gtk_widget_set_events(ev, GDK_BUTTON_PRESS_MASK);
gtk_widget_show_all(ev);
return ev;
}
GtkWidget * gw_window_box_about_create ( GtkWindow *window)
{
/* This window must be single, this property shouldn't be changed */
static GtkWidget *w = NULL;
GdkColor transparent = {0};
GtkWidget *vbox_about = NULL;
GtkWidget *label = NULL;
GtkWidget *event_box = NULL;
GtkWidget *logo = NULL;
GdkPixmap *pix_gw_logo = NULL;
GdkBitmap *msk_gw_logo = NULL;
gchar * text = NULL;
gchar * text_utf8 = NULL;
GdkCursor *cursor = NULL;
gchar * os_version = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( !w )
{
/* GWhere logo loading */
pix_gw_logo = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( window)->window, &msk_gw_logo, &transparent, GWhere_logo_xpm);
w = gtk_window_new ( GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal ( GTK_WINDOW ( w), TRUE);
gtk_window_set_transient_for ( GTK_WINDOW ( w), window);
gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER);
g_strdup_to_gtk_text ( _( "About"), text_utf8);
gtk_window_set_title ( GTK_WINDOW ( w), text_utf8);
g_free ( text_utf8);
gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC ( gw_window_box_about_destroy), &w);
gtk_signal_connect ( GTK_OBJECT ( w), "delete-event", GTK_SIGNAL_FUNC ( gtk_widget_destroy), NULL);
/* See more bottom the call of gdk_pixmap_unref() and gdk_bitmap_unref().
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_WINDOW_ABOUT_LOGO_PIX, pix_gw_logo, ( GtkDestroyNotify)gdk_pixmap_unref);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_WINDOW_ABOUT_LOGO_BIT, msk_gw_logo, ( GtkDestroyNotify)gdk_bitmap_unref);
*/
gtk_container_set_border_width ( GTK_CONTAINER ( w), 5);
gtk_widget_set_usize ( w, 360, 340);
event_box = gtk_event_box_new ( );
gtk_container_add ( GTK_CONTAINER ( w), event_box);
vbox_about = gtk_vbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( event_box), vbox_about);
logo = gtk_pixmap_new ( pix_gw_logo, msk_gw_logo);
gdk_pixmap_unref ( pix_gw_logo);
gdk_bitmap_unref ( msk_gw_logo);
gtk_container_add ( GTK_CONTAINER ( vbox_about), logo);
/* Doesn't encode to UTF-8 substring because the result string will be encoded. */
gw_os_get_version_str ( &os_version);
text = g_strconcat ( PROJECT_NAME,
"-",
VERSION,
_( "\nRemovable media catalog management\nBy Sebastien LECACHEUR\n\[email protected]\nhttp://www.gwhere.org\n"),
_( "GWhere allows you to manage a database of your CDs and other removable media (hard disks, floppy drive, Zip drive, CD- ROM, etc...). With GWhere it's easy to browse your CDs or to make a quick search without needing to insert all of your CDs in the drive and search them one by one."),
_( "\n\nRuns under "),
os_version,
NULL);
if ( os_version != NULL )
{
g_free ( os_version);
}
g_strdup_to_gtk_text ( text, text_utf8);
g_free ( text);
label = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_label_set_justify ( GTK_LABEL ( label), GTK_JUSTIFY_FILL);
gtk_label_set_line_wrap ( GTK_LABEL ( label), TRUE);
gtk_container_add ( GTK_CONTAINER ( vbox_about), label);
/* Should it be mandatory? Yes, in order to get the good window size
to displaying all informations. */
gtk_widget_set_usize ( label, 330, 280);
gtk_widget_set_events ( event_box, GDK_BUTTON_PRESS_MASK);
gtk_signal_connect_object ( GTK_OBJECT ( event_box), "button_press_event", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
if ( (cursor = gdk_cursor_new ( GDK_HAND2)) != NULL)
{
/* Fix bug : event_box->window is NULL with GTK-2.0. */
if ( GTK_WIDGET ( event_box)->window != NULL )
{
gdk_window_set_cursor ( GTK_WIDGET ( event_box)->window, cursor);
#ifdef HAVE_GTK20
gdk_cursor_unref ( cursor);
#endif
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_warning ( "gtk_event_box->window is NULL!!");
#endif
gdk_cursor_destroy ( cursor);
}
}
}
if ( !GTK_WIDGET_VISIBLE ( w) )
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : show the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_show_all ( w);
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : destroy the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
g_warning ( "gw_window_box_about is already displayed!! Destroying it...");
gtk_widget_destroy ( w);
}
return w;
}
static void
create_layout (GtkWidget *vbox)
{
GtkAdjustment *hadjustment, *vadjustment;
GtkLayout *layout;
GtkWidget *layout_widget;
GtkWidget *scrolledwindow;
GtkWidget *button;
gchar buf[16];
gint i, j;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_CORNER_TOP_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
layout_widget = gtk_layout_new (NULL, NULL);
layout = GTK_LAYOUT (layout_widget);
gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
/* We set step sizes here since GtkLayout does not set
* them itself.
*/
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_step_increment (hadjustment, 10.0);
gtk_adjustment_set_step_increment (vadjustment, 10.0);
gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
g_signal_connect (layout, "draw",
G_CALLBACK (layout_draw_handler),
NULL);
gtk_layout_set_size (layout, 1600, 128000);
for (i = 0 ; i < 16 ; i++)
for (j = 0 ; j < 16 ; j++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, j);
if ((i + j) % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, j * 100, i * 100);
}
for (i = 16; i < 1280; i++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, 0);
if (i % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, 0, i * 100);
}
layout_timeout = g_timeout_add (1000, scroll_layout, layout);
}
GtkWidget * create_FileSelect( void )
{
GtkWidget * vbox4;
GtkWidget * hbox4;
GtkWidget * vseparator1;
GtkWidget * hbox6;
GtkWidget * fsFNameListWindow;
GtkWidget * hbuttonbox3;
GtkWidget * uppixmapwid;
GdkPixmap * uppixmap;
GdkBitmap * upmask;
GtkStyle * upstyle;
fsFileSelect=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( fsFileSelect,"fsFileSelect" );
gtk_object_set_data( GTK_OBJECT( fsFileSelect ),"fsFileSelect",fsFileSelect );
gtk_widget_set_usize( fsFileSelect,512,300 );
GTK_WIDGET_SET_FLAGS( fsFileSelect,GTK_CAN_DEFAULT );
gtk_widget_set_events( fsFileSelect,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK );
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FileSelect );
gtk_window_set_position( GTK_WINDOW( fsFileSelect ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( fsFileSelect ),TRUE,TRUE,TRUE );
gtk_window_set_wmclass( GTK_WINDOW( fsFileSelect ),"FileSelect","MPlayer" );
fsColorMap=gdk_colormap_get_system();
gtk_widget_realize( fsFileSelect );
gtkAddIcon( fsFileSelect );
style=gtk_widget_get_style( fsFileSelect );
dpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&dmask,&style->bg[GTK_STATE_NORMAL],(gchar **)dir_xpm );
fpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&fmask,&style->bg[GTK_STATE_NORMAL],(gchar **)file_xpm );
vbox4=AddVBox( AddDialogFrame( fsFileSelect ),0 );
hbox4=AddHBox( vbox4,1 );
fsCombo4=gtk_combo_new();
gtk_widget_set_name( fsCombo4,"fsCombo4" );
gtk_widget_show( fsCombo4 );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsCombo4,TRUE,TRUE,0 );
gtk_widget_set_usize( fsCombo4,-2,20 );
fsPathCombo=GTK_COMBO( fsCombo4 )->entry;
gtk_widget_set_name( fsPathCombo,"fsPathCombo" );
gtk_widget_show( fsPathCombo );
gtk_widget_set_usize( fsPathCombo,-2,20 );
vseparator1=gtk_vseparator_new();
gtk_widget_set_name( vseparator1,"vseparator1" );
gtk_widget_show( vseparator1 );
gtk_box_pack_start( GTK_BOX( hbox4 ),vseparator1,FALSE,TRUE,0 );
gtk_widget_set_usize( vseparator1,7,20 );
upstyle=gtk_widget_get_style( fsFileSelect );
uppixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&upmask,&upstyle->bg[GTK_STATE_NORMAL],(gchar **)up_xpm );
uppixmapwid=gtk_pixmap_new( uppixmap,upmask );
gtk_widget_show( uppixmapwid );
fsUp=gtk_button_new();
gtk_container_add( GTK_CONTAINER(fsUp ),uppixmapwid );
gtk_widget_show( fsUp );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsUp,FALSE,FALSE,0 );
gtk_widget_set_usize( fsUp,65,15 );
AddHSeparator( vbox4 );
hbox6=AddHBox( NULL,0 );
gtk_box_pack_start( GTK_BOX( vbox4 ),hbox6,TRUE,TRUE,0 );
fsFNameListWindow=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( fsFNameListWindow,"fsFNameListWindow" );
gtk_widget_show( fsFNameListWindow );
gtk_box_pack_start( GTK_BOX( hbox6 ),fsFNameListWindow,TRUE,TRUE,0 );
gtk_widget_set_usize( fsFNameListWindow,-2,145 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( fsFNameListWindow ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );
fsFNameList=gtk_clist_new( 2 );
gtk_widget_set_name( fsFNameList,"fsFNameList" );
gtk_container_add( GTK_CONTAINER( fsFNameListWindow ),fsFNameList );
gtk_clist_set_column_width( GTK_CLIST( fsFNameList ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( fsFNameList ),GTK_SELECTION_BROWSE );
gtk_clist_column_titles_hide( GTK_CLIST( fsFNameList ) );
gtk_clist_set_shadow_type( GTK_CLIST( fsFNameList ),GTK_SHADOW_ETCHED_OUT );
AddHSeparator( vbox4 );
List=gtk_combo_new();
gtk_widget_set_name( List,"List" );
gtk_widget_ref( List );
gtk_object_set_data_full( GTK_OBJECT( fsFileSelect ),"List",List,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( List );
gtk_box_pack_start( GTK_BOX( vbox4 ),List,FALSE,FALSE,0 );
gtk_widget_set_usize( List,-2,20 );
fsFilterCombo=GTK_COMBO( List )->entry;
gtk_widget_set_name( fsFilterCombo,"fsFilterCombo" );
gtk_widget_show( fsFilterCombo );
gtk_entry_set_editable (GTK_ENTRY( fsFilterCombo ),FALSE );
AddHSeparator( vbox4 );
hbuttonbox3=AddHButtonBox( vbox4 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox3 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox3 ),10 );
fsOk=AddButton( MSGTR_Ok,hbuttonbox3 );
fsCancel=AddButton( MSGTR_Cancel,hbuttonbox3 );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&fsFileSelect );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"key_release_event",GTK_SIGNAL_FUNC( on_FileSelect_key_release_event ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsFilterCombo_changed ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsFilterCombo_activate ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsPathCombo_changed ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsPathCombo_activate ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsUp ),"released",GTK_SIGNAL_FUNC( fs_Up_released ),fsFNameList );
gtk_signal_connect( GTK_OBJECT( fsOk ),"released",GTK_SIGNAL_FUNC( fs_Ok_released ),fsCombo4 );
gtk_signal_connect( GTK_OBJECT( fsCancel ),"released",GTK_SIGNAL_FUNC( fs_Cancel_released ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFNameList ),"select_row",(GtkSignalFunc)fs_fsFNameList_select_row,NULL );
gtk_widget_grab_focus( fsFNameList );
return fsFileSelect;
}
/**
* @brief Build the GUI
*
* @return
*/
GtkWidget* buildVfoUI() {
GtkWidget* label;
vfoFixed=gtk_fixed_new();
//gtk_widget_modify_bg(vfoFixed,GTK_STATE_NORMAL,&background);
// vfoA
vfoAFrame=gtk_frame_new("VFO A");
label=gtk_frame_get_label_widget((GtkFrame*)vfoAFrame);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),258,40);
#else
gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),300,80);
#endif
vfoAFrequency=gtk_drawing_area_new();
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),240,75);
#else
//gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),250,35);
#endif
g_signal_connect(G_OBJECT (vfoAFrequency),"configure_event",G_CALLBACK(vfoAFrequency_configure_event),NULL);
g_signal_connect(G_OBJECT (vfoAFrequency),"expose_event",G_CALLBACK(vfoAFrequency_expose_event),NULL);
g_signal_connect(G_OBJECT(vfoAFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL);
gtk_widget_set_events(vfoAFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
gtk_widget_show(vfoAFrequency);
gtk_widget_show(vfoAFrame);
gtk_container_add((GtkContainer*)vfoAFrame,vfoAFrequency);
gtk_fixed_put((GtkFixed*)vfoFixed,vfoAFrame,0,0);
// vfoB
vfoBFrame=gtk_frame_new("VFO B");
label=gtk_frame_get_label_widget((GtkFrame*)vfoBFrame);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),258,40);
#else
gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),300,80);
#endif
vfoBFrequency=gtk_drawing_area_new();
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),240,35);
#else
//gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),300,35);
#endif
g_signal_connect(G_OBJECT (vfoBFrequency),"configure_event",G_CALLBACK(vfoBFrequency_configure_event),NULL);
g_signal_connect(G_OBJECT (vfoBFrequency),"expose_event",G_CALLBACK(vfoBFrequency_expose_event),NULL);
g_signal_connect(G_OBJECT(vfoBFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL);
gtk_widget_set_events(vfoBFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
gtk_widget_show(vfoBFrequency);
gtk_widget_show(vfoBFrame);
gtk_container_add((GtkContainer*)vfoBFrame,vfoBFrequency);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,456,0);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,500,0);
#endif
// vfo control
vfoControlFrame=gtk_frame_new(NULL);
buttonAtoB = gtk_button_new_with_label ("A>B");
//gtk_widget_modify_bg(buttonAtoB, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonAtoB);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),50,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),45,25);
#endif
g_signal_connect(G_OBJECT(buttonAtoB),"clicked",G_CALLBACK(vfoCallback),NULL);
gtk_widget_show(buttonAtoB);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,258,0);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,300,0);
#endif
buttonAswapB = gtk_button_new_with_label ("A<>B");
//gtk_widget_modify_bg(buttonAswapB, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonAswapB);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),49,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),60,25);
#endif
g_signal_connect(G_OBJECT(buttonAswapB),"clicked",G_CALLBACK(vfoCallback),NULL);
gtk_widget_show(buttonAswapB);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,308,0);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,345,0);
#endif
buttonBtoA = gtk_button_new_with_label ("A<B");
//gtk_widget_modify_bg(buttonBtoA, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonBtoA);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),49,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),45,25);
#endif
g_signal_connect(G_OBJECT(buttonBtoA),"clicked",G_CALLBACK(vfoCallback),NULL);
gtk_widget_show(buttonBtoA);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,357,0);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,405,0);
#endif
buttonSplit = gtk_button_new_with_label ("Split");
//gtk_widget_modify_bg(buttonSplit, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonSplit);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,25);
#endif
g_signal_connect(G_OBJECT(buttonSplit),"clicked",G_CALLBACK(vfoCallback),NULL);
gtk_widget_show(buttonSplit);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,406,0);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,450,0);
#endif
buttonFrequencyUp = gtk_button_new_with_label ("^");
//gtk_widget_modify_bg(buttonFrequencyUp, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonFrequencyUp);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,25);
#endif
g_signal_connect(G_OBJECT(buttonFrequencyUp),"pressed",G_CALLBACK(frequencyUpCallback),NULL);
g_signal_connect(G_OBJECT(buttonFrequencyUp),"released",G_CALLBACK(frequencyReleasedCallback),NULL);
gtk_widget_show(buttonFrequencyUp);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,258,20);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,300,25);
#endif
buttonIncrementPlus = gtk_button_new_with_label ("+");
//gtk_widget_modify_bg(buttonIncrementPlus, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonIncrementPlus);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,25);
#endif
g_signal_connect(G_OBJECT(buttonIncrementPlus),"clicked",G_CALLBACK(buttonIncrementPlusCallback),NULL);
gtk_widget_show(buttonIncrementPlus);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,288,20);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,330,25);
#endif
incrementDisplay=gtk_drawing_area_new();
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),98,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),100,25);
#endif
gtk_widget_show(incrementDisplay);
g_signal_connect(G_OBJECT (incrementDisplay),"configure_event",G_CALLBACK(incrementDisplay_configure_event),NULL);
g_signal_connect(G_OBJECT (incrementDisplay),"expose_event",G_CALLBACK(incrementDisplay_expose_event),NULL);
g_signal_connect(G_OBJECT(incrementDisplay),"scroll_event",G_CALLBACK(increment_scroll_event),NULL);
gtk_widget_set_events(incrementDisplay,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
gtk_widget_show(incrementDisplay);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,308,20);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,350,25);
#endif
buttonIncrementMinus = gtk_button_new_with_label ("-");
//gtk_widget_modify_bg(buttonIncrementMinus, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonIncrementMinus);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,25);
#endif
g_signal_connect(G_OBJECT(buttonIncrementMinus),"clicked",G_CALLBACK(buttonIncrementMinusCallback),NULL);
gtk_widget_show(buttonIncrementMinus);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,406,20);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,450,25);
#endif
buttonFrequencyDown = gtk_button_new_with_label ("v");
//gtk_widget_modify_bg(buttonFrequencyDown, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonFrequencyDown);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,20);
#else
gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,25);
#endif
g_signal_connect(G_OBJECT(buttonFrequencyDown),"pressed",G_CALLBACK(frequencyDownCallback),NULL);
g_signal_connect(G_OBJECT(buttonFrequencyDown),"released",G_CALLBACK(frequencyReleasedCallback),NULL);
gtk_widget_show(buttonFrequencyDown);
#ifdef NETBOOK
gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,426,20);
#else
gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,470,25);
#endif
#ifdef NETBOOK
gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),714,40);
#else
gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),800,50);
#endif
gtk_widget_show(vfoFixed);
return vfoFixed;
}
void
ags_note_edit_init(AgsNoteEdit *note_edit)
{
GtkAdjustment *adjustment;
note_edit->flags = 0;
note_edit->ruler = ags_ruler_new();
gtk_table_attach(GTK_TABLE(note_edit),
(GtkWidget *) note_edit->ruler,
0, 1,
0, 1,
GTK_FILL|GTK_EXPAND,
GTK_FILL,
0, 0);
note_edit->drawing_area = (GtkDrawingArea *) gtk_drawing_area_new();
gtk_widget_set_style((GtkWidget *) note_edit->drawing_area, note_edit_style);
gtk_widget_set_events (GTK_WIDGET (note_edit->drawing_area), GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
);
gtk_table_attach(GTK_TABLE(note_edit),
(GtkWidget *) note_edit->drawing_area,
0, 1,
1, 2,
GTK_FILL|GTK_EXPAND,
GTK_FILL|GTK_EXPAND,
0, 0);
note_edit->control.note = ags_note_new();
note_edit->width = 0;
note_edit->height = 0;
note_edit->map_width = AGS_NOTE_EDIT_MAX_CONTROLS * 64;
note_edit->map_height = 78;
note_edit->control_height = 14;
note_edit->control_margin_y = 2;
note_edit->control_width = 16;
note_edit->y0 = 0;
note_edit->y1 = 0;
note_edit->nth_y = 0;
note_edit->stop_y = 0;
/* AgsNoteEditControlCurrent is used by ags_note_edit_draw_segment */
note_edit->control_current.control_count = AGS_NOTE_EDIT_MAX_CONTROLS;
note_edit->control_current.control_width = 64;
note_edit->control_current.x0 = 0;
note_edit->control_current.x1 = 0;
note_edit->control_current.nth_x = 0;
/* AgsNoteEditControlUnit is used by ags_note_edit_draw_notation */
note_edit->control_unit.control_count = 16 * AGS_NOTE_EDIT_MAX_CONTROLS;
note_edit->control_unit.control_width = 1 * 4;
note_edit->control_unit.x0 = 0;
note_edit->control_unit.x1 = 0;
note_edit->control_unit.nth_x = 0;
note_edit->control_unit.stop_x = 0;
/* offset for pasting from clipboard */
note_edit->selected_x = 0;
note_edit->selected_y = 0;
/* GtkScrollbars */
adjustment = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0);
note_edit->vscrollbar = (GtkVScrollbar *) gtk_vscrollbar_new(adjustment);
gtk_table_attach(GTK_TABLE(note_edit),
(GtkWidget *) note_edit->vscrollbar,
1, 2,
1, 2,
GTK_FILL, GTK_FILL,
0, 0);
adjustment = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0);
note_edit->hscrollbar = (GtkHScrollbar *) gtk_hscrollbar_new(adjustment);
gtk_table_attach(GTK_TABLE(note_edit),
(GtkWidget *) note_edit->hscrollbar,
0, 1,
2, 3,
GTK_FILL, GTK_FILL,
0, 0);
}
void
CReciteWord::create ()
{
init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_events(window,GDK_SCROLL_MASK);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_widget_set_app_paintable(window,TRUE);
gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
gtk_widget_set_size_request (window, Skin->reciteword.width, Skin->reciteword.height);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (window), _("ReciteWord"));
gtk_widget_realize(window);
skin_load_reciteword (window);
skin_load_face (window);
gtk_window_set_icon (GTK_WINDOW(window),Skin->face.icon.p[0]);
tooltips = gtk_tooltips_new ();
fixed = gtk_fixed_new ();
//gtk_fixed_set_has_window(GTK_FIXED(fixed),TRUE);
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
SetBackPixmap (fixed, Skin->face.face.p[0]);
help_button.create (fixed, Skin->face.help_button.x[0],
Skin->face.help_button.y[0], Skin->face.help_button.p[0],
Skin->face.help_button.p[1],
Skin->face.help_button.p[2], PopupHelp, NULL);
record_button.create (fixed, Skin->face.record_button.x[0],
Skin->face.record_button.y[0],
Skin->face.record_button.p[0],
Skin->face.record_button.p[1],
Skin->face.record_button.p[2], PopupRecord, NULL);
option_button.create (fixed, Skin->face.option_button.x[0],
Skin->face.option_button.y[0],
Skin->face.option_button.p[0],
Skin->face.option_button.p[1],
Skin->face.option_button.p[2], PopupOption, NULL);
dict_button.create (fixed, Skin->face.dict_button.x[0],
Skin->face.dict_button.y[0], Skin->face.dict_button.p[0],
Skin->face.dict_button.p[1],
Skin->face.dict_button.p[2], PopupDict, NULL);
about_button.create (fixed, Skin->face.about_button.x[0],
Skin->face.about_button.y[0],
Skin->face.about_button.p[0],
Skin->face.about_button.p[1],
Skin->face.about_button.p[2], PopupAbout, NULL);
GtkWidget *event_box = gtk_event_box_new ();
gtk_fixed_put (GTK_FIXED (fixed), event_box, Skin->face.menubar.x[0],
Skin->face.menubar.y[0]);
GtkWidget *pixmap_widget = gtk_image_new_from_pixmap (Skin->face.menubar.p[0], NULL);
gtk_container_add (GTK_CONTAINER (event_box), pixmap_widget);
gtk_widget_show (pixmap_widget);
gtk_widget_show (event_box);
g_signal_connect (G_OBJECT (event_box), "enter_notify_event",
G_CALLBACK (on_menu_bar_enter_notify), this);
g_signal_connect (G_OBJECT (window), "enter_notify_event",
G_CALLBACK (on_window_enter_notify), this);
g_signal_connect (G_OBJECT (window), "button_press_event",
G_CALLBACK (on_mainwnd_button_press), this);
g_signal_connect (G_OBJECT (window), "scroll_event",
G_CALLBACK (on_mainwnd_scroll), this);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (on_mainwnd_delete_event), this);
gtk_widget_show (window);
gdk_threads_enter();
gtk_main ();
gdk_threads_leave();
}
void gui_init (gui *g) {
g->poly = poly_new ();
g->selected = NULL;
g->hovered = NULL;
g->gc = NULL;
g->canvas = NULL;
g->pixmap = NULL;
g->ctrl = false;
g->pix_w = 0;
g->pix_h = 0;
/* Main window */
g->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (g->window, "[:Polytool:]");
/* Widget creation */
g->vbox = gtk_vbox_new (false, 0);
g->box = gtk_hbox_new (false, 4);
g->status = gtk_statusbar_new ();
g->draw_zone = gtk_drawing_area_new ();
/* Context menu */
g->menu = gtk_menu_new ();
g->m_split = gtk_menu_item_new_with_label ("Split left/right chains");
g->m_mtr = gtk_menu_item_new_with_label ("Triangulate (monotone)");
g->m_rtr = gtk_menu_item_new_with_label ("Triangulate (generic)");
g->m_hull = gtk_menu_item_new_with_label ("Convex hull (Graham)");
g->m_sep1 = gtk_separator_menu_item_new ();
g->m_clear = gtk_menu_item_new_with_label ("Clear");
g->m_draw = gtk_menu_item_new_with_label ("Redraw");
g->m_sep2 = gtk_separator_menu_item_new ();
g->m_quit = gtk_menu_item_new_with_label ("Quit");
gtk_menu_append (g->menu, g->m_split);
gtk_menu_append (g->menu, g->m_mtr);
gtk_menu_append (g->menu, g->m_rtr);
gtk_menu_append (g->menu, g->m_hull);
gtk_menu_append (g->menu, g->m_sep1);
gtk_menu_append (g->menu, g->m_clear);
gtk_menu_append (g->menu, g->m_draw);
gtk_menu_append (g->menu, g->m_sep2);
gtk_menu_append (g->menu, g->m_quit);
gtk_widget_show_all (g->menu);
/* Drawing area */
gtk_drawing_area_size (g->draw_zone, 200, 200);
gtk_widget_set_events (g->draw_zone, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
/* Packing */
gtk_container_set_border_width (g->box, 4);
gtk_box_pack_start (g->box, g->draw_zone, true, true, 0);
gtk_box_pack_start (g->vbox, g->box, true, true, 0);
gtk_box_pack_start (g->vbox, g->status, false, false, 0);
gtk_container_add (g->window, g->vbox);
g->cid = gtk_statusbar_get_context_id (g->status, "default");
gui_connect_signals (g);
}
//---------------- [ Mo ta cac ham] --------------------
GtkWidget* create_window(){
GtkWidget *window;
GtkWidget *vbox_main;
GtkWidget *vbox_send;
GtkWidget *vbox_rcv;
GtkWidget *hbox;
GtkWidget *hbox_bottom;
GtkWidget *txt_pheptoan;
GtkWidget *txt_ketqua;
GtkWidget *scroll_pheptoan;
GtkWidget *scroll_ketqua;
GtkWidget *btn_send_msq;
GtkWidget *btn_read_result;
GtkWidget *img_top;
GtkWidget *img_bottom;
GtkWidget *img_left;
// Tao nut thoat tu image + event_box
GtkWidget *img_exit;
GtkWidget *box_exit;
// Tao nut goi thieu tu image + event_box
GtkWidget *img_about;
GtkWidget *box_about;
// Thiet lap window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Hàng đợi thông điệp");
gtk_window_set_default_size(GTK_WINDOW(window), 640, 500);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file(GTK_WINDOW(window),"skin//icon.png",NULL);
// Thiet lap Layout chinh
vbox_main = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(window), vbox_main);
// Phan gioi thieu < TOP >
img_top = gtk_image_new_from_file("skin//top.png");
gtk_box_pack_start(GTK_BOX(vbox_main), img_top, TRUE, TRUE, 0);
// Phan noi dung < CENTER >
hbox = gtk_hbox_new(FALSE,3);
gtk_box_pack_start(GTK_BOX(vbox_main), hbox, TRUE, TRUE, 0);
// <LEFT>
img_left = gtk_image_new_from_file("skin//left.png");
gtk_box_pack_start(GTK_BOX(hbox), img_left, FALSE, FALSE, 0);
// Thiet lap khung hien thi phep toan
vbox_send = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), vbox_send, TRUE, TRUE, 0);
scroll_pheptoan = gtk_scrolled_window_new(NULL,NULL);
gtk_box_pack_start(GTK_BOX(vbox_send), scroll_pheptoan, TRUE, TRUE, 0);
txt_pheptoan = gtk_text_view_new();
buf_pheptoan = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_pheptoan));
gtk_widget_set_size_request(GTK_WIDGET(txt_pheptoan),205,300);
gtk_container_add(GTK_CONTAINER(scroll_pheptoan), txt_pheptoan);
btn_send_msq = gtk_button_new_with_label("Đọc các phép toán");
g_signal_connect( G_OBJECT(btn_send_msq), "clicked", G_CALLBACK(send_and_cal), NULL);
gtk_box_pack_start(GTK_BOX(vbox_send), btn_send_msq, TRUE, TRUE, 0);
// Thiet lap khung hien thi ket qua
vbox_rcv = gtk_vbox_new(FALSE,2);
gtk_box_pack_start(GTK_BOX(hbox), vbox_rcv, TRUE, TRUE, 0);
scroll_ketqua = gtk_scrolled_window_new(NULL,NULL);
gtk_box_pack_start(GTK_BOX(vbox_rcv), scroll_ketqua, TRUE, TRUE, 0);
txt_ketqua = gtk_text_view_new();
buf_ketqua = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_ketqua));
gtk_widget_set_size_request(GTK_WIDGET(txt_ketqua),205,300);
gtk_container_add(GTK_CONTAINER(scroll_ketqua), txt_ketqua);
btn_read_result = gtk_button_new_with_label("Xem file kết quả");
g_signal_connect( G_OBJECT(btn_read_result), "clicked", G_CALLBACK(read_result), NULL);
gtk_box_pack_start(GTK_BOX(vbox_rcv), btn_read_result, TRUE, TRUE, 0);
// Ket thuc phan noi dung
// Phan <BOTTOM>
hbox_bottom = gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox_main), hbox_bottom, TRUE, TRUE, 0);
img_bottom = gtk_image_new_from_file("skin//bottom.png");
gtk_box_pack_start(GTK_BOX(hbox_bottom), img_bottom, TRUE, TRUE, 0);
//Nut gioi thieu
box_about = gtk_event_box_new();
img_about = gtk_image_new_from_file("skin//about.png");
gtk_container_add(GTK_CONTAINER(box_about), img_about);
gtk_widget_set_events(box_about, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start(GTK_BOX(hbox_bottom), box_about, TRUE, TRUE, 0);
g_signal_connect( G_OBJECT(box_about), "button_press_event", G_CALLBACK(show_about), NULL);
//Nut thoat
box_exit = gtk_event_box_new();
img_exit = gtk_image_new_from_file("skin//exit.png");
gtk_container_add(GTK_CONTAINER(box_exit), img_exit);
gtk_widget_set_events(box_exit, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start(GTK_BOX(hbox_bottom), box_exit, TRUE, TRUE, 0);
g_signal_connect( G_OBJECT(box_exit), "button_press_event", G_CALLBACK(gtk_main_quit), NULL);
// ket thuc <BOTTOM>
return window;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *vbox;
char buf[G_ASCII_DTOSTR_BUF_SIZE];
GtkWidget *button;
GtkWidget *entry;
gtk_init (&argc, &argv);
gdk_rgb_init();
pos_x[0] = 100;
pos_y[0] = 100;
pos_x[1] = 300;
pos_y[1] = 300;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (window, "Test Input");
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
/* Create the drawing area */
drawing_area = gtk_drawing_area_new ();
gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 512, 512);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/* Signals used to handle backing pixmap */
gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
(GtkSignalFunc) expose_event, NULL);
gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
(GtkSignalFunc) configure_event, NULL);
/* Event signals */
gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
(GtkSignalFunc) motion_notify_event, NULL);
gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (change_gradient),
&a);
gtk_entry_set_text (GTK_ENTRY (entry),
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
1.0/a));
gtk_widget_show (entry);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (change_gradient),
&b);
gtk_entry_set_text (GTK_ENTRY (entry),
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
1.0/b));
gtk_widget_show (entry);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (change_gradient),
&c);
gtk_entry_set_text (GTK_ENTRY (entry),
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
1.0/c));
gtk_widget_show (entry);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (change_spread),
&spread);
gtk_entry_set_text (GTK_ENTRY (entry),
g_strdup_printf ("%d", spread));
gtk_widget_show (entry);
/* .. And a quit button */
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void
gtk_dateentry_init (GtkDateEntry * dateentry)
{
GtkWidget *widget;
GtkWidget *arrow;
DB( g_print(" (dateentry) init\n") );
widget=GTK_WIDGET(dateentry);
GTK_BOX(widget)->homogeneous = FALSE;
dateentry->date = g_date_new();
/* today's date */
g_date_set_time_t(dateentry->date, time(NULL));
g_date_set_dmy(&dateentry->mindate, 1, 1, 1900);
g_date_set_dmy(&dateentry->maxdate, 31, 12, 2200);
dateentry->entry = gtk_entry_new ();
gtk_widget_set_size_request(dateentry->entry, 90, -1);
gtk_box_pack_start (GTK_BOX (dateentry), dateentry->entry, TRUE, TRUE, 0);
dateentry->arrow = gtk_toggle_button_new ();
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (dateentry->arrow), arrow);
gtk_box_pack_end (GTK_BOX (dateentry), dateentry->arrow, FALSE, FALSE, 0);
gtk_widget_show (dateentry->entry);
gtk_widget_show (dateentry->arrow);
g_signal_connect (GTK_OBJECT (dateentry->arrow), "toggled",
G_CALLBACK (gtk_dateentry_arrow_press), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->entry), "activate",
G_CALLBACK (gtk_dateentry_entry_new), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->entry), "focus-out-event",
G_CALLBACK (gtk_dateentry_focus), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->entry), "key_press_event",
G_CALLBACK (gtk_dateentry_entry_key), dateentry);
/* our popup window */
dateentry->popwin = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_events (dateentry->popwin,
gtk_widget_get_events(dateentry->popwin) | GDK_KEY_PRESS_MASK);
dateentry->frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (dateentry->popwin), dateentry->frame);
gtk_frame_set_shadow_type (GTK_FRAME (dateentry->frame), GTK_SHADOW_OUT);
gtk_widget_show (dateentry->frame);
dateentry->calendar = gtk_calendar_new ();
gtk_container_add (GTK_CONTAINER (dateentry->frame), dateentry->calendar);
gtk_widget_show (dateentry->calendar);
g_signal_connect (GTK_OBJECT (dateentry->popwin), "key_press_event",
G_CALLBACK (key_press_popup), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->popwin), "button_press_event",
G_CALLBACK (gtk_dateentry_button_press), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "prev-year",
G_CALLBACK (gtk_dateentry_calendar_year), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "next-year",
G_CALLBACK (gtk_dateentry_calendar_year), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "prev-month",
G_CALLBACK (gtk_dateentry_calendar_year), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "next-month",
G_CALLBACK (gtk_dateentry_calendar_year), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "day-selected",
G_CALLBACK (gtk_dateentry_calendar_getfrom), dateentry);
g_signal_connect (GTK_OBJECT (dateentry->calendar), "day-selected-double-click",
G_CALLBACK (gtk_dateentry_calendar_select), dateentry);
gtk_dateentry_calendar_getfrom(NULL, dateentry);
}
void move_current_page_to_window (void)
{
WidgetPageData *pageData;
GtkWidget *page, *child, *newWindow;
GList *dlist;
gint pageNo;
char *title;
/* Extract current page's widget & it's parent from the notebook */
pageNo = gtk_notebook_get_current_page (GTK_NOTEBOOK(notebook));
page = gtk_notebook_get_nth_page (GTK_NOTEBOOK(notebook), pageNo );
dlist = gtk_container_get_children (GTK_CONTAINER(page));
if (!dlist || !(dlist->data))
{
/* Must already be a window */
if (dlist)
g_list_free (dlist);
return;
}
child = (GtkWidget *)dlist->data;
g_list_free (dlist);
/* Create new window for widget, plus container, etc. */
newWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
title = g_object_get_data (G_OBJECT(child), "title");
if (!title)
title = "GTetrinet";
gtk_window_set_title (GTK_WINDOW (newWindow), title);
gtk_container_set_border_width (GTK_CONTAINER (newWindow), 0);
/* Attach key events to window */
g_signal_connect (G_OBJECT(newWindow), "key-press-event",
GTK_SIGNAL_FUNC(keypress), NULL);
g_signal_connect (G_OBJECT(newWindow), "key-release-event",
GTK_SIGNAL_FUNC(keyrelease), NULL);
gtk_widget_set_events (newWindow, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
gtk_window_set_resizable (GTK_WINDOW(newWindow), TRUE);
/* Create store to point us back to page for later */
pageData = g_new( WidgetPageData, 1 );
pageData->parent = page;
pageData->widget = child;
pageData->pageNo = pageNo;
/* Move main widget to window */
gtk_widget_reparent (child, newWindow);
/* Pass ID of parent (to put widget back) to window's destroy */
g_signal_connect (G_OBJECT(newWindow), "destroy",
GTK_SIGNAL_FUNC(destroy_page_window),
(gpointer)(pageData));
gtk_widget_show_all( newWindow );
/* cure annoying side effect */
if (gmsgstate)
fields_gmsginput(TRUE);
else
fields_gmsginput(FALSE);
}
int main(int argc, char *argv[])
{
int fd;
GtkWidget *window;
GtkWidget *drawing_area;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
/* Block SIGALRM in the main thread */
sigset_t sigset;
sigemptyset(&sigset);
sigaddset(&sigset, SIGALRM);
pthread_sigmask(SIG_BLOCK, &sigset, NULL);
if (!g_thread_supported()) {
g_thread_init(NULL);
}
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
/* Framebuffer */
/* Open framebuffer */
if (0 > (fd = open("/dev/fb0", O_RDWR))) {
printf("Failed to open fb\n");
return -1;
}
/* Get fixed information */
if(0 > ioctl(fd, FBIOGET_FSCREENINFO, &fi)) {
printf("Failed to get fixed info\n");
return -1;
}
/* Get variable information */
if(0 > ioctl(fd, FBIOGET_VSCREENINFO, &vi)) {
printf("Failed to get variable info\n");
return -1;
}
/* Get raw bits buffer */
if(MAP_FAILED == (bits = mmap(0, fi.smem_len,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0))) {
printf("Failed to mmap fb\n");
return -1;
}
printf("Framebuffer resolution: %d x %d\n", vi.xres, vi.yres);
/* Calculate useful information */
bpp = vi.bits_per_pixel >> 3;
stride = fi.line_length / bpp;
/* Do GTK stuff */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title((GtkWindow*)window, "ParallelDroid");
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(GTK_WIDGET(drawing_area), vi.xres, vi.yres);
gtk_box_pack_start(GTK_BOX(vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show(drawing_area);
init_input_device();
/* Events */
gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
g_signal_connect(drawing_area, "motion-notify-event",
G_CALLBACK (motion_notify_event), NULL);
g_signal_connect(drawing_area, "button-press-event",
G_CALLBACK(button_press_event), NULL);
g_signal_connect(drawing_area, "button-release-event",
G_CALLBACK(button_release_event), NULL);
g_signal_connect(drawing_area, "expose-event",
G_CALLBACK(expose_event), NULL);
g_signal_connect(drawing_area, "configure-event",
G_CALLBACK(configure_event), NULL);
/* Create and add buttons */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show(hbox);
button = gtk_button_new_with_label("Back");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
g_signal_connect(button, "clicked",
G_CALLBACK(back_button_clicked), NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label("Home");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(home_button_clicked), NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label("Menu");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(menu_button_clicked), NULL);
gtk_widget_show(button);
gtk_widget_show_all(window);
pixmap = gdk_pixmap_new(drawing_area->window, IMAGE_WIDTH,
IMAGE_HEIGHT, -1);
(void)g_timeout_add(33, (GSourceFunc)timer_exe, drawing_area);
gtk_main();
gdk_threads_leave();
return 0;
}
static GtkWidget *
show_view_create_widget (PlannerShowView *view)
{
PlannerShowViewPriv *priv;
GtkWidget *pertlayout;
GtkWidget *tree;
GtkWidget *sw;
GtkWidget *frame;
GtkWidget *layout;
GtkWidget *vpaned;
GtkAdjustment *hadj, *vadj;
GtkTreeModel *model;
MrpTaskManager *task_manager;
GtkLabel *label;
GtkEntry *entry;
GtkButton *button;
GtkWidget *hbox,*vbox,*vbox2;
GtkWidget *progressbar;
GtkWidget *randomtogglebutton;
GtkWidget *deleteresourcetogglebutton;
GtkWidget *ganttcharttogglebutton;
GtkWidget *manulsettogglebutton;
GtkWidget *table;
MrpProject *project;
GtkTreeSelection *selection;
GList *task_list;
project = planner_window_get_project (PLANNER_VIEW (view)->main_window);
task_manager = imrp_project_get_task_manager(project);
priv = view->priv;
g_signal_connect (project,
"loaded",
G_CALLBACK (show_view_project_loaded_cb),
view);
model = GTK_TREE_MODEL (planner_gantt_model_new (project));
tree = planner_task_tree_new (PLANNER_VIEW (view)->main_window,
PLANNER_GANTT_MODEL (model),
FALSE,
TRUE,
COL_WBS, _("WBS"),
COL_NAME, _("Name"),
COL_START, _("Start"),
COL_FINISH, _("Finish"),
COL_WORK, _("Work"),
COL_DURATION, _("Duration"),
COL_SLACK, _("Slack"),
COL_COST, _("Cost"),
COL_ASSIGNED_TO, _("Assigned to"),
COL_COMPLETE, _("% Complete"),
-1);
priv->tree = tree;
priv->gantt = planner_gantt_chart_new_with_model (model);
g_object_set (priv->gantt,
"header_height", 50,
NULL);
planner_gantt_chart_set_view (PLANNER_GANTT_CHART (priv->gantt),
PLANNER_TASK_TREE (tree));
//*********************
//events sensitive on gantt widget
gtk_widget_set_events (GTK_WIDGET (priv->gantt), GDK_SCROLL_MASK);
g_signal_connect (priv->gantt, "scroll-event",
G_CALLBACK (show_view_chart_scroll_event), view);
g_object_unref (model);
g_signal_connect (priv->gantt,
"status_updated",
G_CALLBACK (show_view_gantt_status_updated_cb),
view);
g_signal_connect (priv->gantt,
"resource_clicked",
G_CALLBACK (show_view_gantt_resource_clicked_cb),
view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
//g_signal_connect (tree,
//"style_set",
//G_CALLBACK (show_view_tree_style_set_cb),
//view);
//*********************
//interface design
//GtkVPaned
// GtkFrame -> GtkScrollWindow ->GtkLayout (pert view showed here)A
// GtkHBox
// GtkVBox -> GtkHBox (show run-in-time data showed here)B
// GtkLabel
// GtkEntry
// GtkScrollWindow (gantt view showed here)C
//interface design in A
//GtkScrollWindow, let its scrollbar displayed if needed, put the pert view inside
layout = gtk_layout_new(NULL,NULL);
priv->pertlayout = layout;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw),
priv->pertlayout);
//GtkFrame, put the GtkScrollWindow in the GtkFrame
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), sw);
//GtkVPaned, add the GtkFrame in the GtkVPaned
vpaned = gtk_vpaned_new ();
gtk_paned_add1 (GTK_PANED (vpaned), frame);
//interface design in B
//GtkVBox, holds labels and entry and buttons
vbox = gtk_vbox_new(FALSE, 0);
vbox2 = gtk_vbox_new(FALSE,0);
progressbar = gtk_progress_bar_new();
//GtkLabel, "The Current Task Is: "
label = gtk_label_new("当前执行审计任务: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds task name
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currenttaskentry = entry;
//GtkLabel, "The Current Delay Is:: "
label = gtk_label_new("当前审计延迟时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds task delay
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currentdelayentry = entry;
//GtkLabel, "The Current duration is "
label = gtk_label_new("当前审计总时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds total duration
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currentdurationentry = entry;
//GtkLabel, "The Duration has changed :: "
label = gtk_label_new("延迟后审计总时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, The Duration has changed to
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->lastdurationentry = entry;
lastdurationentry = entry;
//GtkLabel, "delete resource"
label = gtk_label_new("调整的审计人员: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, delete resource
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->deleteresourceentry = entry;
GtkWidget *labelChild;
PangoFontDescription *font1;
short fontSize = 8;
//GtkButton, delete resource
button = gtk_button_new_with_label("重大事项显示");
GdkColor color;
color.red = 50000;
color.green = 20000;
color.blue = 15000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
//pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (show_view_delete_resource_cb),
view);
priv->deleteresourcebutton = button;
//total duration display
button = gtk_button_new_with_label("审计总时间无延迟");
GdkColor color1;
color1.red = 50000;
color1.green = 20000;
color1.blue = 15000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color1);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
// pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect(button, "clicked",
G_CALLBACK (show_view_delete_resource_cb), view);
priv->displaytotaldurationbutton = button;
//GtkButton, go to next task
button = gtk_button_new_with_label("执行下一审计任务");
GdkColor color2;
color2.red = 50000;
color2.green = 10000;
color2.blue = 10000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color2);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
// pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (show_view_next_task_cb),
view);
priv->nextstepbutton = button;
table = gtk_table_new(2, 2, FALSE);
manulsettogglebutton = gtk_toggle_button_new_with_label("手动设置审计任务延迟");
gtk_widget_set_size_request(manulsettogglebutton,5,7);
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( manulsettogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
randomtogglebutton = gtk_toggle_button_new_with_label("随机设置审计任务延迟");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( randomtogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
deleteresourcetogglebutton = gtk_toggle_button_new_with_label("参审人员随机调整");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( deleteresourcetogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
ganttcharttogglebutton = gtk_toggle_button_new_with_label("干特图路径选择");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( ganttcharttogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
gtk_table_attach_defaults(GTK_TABLE(table), manulsettogglebutton, 0, 1, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table), randomtogglebutton, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), deleteresourcetogglebutton, 1,
2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), ganttcharttogglebutton, 1, 2, 1,
2);
gtk_signal_connect(GTK_OBJECT(randomtogglebutton), "toggle",
GTK_SIGNAL_FUNC(select_random_task), view);
gtk_signal_connect(GTK_OBJECT(deleteresourcetogglebutton), "toggle",
GTK_SIGNAL_FUNC(select_deleteresource), view);
priv->manulsettogglebutton = manulsettogglebutton;
priv->randomtogglebutton = randomtogglebutton;
priv->deleteresourcetogglebutton = deleteresourcetogglebutton;
priv->ganttcharttogglebutton = ganttcharttogglebutton;
//gtk_table_attach_defaults(GTK_TABLE(table), labelprobability,1,2,2,3);
// gtk_table_attach_defaults(GTK_TABLE(table), togglebutton,0,2,3,4);
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (table), FALSE, FALSE, 0);
//GtkButton, auto optimization
button = gtk_button_new_with_label("Auto Optimization");
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw),
priv->gantt);
gtk_box_pack_start(GTK_BOX (vbox2), GTK_WIDGET (sw), TRUE, TRUE,0);
gtk_widget_set_size_request(progressbar,150,36);
gtk_box_pack_start(GTK_BOX (vbox2), GTK_WIDGET (progressbar), FALSE, FALSE, 0);
priv->progressbar = progressbar;
//put the GtkHBox in the GtkFrame, put the GtkVBox and GtkScrollWindow in the GtkHBox
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox), GTK_WIDGET (vbox), FALSE,TRUE, 0);
gtk_box_pack_end(GTK_BOX (hbox), GTK_WIDGET (vbox2), TRUE, TRUE, 10);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (hbox));
//add the GtkFrame in the GtkVPaned
gtk_paned_add2 (GTK_PANED (vpaned), frame);
gtk_paned_set_position (GTK_PANED (vpaned), 250);
g_signal_connect (tree,
"row_expanded",
G_CALLBACK (show_view_row_expanded),
priv->gantt);
g_signal_connect (tree,
"row_collapsed",
G_CALLBACK (show_view_row_collapsed),
priv->gantt);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree));
return vpaned;
}