void make_menus(GtkWidget *box)
{
GtkWidget *menu, *menu_bar, *root_menu, *menu_items;
/* FILE menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Open");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_func), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Exit");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(exit_func), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("File");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menu_bar, FALSE, FALSE, 0);
gtk_widget_show (menu_bar);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* OPTIONS menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Options");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_options_window), NULL);
gtk_widget_show(menu_items);
// root_menu = gtk_menu_item_new_with_label ("Options");
// gtk_widget_show (root_menu);
root_menu = gtk_menu_item_new_with_label ("Options");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* HELP menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("About");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_about_menu), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Help");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_help_menu), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("Help");
gtk_widget_show (root_menu);
//gtk_menu_item_right_justify(GTK_MENU_ITEM(root_menu)); //(for later)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
}
GtkWidget *createMenu()
{
//建立菜单条并把第一级菜单项放入
GtkWidget *menubar=gtk_menu_bar_new();//建立菜单条
GtkWidget *menuitem[2];
menuitem[0]=gtk_menu_item_new_with_label("文件");//建立菜单项
gtk_menu_bar_append(GTK_MENU_BAR(menubar),menuitem[0]);//把菜单项加入到菜单条中
menuitem[1]=gtk_menu_item_new_with_label("帮助");
gtk_menu_bar_append(GTK_MENU_BAR(menubar),menuitem[1]);
GtkWidget *menu[2];
//建立menuitem[0]的子菜单
menu[0]=gtk_menu_new();//建立菜单
GtkWidget *menuitem0_0=gtk_menu_item_new_with_label("退出");
gtk_menu_shell_append(GTK_MENU_SHELL(menu[0]),menuitem0_0);//把菜单项加入到菜单中
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem[0]),menu[0]);//最后把菜单menu1粘到菜单项menuitem1上
//如法炮制menuitem[1]的子菜单
menu[1]=gtk_menu_new();
GtkWidget *menuitem1_0=gtk_menu_item_new_with_label("关于");
gtk_menu_shell_append(GTK_MENU_SHELL(menu[1]),menuitem1_0);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem[1]),menu[1]);
//连接信号和函数
gtk_signal_connect(GTK_OBJECT(menuitem0_0),"activate",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect(GTK_OBJECT(menuitem1_0),"activate",GTK_SIGNAL_FUNC(about_system),NULL);
return menubar;
}
GtkWidget* construct_menu( void )
{
GtkWidget* bar;
GtkWidget* fileItem, *editItem, *viewItem, *aboutItem;
GtkWidget* fileMenu, *openItem, *saveItem, *exportOBJItem, *quitItem;
GtkWidget* exportSubMenu;
bar = gtk_menu_bar_new();
fileItem = gtk_menu_item_new_with_label( "Plik" );
fileMenu = gtk_menu_new();
openItem = gtk_menu_item_new_with_label( "Otwórz" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), openItem );
saveItem = gtk_menu_item_new_with_label( "Zapisz" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), saveItem );
exportOBJItem = gtk_menu_item_new_with_label( "Eksportuj" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), exportOBJItem );
quitItem = gtk_menu_item_new_with_label( "Zakończ" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), quitItem );
editItem = gtk_menu_item_new_with_label( "Edycja" );
viewItem = gtk_menu_item_new_with_label( "Widok" );
aboutItem = gtk_menu_item_new_with_label( "O programie" );
gtk_menu_bar_append( bar, fileItem );
gtk_menu_bar_append( bar, editItem );
gtk_menu_bar_append( bar, viewItem );
gtk_menu_bar_append( bar, aboutItem );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( fileItem ), fileMenu );
g_signal_connect( G_OBJECT( quitItem ), "activate", (GtkSignalFunc) gtk_main_quit, NULL );
return bar;
}
void CreateMainWindow(GtkWidget **m_oWindow, GtkWidget **m_oMenuBar, GtkWidget **m_oFileItem, GtkWidget **m_oDSPItem)
{
// Main Window
gtk_window_set_title(GTK_WINDOW(m_oWindow), "Benchmark Suite");
gtk_window_set_default_size(GTK_WINDOW(m_oWindow), 290, 200);
gtk_window_set_position(GTK_WINDOW(m_oWindow), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(m_oWindow), 5);
gtk_menu_bar_append(GTK_MENU_BAR(m_oMenuBar), m_oFileItem);
gtk_menu_bar_append(GTK_MENU_BAR(m_oMenuBar), m_oDSPItem);
}
void build_menus( GtkWidget* window )
{
GtkWidget* menu_bar;
GtkWidget* file_menu;
GtkWidget* file_item;
GtkWidget* file_open;
GtkWidget* file_quit;
menu_bar = gtk_menu_bar_new( );
file_menu = gtk_menu_new( );
file_open = gtk_menu_item_new_with_label( "Open" );
gtk_signal_connect_object( GTK_OBJECT( file_open ), "activate",
GTK_SIGNAL_FUNC( show_open_dialog ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_open );
gtk_widget_show( file_open );
file_quit = gtk_menu_item_new_with_label( "Quit" );
gtk_signal_connect_object( GTK_OBJECT( file_quit ), "activate",
GTK_SIGNAL_FUNC( query_quit ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_quit );
gtk_widget_show( file_quit );
file_item = gtk_menu_item_new_with_label( "File" );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( file_item ), file_menu );
gtk_widget_show( file_item );
gtk_menu_bar_append( GTK_MENU_BAR( menu_bar ), file_item );
gtk_container_add( GTK_CONTAINER( window ), menu_bar );
gtk_widget_show( menu_bar );
}
GtkWidget *create_menu( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
GtkWidget *main_menu, *item;
/* Creating the main menu */
main_menu = gtk_menu_new();
/* Filling the menu */
ADD_MENU_ITEM( "Open", open_cb );
ADD_MENU_ITEM( "Open Address", open_address_cb );
ADD_MENU_ITEM( "Open Webcam", open_webcam_cb );
ADD_SEPARATOR();
item = gtk_menu_item_new_with_label ("Playback");
p_sys->menu_input = GTK_MENU_ITEM(item);
gtk_menu_bar_append(main_menu, item);
g_signal_connect( GTK_OBJECT(item), "activate",
G_CALLBACK( toplevel_menu_callback ), p_intf );
item = gtk_menu_item_new_with_label ("Audio");
p_sys->menu_audio = GTK_MENU_ITEM(item);
gtk_menu_bar_append(main_menu, item);
g_signal_connect( GTK_OBJECT(item), "activate",
G_CALLBACK( toplevel_menu_callback ), p_intf );
item = gtk_menu_item_new_with_label ("Video");
p_sys->menu_video = GTK_MENU_ITEM(item);
gtk_menu_bar_append(main_menu, item);
g_signal_connect( GTK_OBJECT(item), "activate",
G_CALLBACK( toplevel_menu_callback ), p_intf );
toplevel_menu_callback(p_sys->menu_input, p_intf);
toplevel_menu_callback(p_sys->menu_video, p_intf);
toplevel_menu_callback(p_sys->menu_audio, p_intf);
ADD_SEPARATOR();
ADD_MENU_ITEM( "Exit", quit_event );
gtk_widget_show_all( main_menu );
return main_menu;
}
/**** ------------------ ****/
int
clip_GTK_MENUBARAPPEND(ClipMachine * cm)
{
C_widget *cmnb = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cmnb,GTK_IS_MENU_BAR);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_menu_bar_append(GTK_MENU_BAR(cmnb->widget), cwid->widget);
return 0;
err:
return 1;
}
static GtkWidget *
CreateMenuBar(void) {
GtkWidget *menubar;
GtkWidget *game_item, *game_menu;
GtkWidget *info_item, *info_menu;
GtkWidget *tearoff;
menubar = gtk_menu_bar_new();
game_item = gtk_menu_item_new_with_label("Game");
game_menu = gtk_menu_new();
tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(game_menu), tearoff);
new_menu_item(game_menu, DIALOG_NEWGAME);
pausebutton = new_menu_item(game_menu, DIALOG_PAUSEGAME);
new_menu_item(game_menu, DIALOG_WARPLEVEL);
new_menu_item(game_menu, DIALOG_HIGHSCORE);
new_menu_item(game_menu, DIALOG_QUITGAME);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), game_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(game_item), game_menu);
info_item = gtk_menu_item_new_with_label("Info");
info_menu = gtk_menu_new();
tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(info_menu), tearoff);
new_menu_item(info_menu, DIALOG_STORY);
new_menu_item(info_menu, DIALOG_RULES);
new_menu_item(info_menu, DIALOG_ABOUT);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), info_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(info_item), info_menu);
return menubar;
}
// Create a menu
rtk_menu_t *rtk_menu_create(rtk_canvas_t *canvas, const char *label)
{
rtk_menu_t *menu;
menu = malloc(sizeof(rtk_menu_t));
menu->canvas = canvas;
menu->item = gtk_menu_item_new_with_label(label);
menu->menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->item), menu->menu);
gtk_menu_bar_append(GTK_MENU_BAR(canvas->menu_bar), menu->item);
return menu;
}
GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName)
{
GtkWidget *menuitem;
GtkWidget *submenu;
menuitem = gtk_menu_item_new_with_label (szName);
gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem);
gtk_widget_show (menuitem);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
return (submenu);
}
/**** ------------------ ****/
int
clip_GTK_MENUBARAPPEND(ClipMachine * ClipMachineMemory)
{
C_widget *cmnb = _fetch_cw_arg(ClipMachineMemory);
C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(cmnb, GTK_IS_MENU_BAR);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(cwid, GTK_IS_WIDGET);
gtk_menu_bar_append(GTK_MENU_BAR(cmnb->widget), cwid->widget);
return 0;
err:
return 1;
}
GtkWidget *
add_submenu (GtkWidget * menu_bar, gchar * label_text, GtkWidget * menu)
{
GtkWidget *menu_item;
GtkWidget *label;
menu_item = gtk_menu_item_new ();
label = gtk_widget_new (GTK_TYPE_LABEL,
"GtkWidget::visible", TRUE,
"GtkWidget::parent", menu_item,
"GtkMisc::xalign", 0.0, NULL);
gtk_label_parse_uline (GTK_LABEL (label), label_text);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu_item);
gtk_widget_show (menu_item);
return menu_item;
}
/*
* CreateBarSubMenu
*
* Create a submenu within an existing submenu. (In other words, it's not
* the menubar.)
*
* menu - existing submenu
* szName - label to be given to the new submenu off of this submenu
*
* returns new menu widget
*/
GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName)
{
GtkWidget *menuitem;
GtkWidget *submenu;
/* --- Create menu --- */
menuitem = gtk_menu_item_new_with_label (szName);
/* --- Add it to the menubar --- */
gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem);
gtk_widget_show (menuitem);
/* --- Get a menu and attach to the menuitem --- */
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
/* --- Viola! --- */
return (submenu);
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(window), menubar);
GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup");
GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action);
GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action));
gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile);
GtkWidget *menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu);
GtkToggleAction *toggleaction;
toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemNew);
toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemOpen);
toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemSave);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc, char **argv)
{
char *socketname = get_config_name("control");
/* check if japlay is already running */
if (socketname && file_exists(socketname)) {
int fd = unix_socket_connect(socketname);
if (fd >= 0) {
int i;
for (i = 1; i < argc; ++i) {
char *path = absolute_path(argv[i]);
if (path) {
sendto(fd, path, strlen(path), 0, NULL, 0);
free(path);
}
}
close(fd);
return 0;
}
/* remove leftover socket */
unlink(socketname);
}
g_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
main_thread = g_thread_self();
if (japlay_init(&argc, argv)) {
error("Can not initialize japlay\n");
return -1;
}
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), APP_NAME);
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(destroy_cb), NULL);
g_signal_connect(G_OBJECT(main_window), "key-press-event", G_CALLBACK(key_pressed_cb), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
GtkWidget *file_menu = gtk_menu_new();
GtkWidget *item = gtk_menu_item_new_with_label("New playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(new_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Add directory to the playlist...");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(add_dir_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Clear playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(clear_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_check_menu_item_new_with_label("Enable shuffle");
g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_shuffle_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_check_menu_item_new_with_label("Enable automatic volume");
g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_autovol_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
/*item = gtk_menu_item_new_with_label("Scan playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(scan_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);*/
item = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Quit");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(destroy_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), file_menu);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), item);
static const struct button {
const char *stockid;
const char *help;
void (*const cb)(GtkButton *button, gpointer ptr);
} buttons[] = {
{GTK_STOCK_MEDIA_PLAY, "Play", play_cb},
{GTK_STOCK_MEDIA_STOP, "stop", stop_cb},
{GTK_STOCK_MEDIA_PAUSE, "Pause", pause_cb},
{GTK_STOCK_MEDIA_NEXT, "Skip to the next song in the queue", next_cb},
{GTK_STOCK_OPEN, "Add files to the playlist", add_cb},
{GTK_STOCK_OK, "Add selected songs to the queue", enqueue_cb},
{GTK_STOCK_DELETE, "Remove selected songs", remove_cb},
{NULL, NULL, NULL}
};
GtkWidget *toolbar = gtk_hbox_new(false, 0);
int i;
for (i = 0; buttons[i].stockid; ++i) {
GtkWidget *button = gtk_button_new();
GtkWidget *image = gtk_image_new_from_stock(buttons[i].stockid, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(button), image);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(buttons[i].cb), NULL);
gtk_box_pack_start(GTK_BOX(toolbar), button, false, true, 0);
gtk_widget_set_tooltip_text(button, buttons[i].help);
}
scope_area = gtk_drawing_area_new();
gtk_widget_set_size_request(scope_area, SCOPE_WIDTH, -1);
gtk_box_pack_start(GTK_BOX(toolbar), scope_area, false, true, 0);
g_signal_connect(G_OBJECT(scope_area), "expose_event", G_CALLBACK(expose_event_cb), NULL);
seekbar = gtk_hscale_new_with_range(0, 1, 1);
gtk_range_set_update_policy(GTK_RANGE(seekbar), GTK_UPDATE_DELAYED);
g_signal_connect(G_OBJECT(seekbar), "change-value", G_CALLBACK(seek_cb), NULL);
g_signal_connect(G_OBJECT(seekbar), "format-value", G_CALLBACK(format_seek_cb), NULL);
notebook = gtk_notebook_new();
GtkWidget *vbox = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(vbox), menubar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), seekbar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), notebook, true, true, 0);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
gtk_widget_show_all(main_window);
/* TODO: load all playlists */
main_playlist = new_playlist();
add_playlist_page(main_playlist, "Main");
add_playlist_page(japlay_queue, "Play queue");
add_playlist_page(japlay_history, "History");
char *playlistpath = get_config_name("main_playlist.m3u");
if (playlistpath)
load_playlist(main_playlist, playlistpath);
char *queuepath = get_config_name("queue.m3u");
if (queuepath)
load_playlist(japlay_queue, queuepath);
char *settingspath = get_config_name("settings.cfg");
if (settingspath)
load_settings(settingspath);
for (i = 1; i < argc; ++i)
add_file_playlist(main_playlist, argv[i]);
signal(SIGINT, handle_sigint);
int fd = -1;
if (socketname) {
fd = unix_socket_create(socketname);
if (fd >= 0) {
GIOChannel *io = g_io_channel_unix_new(fd);
g_io_add_watch(io, G_IO_IN, incoming_client, NULL);
}
}
gtk_main();
if (fd >= 0)
unlink(socketname);
if (playlistpath)
save_playlist_m3u(main_playlist, playlistpath);
if (queuepath)
save_playlist_m3u(japlay_queue, queuepath);
if (settingspath)
save_settings(settingspath);
japlay_exit();
return 0;
}
void make_menus(Viewer *viewer, GtkWidget *parent)
{
GtkWidget *menubar = gtk_menu_bar_new();
viewer->menu_bar = menubar;
gtk_box_pack_start(GTK_BOX(parent), menubar, FALSE, FALSE, 0);
GtkWidget *file_menuitem = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), file_menuitem);
viewer->file_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_menuitem), viewer->file_menu);
/////////////////////
GtkWidget *renderers_menuitem = gtk_menu_item_new_with_mnemonic("_Renderers");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), renderers_menuitem);
viewer->renderers_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(renderers_menuitem), viewer->renderers_menu);
if (1) {
// tearoff
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append (GTK_MENU(viewer->renderers_menu), tearoff);
gtk_widget_show (tearoff);
// separator
GtkWidget *sep = gtk_separator_menu_item_new ();
gtk_menu_append (GTK_MENU(viewer->renderers_menu), sep);
gtk_widget_show (sep);
// select all item
GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All");
gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_all_mi);
gtk_widget_show (select_all_mi);
// remove all item
GtkWidget *select_none_mi =
gtk_menu_item_new_with_mnemonic ("Select _None");
gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_none_mi);
gtk_widget_show (select_none_mi);
g_signal_connect (G_OBJECT (select_all_mi), "activate",
G_CALLBACK (on_select_all_renderers_activate), viewer);
g_signal_connect (G_OBJECT (select_none_mi), "activate",
G_CALLBACK (on_select_no_renderers_activate), viewer);
}
/////////////////////
GtkWidget *event_handlers_menuitem = gtk_menu_item_new_with_mnemonic("_Input");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), event_handlers_menuitem);
viewer->event_handlers_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(event_handlers_menuitem), viewer->event_handlers_menu);
if (1) {
// tearoff
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), tearoff);
gtk_widget_show (tearoff);
// separator
GtkWidget *sep = gtk_separator_menu_item_new ();
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), sep);
gtk_widget_show (sep);
// select all item
GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All");
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_all_mi);
gtk_widget_show (select_all_mi);
// remove all item
GtkWidget *select_none_mi =
gtk_menu_item_new_with_mnemonic ("Select _None");
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_none_mi);
gtk_widget_show (select_none_mi);
g_signal_connect (G_OBJECT (select_all_mi), "activate",
G_CALLBACK (on_select_all_event_handlers_activate), viewer);
g_signal_connect (G_OBJECT (select_none_mi), "activate",
G_CALLBACK (on_select_no_event_handlers_activate), viewer);
}
/////////////////////
GtkWidget *mode_menuitem = gtk_menu_item_new_with_mnemonic("_Mode");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), mode_menuitem);
viewer->mode_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode_menuitem), viewer->mode_menu);
}
struct encdata *enc_new(const char *text)
{
GtkWidget *verbox, *tabbola;
GtkWidget *tmpbar, *tmplabel;
GtkWidget *tmpbox;
GtkWidget *scaled;
GtkWidget *ok;
/*gchar *text;*/
bool lame = true;
struct encdata *enc = NULL;
GList *listola = NULL; /* recycling */
/* init area */
enc = (struct encdata *) g_malloc(sizeof(struct encdata));
/* init area end */
if(!(strcmp(text, "Lame"))) {
lame = true;
lameid = mixer->create_enc(MP3);
enc->outchan = mixer->get_enc(lameid);
tmplabel = gtk_label_new(_("Configure Lame Encoder"));
} else {
oggid = mixer->create_enc(OGG);
enc->outchan = mixer->get_enc(oggid);
tmplabel= gtk_label_new(_("Configure Ogg/Vorbis Encoder"));
}
enc->outchan->start();
verbox = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(verbox), tmplabel, FALSE, FALSE, 0);
enc->verbox = verbox;
/*tmplabel = GTK_BIN(w)->child;
gtk_label_get(GTK_LABEL(tmplabel), &text);*/
/*winenc = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(winenc), 7);
gtk_window_set_policy(GTK_WINDOW(winenc), TRUE, TRUE, TRUE);
gtk_signal_connect(GTK_OBJECT(winenc), "destroy",
(GtkSignalFunc) gtk_widget_destroyed, &winenc);*/
tmpbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(verbox), tmpbox, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_("Quality: (low)"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
enc->adj1 = gtk_adjustment_new(0.0, 1.0, 9.0, 1.0, 1.0, 0.0);
g_signal_connect(G_OBJECT(enc->adj1), "value_changed",
G_CALLBACK(gcb_enc_set_quality), enc);
scaled = gtk_hscale_new(GTK_ADJUSTMENT(enc->adj1));
gtk_range_set_update_policy(GTK_RANGE(scaled), GTK_UPDATE_CONTINUOUS);
gtk_scale_set_draw_value(GTK_SCALE(scaled), FALSE);
gtk_widget_set_size_request(scaled, 100, 30);
gtk_box_pack_start(GTK_BOX(tmpbox), scaled, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_("(high)"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_(" Mode"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
enc->mode = gtk_combo_new();
listola = g_list_append(listola, (void *) _("mono"));
listola = g_list_append(listola, (void *) _("stereo"));
gtk_combo_set_popdown_strings(GTK_COMBO(enc->mode), listola);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->mode)->entry), FALSE);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->mode, 70, 22);
gtk_box_pack_start(GTK_BOX(tmpbox), enc->mode, FALSE, FALSE, 0);
enc->adj_lab = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(verbox), enc->adj_lab, FALSE, FALSE, 0);
gtk_adjustment_set_value(GTK_ADJUSTMENT(enc->adj1), 2.0);
/* hidden info */
tabbola = gtk_table_new(3, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(tabbola), 12);
gtk_table_set_col_spacings(GTK_TABLE(tabbola), 12);
gtk_box_pack_start(GTK_BOX(verbox), tabbola, FALSE, FALSE, 0);
enc->tabbola = tabbola;
tmplabel = gtk_label_new(_("bitrate"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 0, 1);
enc->bitrate = gtk_combo_new();
listola = g_list_append(listola, (void *) "16");
listola = g_list_append(listola, (void *) "24");
listola = g_list_append(listola, (void *) "32");
listola = g_list_append(listola, (void *) "48");
listola = g_list_append(listola, (void *) "56");
listola = g_list_append(listola, (void *) "64");
listola = g_list_append(listola, (void *) "96");
listola = g_list_append(listola, (void *) "128");
gtk_combo_set_popdown_strings(GTK_COMBO(enc->bitrate), listola);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->bitrate)->entry), FALSE);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->bitrate, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->bitrate, 1, 2, 0, 1);
tmplabel = gtk_label_new(_("frequency filtering"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 0, 1);
enc->freqfil = gtk_combo_new();
listola = g_list_append(listola, (void *) _("auto"));
listola = g_list_append(listola, (void *) _("none"));
listola = g_list_append(listola, (void *) _("manual"));
gtk_combo_set_popdown_strings(GTK_COMBO(enc->freqfil), listola);
g_list_free(listola);
listola = NULL;
g_signal_connect(G_OBJECT(GTK_COMBO(enc->freqfil)->entry),
"changed", G_CALLBACK(gcb_set_pass), enc);
gtk_widget_set_size_request(enc->freqfil, 70, 22);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freqfil)->entry),
FALSE);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freqfil, 3, 4, 0, 1);
tmplabel=gtk_label_new(_("frequency"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 1, 2);
enc->freq = gtk_combo_new();
listola = g_list_append(listola, (void *) "auto");
listola = g_list_append(listola, (void *) "11000");
listola = g_list_append(listola, (void *) "16000");
listola = g_list_append(listola, (void *) "22050");
listola = g_list_append(listola, (void *) "44100");
gtk_combo_set_popdown_strings(GTK_COMBO(enc->freq), listola);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->freq, 70, 22);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freq)->entry), FALSE);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freq, 1, 2, 1, 2);
tmplabel = gtk_label_new(_("lowpass Hz"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 1, 2);
enc->lowps = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(enc->lowps), FALSE);
gtk_entry_set_text(GTK_ENTRY(enc->lowps), _("guessed"));
gtk_widget_set_size_request(enc->lowps, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->lowps, 3, 4, 1, 2);
tmplabel = gtk_label_new(_("highpass Hz"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 2, 3);
enc->highps = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(enc->highps), FALSE);
gtk_entry_set_text(GTK_ENTRY(enc->highps), _("guessed"));
gtk_widget_set_size_request(enc->highps, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->highps, 3, 4, 2, 3);
/* end of hidden info */
enc->tasti = gtk_vbox_new(FALSE, 5);
enc->expert = gtk_toggle_button_new_with_label(_("I'm Expert..."));
g_signal_connect(G_OBJECT(enc->expert), "toggled",
G_CALLBACK(expert_mode), tabbola);
gtk_box_pack_start(GTK_BOX(enc->tasti), enc->expert, FALSE, FALSE, 0);
/* profile menu */
tmpbar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(enc->tasti), tmpbar, FALSE, FALSE, 0);
enc->profroot = gtk_menu_item_new_with_label(_("Profile..."));
gtk_menu_bar_append(GTK_MENU_BAR(tmpbar), enc->profroot);
if(enc->outchan->tipo == MP3)
profile_lame_load();
else
profile_vorbis_load();
enc_profmenu(enc);
/* profile menu end */
ok = gtk_button_new_with_label(_("Apply"));
gtk_button_set_relief(GTK_BUTTON(ok), GTK_RELIEF_HALF);
g_signal_connect(G_OBJECT(ok), "clicked",
G_CALLBACK(gcb_set_enc), enc);
gtk_box_pack_start(GTK_BOX(enc->tasti), ok, FALSE, FALSE, 0);
/* set value from core */
enc_put(enc);
gtk_widget_show_all(verbox);
gtk_widget_hide_on_delete(tabbola);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc->expert), FALSE);
return enc;
}
/* New dialog */
void
new_cb()
{
// If another nn is open, call delete_cb()
if(nn != NULL)
delete_cb();
GtkWidget *tmp;
// Dialog where select the net neurons number
new_w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(new_w), "New Neural Network");
gtk_window_resize(GTK_WINDOW(new_w), 300, 180);
//g_signal_connect(G_OBJECT(window), "destroy",
// G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *mbox = gtk_vbox_new(1, 0);
gtk_container_add(GTK_CONTAINER(new_w), mbox);
GtkWidget *menu = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(mbox),menu,TRUE,TRUE,0);
//
GtkWidget *menu_file = gtk_menu_item_new_with_label("File");
gtk_menu_bar_append (GTK_MENU_BAR(menu), menu_file);
GtkWidget *menu_sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_file), menu_sub);
GtkWidget *menuitem = gtk_menu_item_new_with_label ("Quit");
g_signal_connect(G_OBJECT(menuitem), "clicked", G_CALLBACK(save_cb), NULL);
gtk_menu_append(GTK_MENU(menu_sub), menuitem);
// Input neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Input neurons: "),FALSE,FALSE,0);
input_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(2.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),input_spin,FALSE,FALSE,0);
// Hidden neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Hidden neurons: "),FALSE,FALSE,0);
hidden_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(3.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),hidden_spin,FALSE,FALSE,0);
// Output neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Output neurons: "),FALSE,FALSE,0);
output_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(1.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),output_spin,FALSE,FALSE,0);
// Learning neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Learning rate: "),FALSE,FALSE,0);
learning_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(0.6, 0.0, 1.0, 0.02, 0.6, 0.1)),
1.0, 2);
gtk_box_pack_start(GTK_BOX(tmp),learning_spin,FALSE,FALSE,0);
// Combo for transfer function
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
GtkWidget *new_button = gtk_button_new_with_label("New");
g_signal_connect(G_OBJECT(new_button), "clicked", G_CALLBACK(new_do_cb), NULL);
gtk_container_add(GTK_CONTAINER(tmp), new_button);
GtkWidget *cancel_button = gtk_button_new_with_label("Cancel");
g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(new_cancel_cb), NULL);
gtk_container_add(GTK_CONTAINER(tmp), cancel_button);
gtk_widget_show_all(new_w);
}
struct menu *
gui_gtk_menu_new(struct container *co, GtkWidget **widget)
{
struct menu *this=g_new0(struct menu, 1);
this->gui=g_new0(struct menu_gui,1);
this->gui->co=co;
GtkWidget *menu,*item,*menu2,*item2,*menu3,*clock;
menu=gtk_menu_bar_new();
item=gtk_menu_item_new_with_label("Goto");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Abensberg");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_abensberg), this);
item2=gtk_menu_item_new_with_label("Regensburg");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_regensburg), this);
item2=gtk_menu_item_new_with_label("Problem");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_problem), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Window");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Clone");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_clone), this);
item2=gtk_menu_item_new_with_label("Command");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_command), this);
item2=gtk_menu_item_new_with_label("Visible Blocks");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_blocks), co);
item2=gtk_menu_item_new_with_label("Visible Towns");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_towns), co);
item2=gtk_menu_item_new_with_label("Visible Polys");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_polys), co);
item2=gtk_menu_item_new_with_label("Visible Streets");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_streets), co);
menu_item(this, menu2, "Visible Points", menu_window_visible_points);
item2=gtk_menu_item_new_with_label("Exit");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (exit), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Map");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Compare");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_map_compare), this);
item2=gtk_menu_item_new_with_label("Distances");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_map_distances), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Route");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Start");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (route_start), co);
item2=gtk_menu_item_new_with_label("Trace");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (route_trace), co);
item2=gtk_menu_item_new_with_label("Update");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_route_update), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Destinations");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Last Destinations");
gtk_menu_append (GTK_MENU(menu2), item2);
menu3=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);
item2=gtk_menu_item_new_with_label("Address");
gtk_menu_append (GTK_MENU(menu2), item2);
{
FILE *file;
char buffer[8192];
double lat,lng,lat_deg,lng_deg;
char lat_c,lng_c;
struct destination *dest;
int pos,len;
char *utf8,*text,*tok,*label;
GList *list;
file=fopen("locations.txt","r");
while (fgets(buffer,8192,file)) {
dest=malloc(sizeof(*dest));
dest->co=co;
len=strlen(buffer)-1;
while (len >= 0 && buffer[len] == '\n') {
buffer[len]='\0';
}
sscanf(buffer,"%lf %c %lf %c %n",&lat, &lat_c, &lng, &lng_c, &pos);
lat_deg=floor(lat/100);
lat-=lat_deg*100;
lat_deg+=lat/60;
lng_deg=floor(lng/100);
lng-=lng_deg*100;
lng_deg+=lng/60;
transform_mercator(&lng_deg, &lat_deg, &dest->pos);
text=buffer+pos;
dest->text=strdup(text);
item2=NULL;
menu3=menu2;
while ((tok=strtok(text,"/"))) {
list=NULL;
if (item2) {
menu3=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);
}
list=gtk_container_get_children(GTK_CONTAINER(menu3));
while (list) {
item2=GTK_WIDGET(list->data);
gtk_label_get(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item2))),&label);
if (!strcmp(label, tok)) {
menu3=gtk_menu_item_get_submenu(GTK_MENU_ITEM(item2));
break;
}
list=list->next;
}
item2=NULL;
if (! list) {
utf8=g_locale_to_utf8(tok,-1,NULL,NULL,NULL);
item2=gtk_menu_item_new_with_label(utf8);
gtk_menu_append (GTK_MENU(menu3), item2);
g_free(utf8);
}
text=NULL;
}
gtk_signal_connect(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_destination_selected), dest);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new();
clock=gtk_label_new(NULL);
gtk_menu_item_right_justify(GTK_MENU_ITEM(item));
gtk_container_add(GTK_CONTAINER(item), clock);
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
menu_clock_update(clock);
*widget=menu;
return this;
}
/**
* main routine, parses args and reads from console
*/
int main(int argc, char *argv[])
{
GtkWidget *menubar, *menu, *menuitem, *vbox;
GtkWidget *dummMenu, *guestMenu, *switchMenu;
enumerator_t *enumerator;
guest_t *guest;
library_init(NULL);
gtk_init(&argc, &argv);
pages = linked_list_create();
dumm = dumm_create(NULL);
/* setup window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);
gtk_window_set_title(GTK_WINDOW (window), "Dumm");
gtk_window_set_default_size(GTK_WINDOW (window), 1000, 500);
g_signal_connect(G_OBJECT(vte_reaper_get()), "child-exited",
G_CALLBACK(child_exited), NULL);
/* add vbox with menubar, notebook */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
notebook = gtk_notebook_new();
g_object_set(G_OBJECT(notebook), "homogeneous", TRUE, NULL);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);
gtk_container_add(GTK_CONTAINER(vbox), notebook);
/* Dumm menu */
menu = gtk_menu_new();
dummMenu = gtk_menu_item_new_with_mnemonic("_Dumm");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), dummMenu);
gtk_widget_show(dummMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(dummMenu), menu);
/* Dumm -> exit */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(quit), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest menu */
menu = gtk_menu_new();
guestMenu = gtk_menu_item_new_with_mnemonic("_Guest");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), guestMenu);
gtk_widget_show(guestMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(guestMenu), menu);
/* Guest -> new */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(create_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> delete */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(delete_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> start */
menuitem = gtk_menu_item_new_with_mnemonic("_Start");
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(start_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> startall */
menuitem = gtk_menu_item_new_with_mnemonic("Start _all");
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(start_all_guests), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> stop */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_STOP, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(stop_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> connect */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_CONNECT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(connect_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> disconnect */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DISCONNECT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(disconnect_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_set_sensitive(menuitem, FALSE);
gtk_widget_show(menuitem);
/* Switch menu */
menu = gtk_menu_new();
switchMenu = gtk_menu_item_new_with_mnemonic("_Switch");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), switchMenu);
gtk_widget_show(switchMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(switchMenu), menu);
/* Switch -> new */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(create_switch), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Switch -> delete */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(delete_switch), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_set_sensitive(menuitem, FALSE);
gtk_widget_show(menuitem);
/* show widgets */
gtk_widget_show(menubar);
gtk_widget_show(notebook);
gtk_widget_show(vbox);
gtk_widget_show(window);
/* fill notebook with guests */
enumerator = dumm->create_guest_enumerator(dumm);
while (enumerator->enumerate(enumerator, (void**)&guest))
{
create_page(guest);
}
enumerator->destroy(enumerator);
gtk_main();
dumm->destroy(dumm);
pages->destroy_function(pages, g_free);
library_deinit();
return 0;
}
int
main(int argc, char **argv)
{
// support standard gtk options
gtk_init(&argc, &argv);
// check other options
if (argc == 2 && strcmp(argv[1], "-v") == 0) verbose = true;
// get get some color in the world
GdkColor yellow;
gdk_color_parse("yellow", &yellow);
GdkColor red;
gdk_color_parse("red", &red);
GdkColor darkgray;
gdk_color_parse("dark gray", &darkgray);
GdkColor blue;
gdk_color_parse("blue", &blue);
GdkColor lightblue;
gdk_color_parse("light blue", &lightblue);
GdkColor lightgreen;
gdk_color_parse("light green", &lightgreen);
GdkColor magenta;
gdk_color_parse("magenta", &magenta);
GdkColor orange;
gdk_color_parse("orange", &orange);
GdkColor violet;
gdk_color_parse("violet", &violet);
// create main window and add trimmings
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &blue);
gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
gtk_window_set_title(GTK_WINDOW(window), "GCALC");
gtk_container_set_border_width(GTK_CONTAINER(window), 20);
// always handle exits
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL);
// use a table to organize
GtkWidget *table = gtk_table_new(10, 9, FALSE);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
// add text box at row 0
text_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(text_entry), 400);
gtk_entry_set_editable(GTK_ENTRY(text_entry), editable);
gtk_entry_set_alignment(GTK_ENTRY(text_entry), 0);
gtk_table_attach_defaults(GTK_TABLE(table), text_entry, 0, 10, 0, 1);
// add lines of separation
GtkWidget *horizontal_line = gtk_hseparator_new();
gtk_table_attach_defaults(GTK_TABLE(table), horizontal_line, 0, 10, 1, 2);
GtkWidget *vertical_line = gtk_vseparator_new();
gtk_table_attach_defaults(GTK_TABLE(table), vertical_line, 5, 6, 1, 10);
// add row 1 buttons
// add_button_at("quit", table, VOIDFN(gtk_main_quit), 1, 2, 2, 3, &darkgray);
add_button_at("quit", table, VOIDFN(gtk_main_quit), 1, 2, 2, 3, &red);
#if 0
add_button_at("(", table, VOIDFN(button_callback), 2, 3, 2, 3);
add_button_at(")", table, VOIDFN(button_callback), 3, 4, 2, 3);
#endif
add_button_at("swap", table, VOIDFN(swap_button_callback), 2, 3, 2, 3, &darkgray);
add_button_at("C", table, VOIDFN(clear_button_callback), 3, 4, 2, 3, &darkgray);
add_button_at("AC", table, VOIDFN(allclear_button_callback), 4, 5, 2, 3, &darkgray);
add_button_at("MC", table, VOIDFN(memory_button_callback), 6, 7, 2, 3, &orange);
add_button_at("M+", table, VOIDFN(memory_button_callback), 7, 8, 2, 3, &orange);
add_button_at("M-", table, VOIDFN(memory_button_callback), 8, 9, 2, 3, &orange);
add_button_at("MR", table, VOIDFN(memory_button_callback), 9, 10, 2, 3, &orange);
// add row 2 buttons
add_button_at("1/x", table, VOIDFN(unaryop_button_callback), 1, 2, 3, 4, &magenta);
add_button_at("x^2", table, VOIDFN(unaryop_button_callback), 2, 3, 3, 4, &magenta);
add_button_at("x^3", table, VOIDFN(unaryop_button_callback), 3, 4, 3, 4, &magenta);
add_button_at("y^x", table, VOIDFN(binaryop_button_callback), 4, 5, 3, 4, &lightgreen);
add_button_at("%", table, VOIDFN(unaryop_button_callback), 6, 7, 3, 4, &magenta);
add_button_at("+/-", table, VOIDFN(unaryop_button_callback), 7, 8, 3, 4, &magenta);
add_button_at("/", table, VOIDFN(binaryop_button_callback), 8, 9, 3, 4, &lightgreen);
add_button_at("x", table, VOIDFN(binaryop_button_callback), 9, 10, 3, 4, &lightgreen);
// add row 3 buttons
add_button_at("x!", table, VOIDFN(unaryop_button_callback), 1, 2, 4, 5, &magenta);
add_button_at("sqrt", table, VOIDFN(unaryop_button_callback), 2, 3, 4, 5, &magenta);
add_button_at("y^1/x", table, VOIDFN(binaryop_button_callback), 3, 4, 4, 5, &lightgreen);
add_button_at("log10", table, VOIDFN(unaryop_button_callback), 4, 5, 4, 5, &magenta);
add_button_at("7", table, VOIDFN(number_button_callback), 6, 7, 4, 5, &yellow);
add_button_at("8", table, VOIDFN(number_button_callback), 7, 8, 4, 5, &yellow);
add_button_at("9", table, VOIDFN(number_button_callback), 8, 9, 4, 5, &yellow);
add_button_at("-", table, VOIDFN(binaryop_button_callback), 9, 10, 4, 5, &lightgreen);
// add row 4 buttons
add_button_at("sin", table, VOIDFN(unaryop_button_callback), 1, 2, 5, 6, &magenta);
add_button_at("cos", table, VOIDFN(unaryop_button_callback), 2, 3, 5, 6, &magenta);
add_button_at("tan", table, VOIDFN(unaryop_button_callback), 3, 4, 5, 6, &magenta);
add_button_at("ln", table, VOIDFN(unaryop_button_callback), 4, 5, 5, 6, &magenta);
add_button_at("4", table, VOIDFN(number_button_callback), 6, 7, 5, 6, &yellow);
add_button_at("5", table, VOIDFN(number_button_callback), 7, 8, 5, 6, &yellow);
add_button_at("6", table, VOIDFN(number_button_callback), 8, 9, 5, 6, &yellow);
add_button_at("+", table, VOIDFN(binaryop_button_callback), 9, 10, 5, 6, &lightgreen);
// add row 5 buttons
add_button_at("sinh", table, VOIDFN(unaryop_button_callback), 1, 2, 6, 7, &magenta);
add_button_at("cosh", table, VOIDFN(unaryop_button_callback), 2, 3, 6, 7, &magenta);
add_button_at("tanh", table, VOIDFN(unaryop_button_callback), 3, 4, 6, 7, &magenta);
add_button_at("e^x", table, VOIDFN(unaryop_button_callback), 4, 5, 6, 7, &magenta);
add_button_at("1", table, VOIDFN(number_button_callback), 6, 7, 6, 7, &yellow);
add_button_at("2", table, VOIDFN(number_button_callback), 7, 8, 6, 7, &yellow);
add_button_at("3", table, VOIDFN(number_button_callback), 8, 9, 6, 7, &yellow);
add_button_at("=", table, VOIDFN(equal_button_callback), 9, 10, 6, 8, &lightblue);
// add row 6 buttons
add_button_at("asin", table, VOIDFN(unaryop_button_callback), 1, 2, 7, 8, &magenta);
add_button_at("acos", table, VOIDFN(unaryop_button_callback), 2, 3, 7, 8, &magenta);
add_button_at("atan", table, VOIDFN(unaryop_button_callback), 3, 4, 7, 8, &magenta);
add_button_at("log2", table, VOIDFN(unaryop_button_callback), 4, 5, 7, 8, &magenta);
add_button_at("0", table, VOIDFN(number_button_callback), 6, 8, 7, 8, &yellow);
add_button_at(".", table, VOIDFN(number_button_callback), 8, 9, 7, 8, &lightblue);
// add row 7 buttons
add_button_at("asinh", table, VOIDFN(unaryop_button_callback), 1, 2, 8, 9, &magenta);
add_button_at("acosh", table, VOIDFN(unaryop_button_callback), 2, 3, 8, 9, &magenta);
add_button_at("atanh", table, VOIDFN(unaryop_button_callback), 3, 4, 8, 9, &magenta);
add_button_at("2^x", table, VOIDFN(unaryop_button_callback), 4, 5, 8, 9, &magenta);
// add row 8 buttons
GSList *group = add_radio_button_at("rad", table, NULL, TRUE, VOIDFN(angle_button_callback), 1, 2, 9, 10, &violet);
add_radio_button_at("deg", table, group, FALSE, VOIDFN(angle_button_callback), 2, 3, 9, 10, &violet);
add_button_at("pi", table, VOIDFN(constant_button_callback), 3, 4, 9, 10, &violet);
add_button_at("EE", table, VOIDFN(button_callback), 4, 5, 9, 10, &violet);
#if 0
// add debug button
add_button_at("dbg", table, VOIDFN(debug_button_callback), 9, 10, 9, 10, &violet);
#else
// add menu item with choices to activate
GtkWidget *menubar = gtk_menu_bar_new();
GtkWidget *options = gtk_menu_item_new_with_label("options");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), options);
GtkWidget *submenu= gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(options), submenu);
GtkWidget *dbgitem = gtk_check_menu_item_new_with_label("dbg");
gtk_menu_append(GTK_MENU(submenu), dbgitem);
g_signal_connect(G_OBJECT(dbgitem), "activate",
G_CALLBACK(checked_callback), (gpointer)"dbg");
GtkWidget *edtitem = gtk_check_menu_item_new_with_label("edt");
gtk_menu_append(GTK_MENU(submenu), edtitem);
g_signal_connect(G_OBJECT(edtitem), "activate",
G_CALLBACK(checked_callback), (gpointer)"edt");
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 8, 10, 9, 10);
#endif
// show main window and anything it contains
gtk_widget_show_all(window);
// start up main event loop
gtk_main();
// all done
return 0;
}
GtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
guint32 actualChromeMask = chromeMask;
GtkBrowser *browser = 0;
browser = g_new0(GtkBrowser, 1);
browser->menuBarOn = FALSE;
browser->toolBarOn = FALSE;
browser->locationBarOn = FALSE;
browser->statusBarOn = FALSE;
g_print("new_gtk_browser\n");
if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
{
browser->menuBarOn = TRUE;
g_print("\tmenu bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
{
browser->toolBarOn = TRUE;
g_print("\ttool bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
{
browser->locationBarOn = TRUE;
g_print("\tlocation bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
{
browser->statusBarOn = TRUE;
g_print("\tstatus bar\n");
}
// create our new toplevel window
browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// new vbox
browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
// add it to the toplevel window
gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
browser->topLevelVBox);
// create our menu bar
browser->menuBar = gtk_menu_bar_new();
// create the file menu
browser->fileMenuItem = gtk_menu_item_new_with_label("File");
browser->fileMenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
browser->fileMenu);
browser->fileClose =
gtk_menu_item_new_with_label("Close");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileClose);
// append it
gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->menuBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create the hbox that will contain the toolbar and the url text entry bar
browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
// add that hbox to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->toolbarHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */
#ifdef MOZ_WIDGET_GTK2
browser->toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
FALSE, // expand
FALSE, // fill
0); // padding
// new back button
browser->backButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Back",
"Go Back",
"Go Back",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(back_clicked_cb),
browser);
// new stop button
browser->stopButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Stop",
"Stop",
"Stop",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(stop_clicked_cb),
browser);
// new forward button
browser->forwardButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Forward",
"Forward",
"Forward",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(forward_clicked_cb),
browser);
// new reload button
browser->reloadButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Reload",
"Reload",
"Reload",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(reload_clicked_cb),
browser);
// create the url text entry
browser->urlEntry = gtk_entry_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
TRUE, // expand
TRUE, // fill
0); // padding
// create our new gtk moz embed widget
browser->mozEmbed = gtk_moz_embed_new();
// add it to the toplevel vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
TRUE, // expand
TRUE, // fill
0); // padding
// create the new hbox for the progress area
browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// create our new progress bar
browser->progressBar = gtk_progress_bar_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create our status area and the alignment object that will keep it
// from expanding
browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(browser->statusAlign, 1, -1);
// create the status bar
browser->statusBar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
TRUE, // expand
TRUE, // fill
0); // padding
// by default none of the buttons are marked as sensitive.
gtk_widget_set_sensitive(browser->backButton, FALSE);
gtk_widget_set_sensitive(browser->stopButton, FALSE);
gtk_widget_set_sensitive(browser->forwardButton, FALSE);
gtk_widget_set_sensitive(browser->reloadButton, FALSE);
// catch the destruction of the toplevel window
gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
GTK_SIGNAL_FUNC(delete_cb), browser);
// hook up the activate signal to the right callback
gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
GTK_SIGNAL_FUNC(url_activate_cb), browser);
// close this window
gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
GTK_SIGNAL_FUNC(menu_close_cb), browser);
install_mozembed_cb(browser);
// set the chrome type so it's stored in the object
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
actualChromeMask);
return browser;
}
/*
* Windows Main
* Twitter TimeLine Cntent
*
*/
int windows_main(int argc, char **argv){
gtk_init (&argc, &argv);
char *configFile = NULL;
GError *error = NULL;
GtkWidget *window,
*table,
*scroll,
*icon_menu,
*table_into,
//*tweet,
//*avatar,
*scrolled_window,
*menu_bar,
*layout,
*toolbar,
*statusbar,
*statusbar_char,
*new_button,
*text,
*file_menu_obj,
*file_menu_root,
*file_menu_items,
*aiuto_menu_obj,
*aiuto_menu_root,
*aiuto_menu_items;
GtkTextBuffer *buffer;
asprintf(&configFile, "%s%s", g_get_home_dir(), "/.twc/config/user.twc");
/* Set all window options (color, size, position, logo, icon, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 315, 650);
gtk_widget_set_size_request (window, 315, 400);
gtk_window_set_title (GTK_WINDOW(window), "TwitCrusader");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_FAVICON, &error);
/* CALLBACK: exit event */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
/* GTK Widget: Menu */
file_menu_obj = gtk_menu_new();
aiuto_menu_obj = gtk_menu_new();
/* SuBMenu File
* Fix Icons Linux
* gconftool-2 --type boolean --set /desktop/gnome/interface/buttons_have_icons true
* gconftool-2 --type boolean --set /desktop/gnome/interface/menus_have_icons true
* */
file_menu_items = gtk_image_menu_item_new_with_label("Nuovo Utente");
icon_menu = gtk_image_new_from_file(ICON_ADDUSER);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_adduser), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Opzioni");
icon_menu = gtk_image_new_from_file(ICON_SETTINGS);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_setting), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Esci");
icon_menu = gtk_image_new_from_file(ICON_CLOSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (gtk_main_quit), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_root = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (file_menu_root), file_menu_obj);
/* SubMenu: Help */
aiuto_menu_items = gtk_image_menu_item_new_with_label("Updates");
icon_menu = gtk_image_new_from_file(ICON_UPGRADE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_upgrade), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_items = gtk_image_menu_item_new_with_label("Informazioni");
icon_menu = gtk_image_new_from_file(ICON_STAR);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_about), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_root = gtk_menu_item_new_with_label("Aiuto");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (aiuto_menu_root), aiuto_menu_obj);
/* Set Layout Position */
layout = gtk_vbox_new(0, 1);
gtk_container_add(GTK_CONTAINER(window), layout);
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(layout), menu_bar, FALSE, FALSE, 0);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file_menu_root);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), aiuto_menu_root);
/* Status Bar */
statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar), TRUE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar), 0, "TwitCrusader...");
gtk_box_pack_end (GTK_BOX (layout), statusbar, FALSE, FALSE, 0);
/* GTK Widget: Twitter Menu */
toolbar = gtk_toolbar_new ();
gtk_box_pack_end (GTK_BOX (layout), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
/* Twitter Menu: Buttons */
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_HOME);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_UPDATE);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_MENTION);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_DM);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_FAVORITES);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_LINK);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_PHOTO);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
/* Status Bar: Twitter 140char */
statusbar_char = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar_char), FALSE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar_char), 0, "140");
gtk_box_pack_end (GTK_BOX (layout), statusbar_char, FALSE, FALSE, 0);
/* Table Content Tweet/Mentions */
table = gtk_table_new (9, 3, TRUE);
gtk_container_add(GTK_CONTAINER(layout), table);
/* Scrolled */
table_into = gtk_table_new (1, 3, TRUE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_table_attach (GTK_TABLE (table), scrolled_window, 0, 3, 0, 8, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table_into);
/*for ( rows = 0; rows < 40; rows = rows + 4 ) {
for ( cols = 0; cols < 3; cols++ ) {
avatar = gtk_image_new_from_file ("");
tweet = gtk_label_new ("");
gtk_label_set_justify (GTK_LABEL(tweet),GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap_mode (GTK_LABEL(tweet), GTK_WRAP_WORD_CHAR);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 0, 1,rows, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows, rows + 1, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
tweet = gtk_label_new ("");
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows + 1, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
}
}*/
// TextArea + Scrollbar
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_table_attach (GTK_TABLE (table), scroll, 0, 3,8, 9, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_set_text (buffer, "", -1);
g_signal_connect(buffer, "changed", G_CALLBACK(update_statusbar), statusbar_char);
g_signal_connect(text, "key-press-event", G_CALLBACK(send_tweet_gtk), buffer);
gtk_container_add(GTK_CONTAINER(scroll), text);
// Widget Show
gtk_widget_show_all (window);
//Exist Config File?
if(readUserFile()==1) windows_adduser();
//Show GTK Main
gtk_main ();
return 0;
}
/*****************************************************************************
* Initialize and launch the interface
*****************************************************************************/
static void *Thread( void *obj )
{
intf_thread_t *p_intf = (intf_thread_t *)obj;
const char *p_args[] = { "vlc" };
int i_args = sizeof(p_args)/sizeof(char *);
char **pp_args = (char **)p_args;
HildonProgram *program;
HildonWindow *window;
GtkWidget *main_vbox, *bottom_hbox;
GtkWidget *video, *seekbar;
GtkWidget *play_button, *prev_button, *next_button;
GtkWidget *stop_button, *playlist_button;
gtk_init( &i_args, &pp_args );
program = HILDON_PROGRAM( hildon_program_get_instance() );
g_set_application_name( "VLC Media Player" );
window = HILDON_WINDOW( hildon_window_new() );
hildon_program_add_window( program, window );
gtk_object_set_data( GTK_OBJECT( window ), "p_intf", p_intf );
p_intf->p_sys->p_main_window = window;
g_signal_connect( GTK_WIDGET(window), "key-press-event",
G_CALLBACK( key_cb ), p_intf );
g_signal_connect (GTK_WIDGET(window), "delete_event",
GTK_SIGNAL_FUNC( quit_event), p_intf );
// A little theming
char *psz_rc_file = NULL;
char *psz_data = config_GetDataDir( p_intf );
if( asprintf( &psz_rc_file, "%s/maemo/vlc_intf.rc", psz_data ) != -1 )
{
gtk_rc_parse( psz_rc_file );
free( psz_rc_file );
}
free( psz_data );
// We create the main vertical box
main_vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( window ), main_vbox );
// Menubar
GtkWidget *main_menu = create_menu( p_intf );
#ifdef HAVE_MAEMO
hildon_window_set_menu( HILDON_WINDOW( p_intf->p_sys->p_main_window ),
GTK_MENU( main_menu ) );
#else
GtkWidget *menu_bar = gtk_menu_bar_new ();
GtkWidget *item = gtk_menu_item_new_with_label ("Menu");
gtk_menu_bar_append(menu_bar, item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), main_menu);
gtk_widget_show_all (menu_bar);
gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, FALSE, 0);
#endif
// We put first the embedded video
video = gtk_event_box_new();
GdkColor black = {0,0,0,0};
gtk_widget_modify_bg(video, GTK_STATE_NORMAL, &black);
p_intf->p_sys->p_video_window = video;
gtk_box_pack_start( GTK_BOX( main_vbox ), video, TRUE, TRUE, 0 );
create_playlist( p_intf );
gtk_box_pack_start( GTK_BOX( main_vbox ), p_intf->p_sys->p_playlist_window, TRUE, TRUE, 0 );
// We put the horizontal box which contains all the buttons
p_intf->p_sys->p_control_window = bottom_hbox = gtk_hbox_new( FALSE, 0 );
// We create the buttons
play_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( play_button ),
gtk_image_new_from_stock( "vlc-play", GTK_ICON_SIZE_BUTTON ) );
p_intf->p_sys->p_play_button = play_button;
stop_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( stop_button ),
gtk_image_new_from_stock( "vlc-stop", GTK_ICON_SIZE_BUTTON ) );
prev_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( prev_button ),
gtk_image_new_from_stock( "vlc-previous", GTK_ICON_SIZE_BUTTON ) );
next_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( next_button ),
gtk_image_new_from_stock( "vlc-next", GTK_ICON_SIZE_BUTTON ) );
playlist_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( playlist_button ),
gtk_image_new_from_stock( "vlc-playlist", GTK_ICON_SIZE_BUTTON ) );
seekbar = hildon_seekbar_new();
p_intf->p_sys->p_seekbar = HILDON_SEEKBAR( seekbar );
// We add them to the hbox
gtk_box_pack_start( GTK_BOX( bottom_hbox ), play_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), stop_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), prev_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), next_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), playlist_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), seekbar , TRUE , TRUE , 5 );
// We add the hbox to the main vbox
gtk_box_pack_start( GTK_BOX( main_vbox ), bottom_hbox, FALSE, FALSE, 0 );
g_signal_connect( play_button, "clicked", G_CALLBACK( play_cb ), NULL );
g_signal_connect( stop_button, "clicked", G_CALLBACK( stop_cb ), NULL );
g_signal_connect( prev_button, "clicked", G_CALLBACK( prev_cb ), NULL );
g_signal_connect( next_button, "clicked", G_CALLBACK( next_cb ), NULL );
g_signal_connect( playlist_button, "clicked", G_CALLBACK( playlist_cb ), NULL );
g_signal_connect( seekbar, "change-value",
G_CALLBACK( seekbar_changed_cb ), NULL );
gtk_widget_show_all( GTK_WIDGET( window ) );
gtk_widget_hide_all( p_intf->p_sys->p_playlist_window );
#if 1
/* HACK: Only one X11 client can subscribe to mouse button press events.
* VLC currently handles those in the video display.
* Force GTK to unsubscribe from mouse press and release events. */
Display *dpy = GDK_WINDOW_XDISPLAY( gtk_widget_get_window(p_intf->p_sys->p_video_window) );
Window w = GDK_WINDOW_XID( gtk_widget_get_window(p_intf->p_sys->p_video_window) );
XWindowAttributes attr;
XGetWindowAttributes( dpy, w, &attr );
attr.your_event_mask &= ~(ButtonPressMask|ButtonReleaseMask);
XSelectInput( dpy, w, attr.your_event_mask );
#endif
// The embedded video is only ready after gtk_main and windows are shown
g_idle_add( interface_ready, p_intf );
gtk_main();
delete_input( p_intf );
delete_playlist( p_intf );
gtk_object_destroy( GTK_OBJECT( main_menu ) );
gtk_object_destroy( GTK_OBJECT( window ) );
return NULL;
}
static TestGtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
guint32 actualChromeMask = chromeMask;
TestGtkBrowser *browser = 0;
num_browsers++;
browser = g_new0(TestGtkBrowser, 1);
browser_list = g_list_prepend(browser_list, browser);
browser->menuBarOn = FALSE;
browser->toolBarOn = FALSE;
browser->locationBarOn = FALSE;
browser->statusBarOn = FALSE;
g_print("new_gtk_browser\n");
if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
{
browser->menuBarOn = TRUE;
g_print("\tmenu bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
{
browser->toolBarOn = TRUE;
g_print("\ttool bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
{
browser->locationBarOn = TRUE;
g_print("\tlocation bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
{
browser->statusBarOn = TRUE;
g_print("\tstatus bar\n");
}
// create our new toplevel window
browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// new vbox
browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
// add it to the toplevel window
gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
browser->topLevelVBox);
// create our menu bar
browser->menuBar = gtk_menu_bar_new();
// create the file menu
browser->fileMenuItem = gtk_menu_item_new_with_label("File");
browser->fileMenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
browser->fileMenu);
browser->fileOpenNewBrowser =
gtk_menu_item_new_with_label("Open New Browser");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileOpenNewBrowser);
browser->fileStream =
gtk_menu_item_new_with_label("Test Stream");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileStream);
browser->fileClose =
gtk_menu_item_new_with_label("Close");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileClose);
browser->fileQuit =
gtk_menu_item_new_with_label("Quit");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileQuit);
// append it
gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->menuBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create the hbox that will contain the toolbar and the url text entry bar
browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
// add that hbox to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->toolbarHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */
#ifdef MOZ_WIDGET_GTK2
browser->toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
FALSE, // expand
FALSE, // fill
0); // padding
// new back button
browser->backButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Back",
"Go Back",
"Go Back",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(back_clicked_cb),
browser);
// new stop button
browser->stopButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Stop",
"Stop",
"Stop",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(stop_clicked_cb),
browser);
// new forward button
browser->forwardButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Forward",
"Forward",
"Forward",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(forward_clicked_cb),
browser);
// new reload button
browser->reloadButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Reload",
"Reload",
"Reload",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(reload_clicked_cb),
browser);
// create the url text entry
browser->urlEntry = gtk_entry_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
TRUE, // expand
TRUE, // fill
0); // padding
// create our new gtk moz embed widget
browser->mozEmbed = gtk_moz_embed_new();
// add it to the toplevel vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
TRUE, // expand
TRUE, // fill
0); // padding
// create the new hbox for the progress area
browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// create our new progress bar
browser->progressBar = gtk_progress_bar_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create our status area and the alignment object that will keep it
// from expanding
browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(browser->statusAlign, 1, -1);
// create the status bar
browser->statusBar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
TRUE, // expand
TRUE, // fill
0); // padding
// by default none of the buttons are marked as sensitive.
gtk_widget_set_sensitive(browser->backButton, FALSE);
gtk_widget_set_sensitive(browser->stopButton, FALSE);
gtk_widget_set_sensitive(browser->forwardButton, FALSE);
gtk_widget_set_sensitive(browser->reloadButton, FALSE);
// catch the destruction of the toplevel window
gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
GTK_SIGNAL_FUNC(delete_cb), browser);
// hook up the activate signal to the right callback
gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
GTK_SIGNAL_FUNC(url_activate_cb), browser);
// hook up to the open new browser activation
gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
GTK_SIGNAL_FUNC(menu_open_new_cb), browser);
// hook up to the stream test
gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate",
GTK_SIGNAL_FUNC(menu_stream_cb), browser);
// close this window
gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
GTK_SIGNAL_FUNC(menu_close_cb), browser);
// quit the application
gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate",
GTK_SIGNAL_FUNC(menu_quit_cb), browser);
// hook up the location change to update the urlEntry
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location",
GTK_SIGNAL_FUNC(location_changed_cb), browser);
// hook up the title change to update the window title
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title",
GTK_SIGNAL_FUNC(title_changed_cb), browser);
// hook up the start and stop signals
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start",
GTK_SIGNAL_FUNC(load_started_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop",
GTK_SIGNAL_FUNC(load_finished_cb), browser);
// hook up to the change in network status
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state",
GTK_SIGNAL_FUNC(net_state_change_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all",
GTK_SIGNAL_FUNC(net_state_change_all_cb), browser);
// hookup to changes in progress
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress",
GTK_SIGNAL_FUNC(progress_change_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all",
GTK_SIGNAL_FUNC(progress_change_all_cb), browser);
// hookup to changes in over-link message
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message",
GTK_SIGNAL_FUNC(link_message_cb), browser);
// hookup to changes in js status message
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status",
GTK_SIGNAL_FUNC(js_status_cb), browser);
// hookup to see whenever a new window is requested
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window",
GTK_SIGNAL_FUNC(new_window_cb), browser);
// hookup to any requested visibility changes
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility",
GTK_SIGNAL_FUNC(visibility_cb), browser);
// hookup to the signal that says that the browser requested to be
// destroyed
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser",
GTK_SIGNAL_FUNC(destroy_brsr_cb), browser);
// hookup to the signal that is called when someone clicks on a link
// to load a new uri
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
GTK_SIGNAL_FUNC(open_uri_cb), browser);
// this signal is emitted when there's a request to change the
// containing browser window to a certain height, like with width
// and height args for a window.open in javascript
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to",
GTK_SIGNAL_FUNC(size_to_cb), browser);
// key event signals
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down",
GTK_SIGNAL_FUNC(dom_key_down_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press",
GTK_SIGNAL_FUNC(dom_key_press_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up",
GTK_SIGNAL_FUNC(dom_key_up_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down",
GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up",
GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click",
GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click",
GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over",
GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out",
GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_activate",
GTK_SIGNAL_FUNC(dom_activate_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_in",
GTK_SIGNAL_FUNC(dom_focus_in_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_out",
GTK_SIGNAL_FUNC(dom_focus_out_cb), browser);
// hookup to when the window is destroyed
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy",
GTK_SIGNAL_FUNC(destroy_cb), browser);
// set the chrome type so it's stored in the object
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
actualChromeMask);
return browser;
}
void
do_menu (GtkWidget * vbox)
{
GtkWidget *menu_bar, *menu, *smenu;
GtkWidget *mi;
GtkWidget *handlebox;
menu_bar = gtk_menu_bar_new ();
menu = gtk_menu_item_new_with_label (_("File"));
gtk_widget_show (menu);
smenu = gtk_menu_new ();
gtk_widget_show (smenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu);
mi = gtk_menu_item_new_with_label (_("C-Wizard"));
gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (clist),
NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new_with_label (_("Connect"));
gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (cbox),
NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new_with_label (_("Disconnect"));
gtk_signal_connect (GTK_OBJECT (mi), "activate",
GTK_SIGNAL_FUNC (disconnect), NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
/*
mi = gtk_menu_item_new_with_label (_("Preferences..."));
gtk_signal_connect (GTK_OBJECT (mi), "activate",
GTK_SIGNAL_FUNC (show_config), NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
*/
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new_with_label (_("Exit"));
gtk_signal_connect (GTK_OBJECT (mi), "activate",
GTK_SIGNAL_FUNC (bmud_exit), NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu);
menu = gtk_menu_item_new_with_label (_("Tools"));
gtk_widget_show (menu);
smenu = gtk_menu_new ();
gtk_widget_show (smenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu);
mi = gtk_menu_item_new_with_label (_("Equip"));
gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (NULL),
NULL);
gtk_widget_set_sensitive (GTK_WIDGET (mi), FALSE);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new_with_label (_("Map"));
gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (NULL),
NULL);
gtk_widget_set_sensitive (GTK_WIDGET (mi), FALSE);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu);
menu = gtk_menu_item_new_with_label (_("Help"));
gtk_widget_show (menu);
gtk_menu_item_right_justify (GTK_MENU_ITEM (menu));
smenu = gtk_menu_new ();
gtk_widget_show (smenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu);
mi = gtk_menu_item_new_with_label (_("About"));
gtk_signal_connect (GTK_OBJECT (mi), "activate",
GTK_SIGNAL_FUNC (do_about), NULL);
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
mi = gtk_menu_item_new_with_label (_("Manual")); /* I d'no about this one */
/* gtk_signal_connect(GTK_OBJECT(mi),"activate",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); */
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (smenu), mi);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu);
gtk_widget_show (menu_bar);
handlebox = gtk_handle_box_new ();
gtk_widget_show (handlebox);
gtk_container_add (GTK_CONTAINER (handlebox), menu_bar);
gtk_box_pack_start (GTK_BOX (vbox), handlebox, FALSE, FALSE, 0);
return;
}
GtkWidget *
create_term_menu(ZvtTerm *term, gchar *command)
{
GtkWidget *menu_bar;
GtkWidget *menu;
GtkWidget *menu_item;
GtkWidget *vide_menu;
GtkWidget *tools_menu;
GtkWidget *term_label;
GdkColor color = TAB_COLOR;
GtkStyle *defstyle;
GtkStyle *style = gtk_style_new();
menu_bar = gtk_menu_bar_new();
defstyle = gtk_widget_get_default_style();
style = gtk_style_copy(defstyle);
style->fg[0] = color;
menu = gtk_menu_new();
gtk_signal_connect(GTK_OBJECT(menu), "key_press_event",
GTK_SIGNAL_FUNC(menu_key_cb), NULL);
gtk_object_set_data(GTK_OBJECT(term), "menu_bar", menu_bar);
/* The terminal is running vi */
if(GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(term))))
{
add_menu_item(menu, "Open File in Buffer", create_fileselector,
GUINT_TO_POINTER(0));
if(strcmp(cfg.vi_clone, "vi"))
add_menu_item (menu, "Split Buffer & Open File", create_fileselector,
GUINT_TO_POINTER(1));
if(!strcmp(cfg.vi_clone, "vim"))
add_menu_item (menu, "VSplit Buffer & Open File", create_fileselector,
GUINT_TO_POINTER(2));
add_menu_separator (menu);
}
add_menu_item(menu, "Open File in New Term",
create_fileselector, GUINT_TO_POINTER(3));
add_menu_separator (menu);
add_menu_item(menu, "New Shell", split_zterm, NULL);
add_menu_separator(menu);
add_menu_item(menu, "List Pages", create_page_menu, NULL);
add_menu_separator(menu);
add_menu_item(menu, "Detach Term", detach_term, term);
add_menu_separator(menu);
add_menu_item (menu, "Cancel", NULL, NULL);
vide_menu = add_submenu (menu_bar, "_Vide", menu);
gtk_object_set_data(GTK_OBJECT(term), "vide_menu", vide_menu);
menu = gtk_menu_new();
gtk_signal_connect(GTK_OBJECT(menu), "key_press_event",
GTK_SIGNAL_FUNC(menu_key_cb), NULL);
add_menu_item(menu, "Look up word", lookup_word, term);
add_menu_separator(menu);
/*
add_menu_item(menu, "Compare file to..", compare_file, term);
add_menu_separator(menu);
*/
/* I don't know how to visually select text in nvi and vile
if((!strcmp("vim", cfg.vi_clone) | (!strcmp("elvis", cfg.vi_clone))))
{
add_menu_item(menu, "Copy", copy_text, term);
add_menu_separator(menu);
add_menu_item(menu, "Paste", paste_text, term);
add_menu_separator(menu);
}
*/
add_menu_item(menu, "Cancel", NULL, NULL);
tools_menu = add_submenu(menu_bar, "_Tools", menu);
gtk_object_set_data(GTK_OBJECT(term), "tools_menu", tools_menu);
/* label for filename on menubar */
menu = gtk_menu_new();
menu_item = gtk_menu_item_new();
term_label = gtk_widget_new(GTK_TYPE_LABEL,
"GtkWidget::visible", TRUE,
"GtkWidget::parent", menu_item,
"GtkMisc::xalign", 0, 0, NULL);
gtk_label_set_text(GTK_LABEL(term_label), command);
gtk_widget_set_style(GTK_WIDGET(term_label), style);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), menu_item);
gtk_menu_item_right_justify(GTK_MENU_ITEM(menu_item));
gtk_widget_show(menu_item);
gtk_object_set_data(GTK_OBJECT(term), "term_label", term_label);
return menu_bar;
}
static void
setup_gtk (state_t *self)
{
self->window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
gtk_window_set_title(self->window, "Camview");
gtk_window_set_resizable(self->window, TRUE);
gtk_window_set_default_size(self->window, 1000, 540);
gtk_signal_connect (GTK_OBJECT (self->window), "delete_event",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (self->window), vbox);
// menu bar
GtkWidget *menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, TRUE, 0);
// file menu
GtkWidget *file_menu_item = gtk_menu_item_new_with_mnemonic ("_File");
gtk_menu_bar_append (GTK_MENU_BAR (menubar), file_menu_item);
GtkWidget *file_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_menu_item), file_menu);
GtkWidget *open_mi =
gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, NULL);
gtk_menu_append (GTK_MENU (file_menu), open_mi);
gtk_signal_connect (GTK_OBJECT (open_mi), "activate",
GTK_SIGNAL_FUNC (on_open_menu_item_activate), self);
GtkWidget *save_mi =
gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL);
gtk_menu_append (GTK_MENU (file_menu), save_mi);
gtk_signal_connect (GTK_OBJECT (save_mi), "activate",
GTK_SIGNAL_FUNC (on_save_menu_item_activate), self);
GtkWidget *quit_mi =
gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
gtk_menu_append (GTK_MENU (file_menu), quit_mi);
gtk_signal_connect (GTK_OBJECT (quit_mi), "activate",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
// view menu
GtkWidget *view_menu_item = gtk_menu_item_new_with_mnemonic ("_View");
gtk_menu_bar_append (GTK_MENU_BAR (menubar), view_menu_item);
GtkWidget *view_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (view_menu_item), view_menu);
GtkWidget *show_manager_mi =
gtk_check_menu_item_new_with_mnemonic ("Show _Manager");
gtk_menu_append (GTK_MENU (view_menu), show_manager_mi);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_manager_mi),
TRUE);
gtk_signal_connect (GTK_OBJECT (show_manager_mi), "toggled",
GTK_SIGNAL_FUNC (on_show_manager_mi_toggled), self);
GtkWidget *show_chain_mi =
gtk_check_menu_item_new_with_mnemonic ("Show _Chain");
gtk_menu_append (GTK_MENU (view_menu), show_chain_mi);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_chain_mi), TRUE);
gtk_signal_connect (GTK_OBJECT (show_chain_mi), "toggled",
GTK_SIGNAL_FUNC (on_show_chain_mi_toggled), self);
// horizontal panes
GtkWidget *hpane1 = gtk_hpaned_new ();
gtk_box_pack_start (GTK_BOX (vbox), hpane1, TRUE, TRUE, 0);
self->manager_frame = gtk_frame_new ("Manager");
gtk_paned_pack1 (GTK_PANED (hpane1), self->manager_frame, FALSE, TRUE);
GtkWidget *hpane2 = gtk_hpaned_new ();
gtk_paned_pack2 (GTK_PANED(hpane1), hpane2, TRUE, TRUE);
self->chain_frame = gtk_frame_new ("Chain");
GtkWidget *display_frame = gtk_frame_new ("Display");
gtk_paned_pack1 (GTK_PANED(hpane2), display_frame, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED(hpane2), self->chain_frame, FALSE, TRUE);
gtk_paned_set_position (GTK_PANED (hpane1), 200);
gtk_paned_set_position (GTK_PANED (hpane2), 400);
// manager widget
self->manager_widget = cam_unit_manager_widget_new ();
GtkWidget *sw1 = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (sw1), GTK_WIDGET (self->manager_widget));
//gtk_paned_pack1 (GTK_PANED (hpane1), sw, FALSE, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
g_signal_connect (G_OBJECT (self->manager_widget),
"unit-description-activated",
G_CALLBACK (on_unit_description_activated), self);
// description widget
self->desc_widget = cam_unit_description_widget_new ();
cam_unit_description_widget_set_manager (
CAM_UNIT_DESCRIPTION_WIDGET (self->desc_widget),
self->manager_widget);
GtkWidget *sw2 = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw2),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw2), GTK_WIDGET (self->desc_widget));
// vertical pane
GtkWidget * vpane = gtk_vpaned_new ();
gtk_paned_pack1 (GTK_PANED (vpane), sw1, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (vpane), sw2, FALSE, TRUE);
gtk_paned_set_position (GTK_PANED (vpane), 350);
//gtk_paned_pack1 (GTK_PANED (hpane1), vpane, FALSE, TRUE);
gtk_container_add (GTK_CONTAINER (self->manager_frame), vpane);
// chain gl widget
self->chain_gl_widget = cam_unit_chain_gl_widget_new (self->chain);
gtk_container_add (GTK_CONTAINER (display_frame),
GTK_WIDGET (self->chain_gl_widget));
// chain widget
self->chain_widget = cam_unit_chain_widget_new (self->chain);
GtkWidget *sw_chain = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (self->chain_frame), sw_chain);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw_chain),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw_chain),
GTK_WIDGET (self->chain_widget));
gtk_widget_show_all (GTK_WIDGET (self->window));
g_timeout_add(250, decay_fps, self);
}
/* this makes a new screen: */
struct tme_gtk_screen *
_tme_gtk_screen_new(struct tme_gtk_display *display)
{
struct tme_gtk_screen *screen, **_prev;
GtkWidget *menu_bar;
GtkWidget *menu;
GtkWidget *submenu;
GtkWidget *menu_item;
tme_uint8_t *bitmap_data;
unsigned int y;
#define BLANK_SIDE (16 * 8)
/* create the new screen and link it in: */
for (_prev = &display->tme_gtk_display_screens;
(screen = *_prev) != NULL;
_prev = &screen->tme_gtk_screen_next);
screen = *_prev = tme_new0(struct tme_gtk_screen, 1);
/* the backpointer to the display: */
screen->tme_gtk_screen_display = display;
/* there is no framebuffer connection yet: */
screen->tme_gtk_screen_fb = NULL;
/* the user hasn't specified a scaling yet: */
screen->tme_gtk_screen_fb_scale
= -TME_FB_XLAT_SCALE_NONE;
/* we have no colorset: */
screen->tme_gtk_screen_colorset = TME_FB_COLORSET_NONE;
/* create the top-level window, and allow it to shrink, grow,
and auto-shrink: */
screen->tme_gtk_screen_window
= gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(screen->tme_gtk_screen_window),
FALSE, FALSE, TRUE);
/* create the outer vertical packing box: */
screen->tme_gtk_screen_vbox0
= gtk_vbox_new(FALSE, 0);
/* add the outer vertical packing box to the window: */
gtk_container_add(GTK_CONTAINER(screen->tme_gtk_screen_window),
screen->tme_gtk_screen_vbox0);
/* create the menu bar and pack it into the outer vertical packing
box: */
menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start(GTK_BOX(screen->tme_gtk_screen_vbox0),
menu_bar,
FALSE, FALSE, 0);
gtk_widget_show(menu_bar);
/* create the Screen menu: */
menu = gtk_menu_new();
/* create the Screen scaling submenu: */
submenu
= _tme_gtk_display_menu_radio(screen,
_tme_gtk_screen_submenu_scaling);
/* create the Screen scaling submenu item: */
menu_item = gtk_menu_item_new_with_label(_("Scale"));
gtk_widget_show(menu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
gtk_menu_append(GTK_MENU(menu), menu_item);
/* create the Screen menu bar item, attach the menu to it, and
attach the menu bar item to the menu bar: */
menu_item = gtk_menu_item_new_with_label("Screen");
gtk_widget_show(menu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), menu_item);
/* create an event box for the framebuffer area: */
screen->tme_gtk_screen_event_box
= gtk_event_box_new();
/* pack the event box into the outer vertical packing box: */
gtk_box_pack_start(GTK_BOX(screen->tme_gtk_screen_vbox0),
screen->tme_gtk_screen_event_box,
FALSE, FALSE, 0);
/* show the event box: */
gtk_widget_show(screen->tme_gtk_screen_event_box);
/* create a GdkImage of an alternating-bits area. we must use
malloc() here since this memory will end up as part of an XImage,
and X will call free() on it: */
bitmap_data = (tme_uint8_t *)
malloc((BLANK_SIDE * BLANK_SIDE) / 8);
assert(bitmap_data != NULL);
for (y = 0;
y < BLANK_SIDE;
y++) {
memset(bitmap_data
+ (y * BLANK_SIDE / 8),
(y & 1
? 0x33
: 0xcc),
(BLANK_SIDE / 8));
}
screen->tme_gtk_screen_gdkimage
= gdk_image_new_bitmap(gdk_visual_get_system(),
bitmap_data,
BLANK_SIDE,
BLANK_SIDE);
/* create the GtkImage for the framebuffer area: */
screen->tme_gtk_screen_gtkimage
= gtk_image_new_from_image(screen->tme_gtk_screen_gdkimage, NULL);
/* add the GtkImage to the event box: */
gtk_container_add(GTK_CONTAINER(screen->tme_gtk_screen_event_box),
screen->tme_gtk_screen_gtkimage);
/* show the GtkImage: */
gtk_widget_show(screen->tme_gtk_screen_gtkimage);
/* show the outer vertical packing box: */
gtk_widget_show(screen->tme_gtk_screen_vbox0);
/* show the top-level window: */
gtk_widget_show(screen->tme_gtk_screen_window);
/* there is no translation function: */
screen->tme_gtk_screen_fb_xlat = NULL;
/* attach the mouse to this screen: */
_tme_gtk_mouse_attach(screen);
/* attach the keyboard to this screen: */
_tme_gtk_keyboard_attach(screen);
return (screen);
}
//-------------------------------------------------
// 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;
}
