/*#
@method set_right_justified GtkMenuItem
@brief Sets whether the menu item appears justified at the right side of a menu bar.
@param right_justified if TRUE the menu item will appear at the far right if added to a menu bar.
This was traditionally done for "Help" menu items, but is now considered
a bad idea. (If the widget layout is reversed for a right-to-left language
like Hebrew or Arabic, right-justified-menu-items appear at the left.)
*/
FALCON_FUNC MenuItem::set_right_justified( VMARG )
{
Item* i_bool = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_bool || i_bool->isNil() || !i_bool->isBoolean() )
throw_inv_params( "B" );
#endif
MYSELF;
GET_OBJ( self );
gtk_menu_item_set_right_justified( (GtkMenuItem*)_obj,
i_bool->asBoolean() ? TRUE : FALSE );
}
/**** ------------------ ****/
int
clip_GTK_MENUITEMSETRIGHTJUSTIFIED(ClipMachine * ClipMachineMemory)
{
C_widget *citm = _fetch_cw_arg(ClipMachineMemory);
gboolean right_justified = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(citm, GTK_IS_MENU_ITEM);
CHECKARG(2, LOGICAL_type_of_ClipVarType);
gtk_menu_item_set_right_justified(GTK_MENU_ITEM(citm->widget), right_justified);
return 0;
err:
return 1;
}
static void facq_oscope_menu_constructed(GObject *self)
{
FacqOscopeMenu *oscmenu = FACQ_OSCOPE_MENU(self);
GtkWidget *menubar = NULL , *menu = NULL , *menuitem = NULL;
menubar = gtk_menu_bar_new();
//Oscilloscope submenu
menu = gtk_menu_new();
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,NULL);
g_signal_connect(menuitem,"activate",
G_CALLBACK(gtk_main_quit),NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_menu_item_new_with_label(_("Oscilloscope"));
gtk_widget_show(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem);
//Plug submenu
menu = gtk_menu_new();
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES,NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_preferences),oscmenu->priv->data);
gtk_widget_show(menuitem);
oscmenu->priv->preferences = menuitem;
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DISCONNECT,NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
gtk_widget_show(menuitem);
gtk_widget_set_sensitive(GTK_WIDGET(menuitem),FALSE);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_disconnect),oscmenu->priv->data);
oscmenu->priv->disconnect = menuitem;
menuitem = gtk_menu_item_new_with_label(_("Plug"));
gtk_widget_show(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem);
//Zoom submenu
menu = gtk_menu_new();
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN,NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_zoom_in),oscmenu->priv->data);
gtk_widget_show(menuitem);
oscmenu->priv->zoom_in = menuitem;
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT,NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_zoom_out),oscmenu->priv->data);
gtk_widget_show(menuitem);
oscmenu->priv->zoom_out = menuitem;
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100,NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_zoom_100),oscmenu->priv->data);
gtk_widget_show(menuitem);
oscmenu->priv->zoom_home = menuitem;
menuitem = gtk_menu_item_new_with_label(_("Zoom"));
gtk_widget_show(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem);
//Help submenu right justified
menu = gtk_menu_new();
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
g_signal_connect(menuitem,"activate",
G_CALLBACK(facq_oscope_menu_callback_about),oscmenu->priv->data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_menu_item_new_with_label(_("Help"));
gtk_menu_item_set_right_justified(GTK_MENU_ITEM(menuitem),TRUE);
gtk_widget_show(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem);
gtk_widget_show_all(menubar);
oscmenu->priv->menubar = menubar;
}
int main(int argc,char *argv[])
{
char dmmy[20];
GtkWidget *main_window;
GtkWidget *v_box;
GtkWidget *h_box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *right_side;
GtkWidget *game_border;
GtkWidget *next_block_border;
GdkBitmap *mask;
GtkWidget *menu_bar;
GtkWidget *menu_game;
GtkWidget *menu_game_menu;
GtkWidget *separatormenuitem1;
GtkWidget *separator1;
GtkWidget *menu_settings;
GtkWidget *menu_settings_menu;
GtkWidget *menu_help;
GtkWidget *menu_help_menu;
GtkWidget *help1;
GtkWidget *high_scores1;
GtkWidget *separator2;
GtkWidget *about1;
GtkAccelGroup* accel_group;
//init game values
game_play=FALSE;
get_opt_file(options_f,100);
read_options();
game_over = TRUE;
game_pause = FALSE;
current_x = current_y = 0;
current_block = current_frame = 0;
current_score = current_lines = 0;
current_level = options.level;
next_block = next_frame = 0;
// seed random generator
srandom(time(NULL));
//options.shw_nxt = TRUE;
gtk_set_locale();
gtk_init(&argc,&argv);
accel_group = gtk_accel_group_new();
// window
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE);
gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris");
g_signal_connect ((gpointer) main_window, "key_press_event",
G_CALLBACK (keyboard_event_handler),
NULL);
// vertical box
v_box = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(main_window),v_box);
gtk_widget_show(v_box);
// menu stuff
menu_bar = gtk_menu_bar_new();
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0);
//Game sub-menu
menu_game=gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show(menu_game);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_game);
menu_game_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu);
menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game");
gtk_widget_show (menu_game_quick);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick);
g_signal_connect ((gpointer) menu_game_quick, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group,
GDK_G, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game");
gtk_widget_show (menu_game_stop);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop);
g_signal_connect ((gpointer) menu_game_stop, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group,
GDK_O, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive(menu_game_stop,FALSE);
menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause");
gtk_widget_show (menu_game_pause);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause);
g_signal_connect ((gpointer) menu_game_pause, "activate",
G_CALLBACK (game_set_pause),
NULL);
gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separatormenuitem1 = gtk_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit");
gtk_widget_show (menu_game_quit);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit);
g_signal_connect ((gpointer) menu_game_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group,
GDK_X, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
//Settings sub-menu
menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings");
gtk_widget_show (menu_settings);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings);
menu_settings_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings),
menu_settings_menu);
menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings");
gtk_widget_show (menu_game_start);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start);
g_signal_connect ((gpointer) menu_game_start, "activate",
G_CALLBACK (show_new_game),
NULL);
menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block");
gtk_widget_show (menu_game_show_next_block);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_game_show_next_block);
if (options.shw_nxt)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block),
TRUE);
g_signal_connect ((gpointer) menu_game_show_next_block, "activate",
G_CALLBACK (game_show_next_block),
NULL);
gtk_widget_add_accelerator (menu_game_show_next_block, "activate",
accel_group,
GDK_N, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings");
gtk_widget_show (menu_save_options);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_save_options);
g_signal_connect ((gpointer) menu_save_options, "activate",
G_CALLBACK (save_options),
NULL);
//Help sub-menu
menu_help=gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (menu_help);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_help);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE);
menu_help_menu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help),
menu_help_menu);
help1 = gtk_menu_item_new_with_mnemonic ("Help");
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), help1);
g_signal_connect ((gpointer) help1, "activate",
G_CALLBACK (show_help),
NULL);
gtk_widget_add_accelerator (help1, "activate",
accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores");
gtk_widget_show (high_scores1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1);
g_signal_connect ((gpointer) high_scores1, "activate",
G_CALLBACK (show_highscore_wrapper),
NULL);
separator2 = gtk_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
about1 = gtk_menu_item_new_with_mnemonic ("About");
gtk_widget_show (about1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), about1);
g_signal_connect ((gpointer) about1, "activate",
G_CALLBACK (show_about),
NULL);
// horizontal box
h_box = gtk_hbox_new(FALSE,1);
gtk_widget_show(h_box);
gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0);
// game_border
game_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1);
gtk_widget_show(game_border);
// game_area
game_area = gtk_drawing_area_new();
gtk_widget_show(game_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(game_area),
MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT);
g_signal_connect ((gpointer) game_area, "expose_event",
G_CALLBACK (game_area_expose_event),
NULL);
gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(game_border),game_area);
// right_side
right_side = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0);
gtk_widget_show(right_side);
// next_block_border
next_block_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0);
gtk_widget_show(next_block_border);
// next_block_area
next_block_area = gtk_drawing_area_new();
gtk_widget_show(next_block_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area),
4*BLOCK_WIDTH,4*BLOCK_HEIGHT);
g_signal_connect ((gpointer) next_block_area, "expose_event",
G_CALLBACK (next_block_area_expose_event),
NULL);
gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area);
// the score,level and lines labels
score_label1 = gtk_label_new("Score:");
gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label1);
gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3);
score_label2 = gtk_label_new("0");
set_gtk_color_style(score_label2,0xffff,0,0);
gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label2);
gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3);
level_label1 = gtk_label_new("Level:");
gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label1);
gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3);
sprintf(dmmy,"%d",current_level);
level_label2 = gtk_label_new(dmmy);
set_gtk_color_style(level_label2,0,0,0xffff);
gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label2);
gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3);
lines_label1 = gtk_label_new("Lines:");
gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label1);
gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3);
lines_label2 = gtk_label_new("0");
gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label2);
gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3);
//the game buttons
//Start_stop
Start_stop_button = gtk_button_new();
gtk_widget_show(Start_stop_button);
g_signal_connect ((gpointer) Start_stop_button, "clicked",
G_CALLBACK (game_start_stop),
NULL);
Start_stop_button_label= gtk_label_new(start_stop_str[0]);
box2 = label_box(right_side, Start_stop_button_label,
start_stop_str[0] );
gtk_widget_show(box2);
gtk_container_add (GTK_CONTAINER (Start_stop_button), box2);
gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(Start_stop_button);
//Pause
Pause_button = gtk_button_new();
gtk_widget_show(Pause_button);
g_signal_connect ((gpointer) Pause_button, "clicked",
G_CALLBACK (game_set_pause_b),
NULL);
Pause_button_label = gtk_label_new(pause_str[0]);
box1 = label_box(right_side, Pause_button_label, pause_str[0] );
gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (Pause_button), box1);
gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(Pause_button,FALSE);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
gtk_widget_show(main_window);
// Block images...
blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window,
&mask,
NULL,
(gchar **)blocks_xpm);
gtk_main ();
return 0;
}
static VALUE
mitem_set_right_justified(VALUE self, VALUE right_justified)
{
gtk_menu_item_set_right_justified(_SELF(self), RVAL2CBOOL(right_justified));
return self;
}
int
main (int argc, char **argv)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *optionmenu;
GtkWidget *separator;
gtk_init (&argc, &argv);
if (!window)
{
GtkWidget *menubar;
GtkWidget *menu;
GtkWidget *submenu;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_true), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (2, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("dynamic");
submenu = create_menu (3, TRUE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
g_timeout_add (250, change_item, submenu);
menuitem = gtk_menu_item_new_with_label ("bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
menu = create_menu (1, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F1,
0,
GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F3,
0,
GTK_ACCEL_VISIBLE);
optionmenu = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK(gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
{
gtk_widget_show (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
gtk_main ();
return 0;
}
void ui_menu_create(GtkWidget *w, GtkAccelGroup *accel, const char *menu_name, ui_menu_entry_t *list)
{
static int level = 0;
unsigned int i, j;
ui_menu_cb_obj *obj = NULL;
level++;
#ifdef DEBUG_MENUS
printf("allocate new: %s\t(%p)\t%s\n",
gtk_type_name(GTK_WIDGET_TYPE(w)), w,
menu_name);
#endif
for (i = j = 0; list[i].string; i++) {
GtkWidget *new_item = NULL;
int do_right_justify = 0;
char name[256];
sprintf(name, "MenuItem%d", j); /* ugly... */
switch (*list[i].string)
{
case '-': /* line */
new_item = gtk_menu_item_new();
break;
case '*': /* toggle */
{
/* Add this item to the list of calls to perform to update the
menu status. */
char *label = make_menu_label(&list[i]);
if (list[i].callback)
{
checkmark_t *cmt;
new_item = gtk_check_menu_item_new_with_label(label + 1);
cmt = (checkmark_t *)lib_malloc(sizeof(checkmark_t));
cmt->name = lib_stralloc(list[i].string+1);
cmt->w = new_item;
cmt->cb = list[i].callback;
cmt->obj.value = (void*) list[i].callback_data;
cmt->obj.status = CB_NORMAL;
cmt->handlerid =
g_signal_connect(G_OBJECT(new_item),"activate",
G_CALLBACK(list[i].callback),
(gpointer) &(cmt->obj));
g_signal_connect(G_OBJECT(new_item), "destroy",
G_CALLBACK(delete_checkmark_cb),
(gpointer) cmt);
checkmark_list = g_list_prepend(checkmark_list, cmt);
obj = &cmt->obj;
}
else
new_item = gtk_menu_item_new_with_label(label + 1);
j++;
lib_free(label);
break;
}
case 0:
break;
default:
{
char *item, *itemp;
item = itemp = make_menu_label(&list[i]);
if (strncmp(item, "RJ", 2) == 0)
{
do_right_justify = 1;
item += 2;
}
new_item = gtk_menu_item_new_with_label(item);
if (list[i].callback) {
obj = (ui_menu_cb_obj*)lib_malloc(sizeof(ui_menu_cb_obj));
obj->value = (void*) list[i].callback_data;
g_signal_connect(G_OBJECT(new_item),"activate",
G_CALLBACK(list[i].callback),
(gpointer) obj);
}
lib_free(itemp);
j++;
}
}
if (new_item)
{
gtk_menu_shell_append(GTK_MENU_SHELL(w), new_item);
gtk_widget_show(new_item);
if (do_right_justify)
gtk_menu_item_set_right_justified(GTK_MENU_ITEM(new_item), TRUE);
#ifdef DEBUG_MENUS
printf("allocate new: %s\t(%p)\t%s\n",
gtk_type_name(GTK_WIDGET_TYPE(new_item)), new_item,
list[i].string);
#endif
}
if (list[i].sub_menu)
{
GtkWidget *sub;
if (new_item && *list[i].string != '-')
{
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(new_item),sub);
}
else
{
sub = w;
}
ui_menu_create(sub, accel, list[i].string,
list[i].sub_menu);
}
else
{ /* no submenu */
if (accel && list[i].hotkey_keysym != KEYSYM_NONE
&& list[i].callback != NULL && new_item != NULL)
add_accelerator(new_item,
accel, list[i].hotkey_keysym,
list[i].hotkey_modifier);
}
}
level--;
}
//-------------------------------------------------
// Main Window Menubar
//-------------------------------------------------
GtkWidget* createMenubar(void)
{
GtkWidget *menubar;
menubar = gtk_menu_bar_new ();
GtkWidget *menuSeparator;
// Submenus Items on menubar
fileItem = gtk_menu_item_new_with_label ("File");
imageItem = gtk_menu_item_new_with_label ("Image");
helpItem = gtk_menu_item_new_with_label ("Help");
// Submenu: File
fileMenu = gtk_menu_new();
fileSingleItem = gtk_check_menu_item_new_with_label ("Save single image..");
gtk_menu_append( GTK_MENU(fileMenu), fileSingleItem);
gtk_signal_connect( GTK_OBJECT(fileSingleItem), "toggled", GTK_SIGNAL_FUNC(menuFileSingle_CB), mainWindow);
fileSetItem = gtk_check_menu_item_new_with_label ("Save a set of images..");
gtk_menu_append( GTK_MENU(fileMenu), fileSetItem);
gtk_signal_connect( GTK_OBJECT(fileSetItem), "toggled", GTK_SIGNAL_FUNC(menuFileSet_CB), mainWindow);
menuSeparator = gtk_separator_menu_item_new();
gtk_menu_append( GTK_MENU(fileMenu), menuSeparator);
fileQuitItem = gtk_menu_item_new_with_label ("Quit");
gtk_menu_append( GTK_MENU(fileMenu), fileQuitItem);
gtk_signal_connect( GTK_OBJECT(fileQuitItem), "activate", GTK_SIGNAL_FUNC(menuFileQuit_CB), mainWindow);
// Submenu: Image
imageMenu = gtk_menu_new();
imageSizeItem = gtk_menu_item_new_with_label ("Original size");
gtk_menu_append( GTK_MENU(imageMenu), imageSizeItem);
gtk_signal_connect( GTK_OBJECT(imageSizeItem), "activate", GTK_SIGNAL_FUNC(menuImageSize_CB), mainWindow);
imageRatioItem = gtk_menu_item_new_with_label ("Original aspect ratio");
gtk_menu_append( GTK_MENU(imageMenu), imageRatioItem);
gtk_signal_connect( GTK_OBJECT(imageRatioItem), "activate", GTK_SIGNAL_FUNC(menuImageRatio_CB), mainWindow);
menuSeparator = gtk_separator_menu_item_new();
gtk_menu_append( GTK_MENU(imageMenu), menuSeparator);
imageFreezeItem = gtk_check_menu_item_new_with_label ("Freeze");
gtk_menu_append( GTK_MENU(imageMenu), imageFreezeItem);
gtk_signal_connect( GTK_OBJECT(imageFreezeItem), "toggled", GTK_SIGNAL_FUNC(menuImageFreeze_CB), mainWindow);
menuSeparator = gtk_separator_menu_item_new();
gtk_menu_append( GTK_MENU(imageMenu), menuSeparator);
imageFramerateItem = gtk_menu_item_new_with_label ("Change frame rate..");
gtk_menu_append( GTK_MENU(imageMenu), imageFramerateItem);
gtk_signal_connect( GTK_OBJECT(imageFramerateItem), "activate", GTK_SIGNAL_FUNC(menuImageFramerate_CB), mainWindow);
imageIntervalItem = gtk_menu_item_new_with_label ("Show Interval..");
gtk_menu_append( GTK_MENU(imageMenu), imageIntervalItem);
gtk_signal_connect( GTK_OBJECT(imageIntervalItem), "activate", GTK_SIGNAL_FUNC(menuImageInterval_CB), mainWindow);
// Submenu: Help
helpMenu = gtk_menu_new();
helpAboutItem = gtk_menu_item_new_with_label ("About..");
gtk_menu_append( GTK_MENU(helpMenu), helpAboutItem);
gtk_signal_connect( GTK_OBJECT(helpAboutItem), "activate", GTK_SIGNAL_FUNC(menuHelpAbout_CB), mainWindow);
// linking the submenus to items on menubar
gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileItem), fileMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(imageItem), imageMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(helpItem), helpMenu);
// appending the submenus to the menubar
gtk_menu_bar_append(GTK_MENU_BAR(menubar), fileItem);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), imageItem);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (helpItem), TRUE);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), helpItem);
return menubar;
}
static void
gxk_menu_item_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GxkMenuItem *self = GXK_MENU_ITEM (object);
GtkMenuItem *mitem = GTK_MENU_ITEM (object);
GtkBin *bin = GTK_BIN (self);
switch (param_id)
{
const gchar *string, *path;
gchar *accel;
gboolean vbool;
case MENU_ITEM_PROP_ULINE_LABEL:
if (bin->child)
gtk_container_remove (GTK_CONTAINER (self), bin->child);
string = g_value_get_string (value);
if (string)
{
GtkWidget *label = g_object_new (GTK_TYPE_ACCEL_LABEL,
"visible", TRUE,
"label", string,
"use-underline", TRUE,
"xalign", 0.0,
"accel-widget", self,
"parent", self,
NULL);
if (g_object_get_long (self, "gxk-title-style"))
gxk_widget_modify_as_title (label);
}
break;
case MENU_ITEM_PROP_STOCK_IMAGE:
string = g_value_get_string (value);
if (string)
{
GtkWidget *image = gtk_image_new_from_stock (string, GXK_ICON_SIZE_MENU);
if (image)
{
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (self), image);
}
}
break;
case MENU_ITEM_PROP_KEEP_MENUBAR_IMAGE:
vbool = g_value_get_boolean (value);
g_object_set_long (self, "gxk-keep-menubar-image", vbool);
menu_item_keep_menubar_image (self);
break;
case MENU_ITEM_PROP_RIGHT_JUSTIFY:
gtk_menu_item_set_right_justified (mitem, g_value_get_boolean (value));
break;
case MENU_ITEM_PROP_TITLE_STYLE:
if (g_value_get_boolean (value))
{
gxk_widget_modify_as_title (GTK_WIDGET (self));
g_object_set_long (self, "gxk-title-style", 1);
if (bin->child)
gxk_widget_modify_as_title (bin->child);
}
break;
case MENU_ITEM_PROP_ACCEL_PATH:
path = g_value_get_string (value);
gtk_menu_item_set_accel_path (mitem, path);
accel = g_object_get_data (self, "gxk-menu-item-accel");
goto setup_accel;
case MENU_ITEM_PROP_ACCEL:
accel = g_value_dup_string (value);
g_object_set_data_full (self, "gxk-menu-item-accel", accel, g_free);
path = mitem->accel_path;
setup_accel:
if (accel && path)
{
GdkModifierType mods = 0;
guint keyval = 0;
if (accel)
gtk_accelerator_parse (accel, &keyval, &mods);
keyval = keyval != GDK_VoidSymbol ? keyval : 0;
gtk_accel_map_add_entry (path, keyval, mods);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, param_id, pspec);
break;
}
}
GtkWidget *
do_menus (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
if (!window)
{
GtkWidget *menubar;
GtkWidget *menu;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_widget_destroyed), &window);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_true), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (box);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (box), box1);
gtk_widget_show (box1);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (2, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("Flip");
g_signal_connect (button, "clicked",
G_CALLBACK (change_orientation), menubar);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK(gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
{
gtk_widget_show (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
