static GtkWidget *
normal_contents (void)
{
GtkWidget *table;
GtkWidget *toolbar;
GtkWidget *handlebox;
GtkWidget *statusbar;
GtkWidget *contents;
GtkWidget *sw;
GtkItemFactory *item_factory;
table = gtk_table_new (1, 4, FALSE);
/* Create the menubar
*/
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", NULL);
gtk_item_factory_set_translate_func(item_factory,
(GtkTranslateFunc)gettext, NULL, NULL);
/* Set up item factory to go away */
g_object_ref (item_factory);
g_object_ref_sink (item_factory);
g_object_unref (item_factory);
g_object_set_data_full (G_OBJECT (table),
"<main>",
item_factory,
(GDestroyNotify) g_object_unref);
/* create menu items */
gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items),
menu_items, NULL);
gtk_table_attach (GTK_TABLE (table),
gtk_item_factory_get_widget (item_factory, "<main>"),
/* X direction */ /* Y direction */
0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Create the toolbar
*/
toolbar = gtk_toolbar_new ();
GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
gtk_tool_item_set_tooltip_text(newButton,
"Open another one of these windows");
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
newButton,
-1); /*-1 means append to end of toolbar*/
GtkToolItem *openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_tool_item_set_tooltip_text(openButton,
"This is a demo button with an \'open\' icon");
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
openButton,
-1); /*-1 means append to end of toolbar*/
GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
gtk_tool_item_set_tooltip_text(quitButton,
"This is a demo button with a \'quit\' icon");
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
quitButton,
-1); /*-1 means append to end of toolbar*/
handlebox = gtk_handle_box_new ();
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
gtk_table_attach (GTK_TABLE (table),
handlebox,
/* X direction */ /* Y direction */
0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Create document
*/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_table_attach (GTK_TABLE (table),
sw,
/* X direction */ /* Y direction */
0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
contents = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
PANGO_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
gtk_table_attach (GTK_TABLE (table),
statusbar,
/* X direction */ /* Y direction */
0, 1, 3, 4,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gtk_widget_show_all (table);
return table;
}
int
main (int argc, char *argv[])
{
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *checkbutton;
GtkAccelGroup *accel_group;
GtkItemFactory *item_factory;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "Socket Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items (item_factory,
G_N_ELEMENTS (menu_items), menu_items,
NULL);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_item_factory_get_widget (item_factory, "<main>"),
FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add Active Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_active_child), vbox);
button = gtk_button_new_with_label ("Add Passive Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_passive_child), vbox);
button = gtk_button_new_with_label ("Add Local Active Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_local_active_child), vbox);
button = gtk_button_new_with_label ("Add Local Passive Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_local_passive_child), vbox);
button = gtk_button_new_with_label ("Remove Last Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (remove_child), vbox);
checkbutton = gtk_check_button_new_with_label ("Grab keyboard");
gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (grab_window_toggled),
window);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(hbox), entry, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Steal");
gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (steal),
entry);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
box = hbox;
gtk_widget_show_all (window);
gtk_main ();
if (n_children)
{
g_print ("Waiting for children to exit\n");
while (n_children)
g_main_context_iteration (NULL, TRUE);
}
return 0;
}
void _HYGWindow::_SetMenuBar(void)
{
_HYWindow::_SetMenuBar();
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Copy"), TRUE);
}
gint main(gint argc, gchar **argv)
{
Conf *conf;
gchar *stdin_data = NULL;
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
pub = g_malloc(sizeof(PublicData));
pub->fi = g_malloc(sizeof(FileInfo));
pub->fi->filename = NULL;
pub->fi->charset = NULL;
pub->fi->charset_flag = FALSE;
pub->fi->lineend = LF;
parse_args(argc, argv, pub->fi);
#if !ENABLE_XINPUT2
gdk_disable_multidevice();
#endif
gtk_init(&argc, &argv);
g_set_application_name(PACKAGE_NAME);
pub->mw = create_main_window();
conf = g_malloc(sizeof(Conf));
conf->width = 600;
conf->height = 400;
conf->fontname = g_strdup("Monospace 12");
conf->wordwrap = FALSE;
conf->linenumbers = FALSE;
conf->autoindent = FALSE;
load_config_file(conf);
gtk_window_set_default_size(
GTK_WINDOW(pub->mw->window), conf->width, conf->height);
set_text_font_by_name(pub->mw->view, conf->fontname);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
gtk_item_factory_get_widget(pub->mw->menubar, "/M/Options/WordWrap")),
conf->wordwrap);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
gtk_item_factory_get_widget(pub->mw->menubar, "/M/Options/LineNumbers")),
conf->linenumbers);
indent_refresh_tab_width(pub->mw->view);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
gtk_item_factory_get_widget(pub->mw->menubar, "/M/Options/AutoIndent")),
conf->autoindent);
gtk_widget_show_all(pub->mw->window);
g_free(conf->fontname);
g_free(conf);
#if ENABLE_EMACS
check_emacs_key_theme(GTK_WINDOW(pub->mw->window), pub->mw->menubar);
#endif
hlight_init(pub->mw->buffer);
undo_init(pub->mw->view,
gtk_item_factory_get_widget(pub->mw->menubar, "/M/Edit/Undo"),
gtk_item_factory_get_widget(pub->mw->menubar, "/M/Edit/Redo"));
// hlight_init(pub->mw->buffer);
dnd_init(pub->mw->view);
if (pub->fi->filename)
file_open_real(pub->mw->view, pub->fi);
#ifdef G_OS_UNIX
else
stdin_data = gedit_utils_get_stdin();
#endif
if (stdin_data) {
gchar *str;
GtkTextIter iter;
str = g_convert(stdin_data, -1, "UTF-8",
get_default_charset(), NULL, NULL, NULL);
g_free(stdin_data);
// gtk_text_buffer_set_text(buffer, "", 0);
gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
gtk_text_buffer_insert(pub->mw->buffer, &iter, str, strlen(str));
gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
gtk_text_buffer_set_modified(pub->mw->buffer, FALSE);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(pub->mw->view), &iter, 0, FALSE, 0, 0);
g_free(str);
}
if (jump_linenum) {
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(pub->mw->buffer, &iter, jump_linenum - 1);
gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
// gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5);
scroll_to_cursor(pub->mw->buffer, 0.25);
}
set_main_window_title();
// hlight_apply_all(pub->mw->buffer);
gtk_main();
return 0;
}
void GUI_CreateSpeedDialWindow(void)
{
int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
SortColumn *sColumn;
GtkWidget *menubar;
GtkWidget *main_vbox;
GtkWidget *toolbar;
GtkWidget *clistScrolledWindow;
register gint i;
gchar *titles[3] = { _("Key"), _("Name"), _("Number") };
InitMainMenu();
GUI_SpeedDialWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(GUI_SpeedDialWindow), "SpeedDialWindow", "Xgnokii");
gtk_window_set_title(GTK_WINDOW(GUI_SpeedDialWindow), _("Speed Dial"));
gtk_widget_set_usize(GTK_WIDGET(GUI_SpeedDialWindow), 350, 220);
//gtk_container_set_border_width (GTK_CONTAINER (GUI_SpeedDialWindow), 10);
gtk_signal_connect(GTK_OBJECT(GUI_SpeedDialWindow), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
gtk_widget_realize(GUI_SpeedDialWindow);
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(GUI_SpeedDialWindow), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
menubar = gtk_item_factory_get_widget(item_factory, "<main>");
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(GUI_SpeedDialWindow), main_vbox);
gtk_widget_show(main_vbox);
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show(menubar);
/* Create the toolbar */
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Read from phone"), NULL,
NewPixmap(Read_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ReadSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Save to phone"), NULL,
NewPixmap(Send_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) SaveSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Import from file"), NULL,
NewPixmap(Open_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ImportSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Export to file"), NULL,
NewPixmap(Save_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ExportSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Edit entry"), NULL,
NewPixmap(Edit_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) EditKey, NULL);
gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show(toolbar);
clist = gtk_clist_new_with_titles(3, titles);
gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT);
// gtk_clist_set_compare_func (GTK_CLIST (clist), CListCompareFunc);
gtk_clist_set_sort_column(GTK_CLIST(clist), 0);
gtk_clist_set_sort_type(GTK_CLIST(clist), GTK_SORT_ASCENDING);
gtk_clist_set_auto_sort(GTK_CLIST(clist), FALSE);
//gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_column_width(GTK_CLIST(clist), 1, 150);
gtk_clist_set_column_width(GTK_CLIST(clist), 2, 115);
gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_CENTER);
// gtk_clist_set_column_visibility (GTK_CLIST (clist), 3, xgnokiiConfig.callerGroupsSupported);
for (i = 0; i < 3; i++) {
if ((sColumn = g_malloc(sizeof(SortColumn))) == NULL) {
g_print(_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__);
gtk_main_quit();
}
sColumn->clist = clist;
sColumn->column = i;
gtk_signal_connect(GTK_OBJECT(GTK_CLIST(clist)->column[i].button), "clicked",
GTK_SIGNAL_FUNC(SetSortColumn), (gpointer) sColumn);
}
gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(ClickEntry), NULL);
clistScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(clistScrolledWindow), clist);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistScrolledWindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(main_vbox), clistScrolledWindow, TRUE, TRUE, 0);
gtk_widget_show(clist);
gtk_widget_show(clistScrolledWindow);
questMark.pixmap = gdk_pixmap_create_from_xpm_d(GUI_SpeedDialWindow->window,
&questMark.mask,
&GUI_SpeedDialWindow->style->
bg[GTK_STATE_NORMAL], quest_xpm);
CreateErrorDialog(&errorDialog, GUI_SpeedDialWindow);
CreateInfoDialog(&infoDialog, GUI_SpeedDialWindow);
speedDialInitialized = FALSE;
}
/*****************************************************************************
* create_menubar()
*****************************************************************************/
void
create_menubar(GtkWidget *main_window, GtkWidget *box)
{
GtkAccelGroup *accel_group;
GtkItemFactory *item_factory;
#ifdef CUSTOM_FONTS_IN_MENUS
GtkWidget *widget;
#endif
int mem_mode = setting_bank_mem_mode;
/* create item factory with associated accel group */
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
/* build menubar and menus with the item factory */
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
/* handle check and radio items */
/* fullscreen checkbox */
menu_item_fullscreen = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/View/FullScreen"));
gtk_check_menu_item_set_active(menu_item_fullscreen, setting_fullscreen);
/* window layout radio group */
menu_item_notebook = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/View/Notebook"));
menu_item_one_page = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/View/One Page"));
menu_item_widescreen = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/View/WideScreen"));
switch (setting_window_layout) {
case LAYOUT_NOTEBOOK:
if (!gtk_check_menu_item_get_active(menu_item_notebook)) {
gtk_check_menu_item_set_active(menu_item_notebook, TRUE);
}
break;
case LAYOUT_ONE_PAGE:
if (!gtk_check_menu_item_get_active(menu_item_one_page)) {
gtk_check_menu_item_set_active(menu_item_one_page, TRUE);
}
break;
case LAYOUT_WIDESCREEN:
if (!gtk_check_menu_item_get_active(menu_item_widescreen)) {
gtk_check_menu_item_set_active(menu_item_widescreen, TRUE);
}
break;
}
/* jack manual/auto radio group */
menu_item_autoconnect = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/JACK/Autoconnect"));
menu_item_manualconnect = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/JACK/Manual Connect"));
if (setting_jack_autoconnect) {
if (!gtk_check_menu_item_get_active(menu_item_autoconnect)) {
gtk_check_menu_item_set_active(menu_item_autoconnect, TRUE);
}
}
else {
if (!gtk_check_menu_item_get_active(menu_item_manualconnect)) {
gtk_check_menu_item_set_active(menu_item_manualconnect, TRUE);
}
}
/* jack stereo/multi radio group */
menu_item_stereo_out = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/JACK/Stereo Output"));
menu_item_multi_out = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/JACK/Multi-Part Output"));
if (setting_jack_multi_out) {
if (!gtk_check_menu_item_get_active(menu_item_multi_out)) {
gtk_check_menu_item_set_active(menu_item_multi_out, TRUE);
}
}
else {
if (!gtk_check_menu_item_get_active(menu_item_stereo_out)) {
gtk_check_menu_item_set_active(menu_item_stereo_out, TRUE);
}
}
/* midi channel radio group */
#if MAX_PARTS > 1
menu_item_part[0] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/1"));
menu_item_part[1] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/2"));
#endif
#if MAX_PARTS > 2
menu_item_part[2] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/3"));
#endif
#if MAX_PARTS > 3
menu_item_part[3] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/4"));
#endif
#if MAX_PARTS > 4
menu_item_part[4] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/5"));
#endif
#if MAX_PARTS > 5
menu_item_part[5] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/6"));
#endif
#if MAX_PARTS > 6
menu_item_part[6] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/7"));
#endif
#if MAX_PARTS > 7
menu_item_part[7] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/8"));
#endif
#if MAX_PARTS > 8
menu_item_part[8] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/9"));
#endif
#if MAX_PARTS > 9
menu_item_part[9] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/10"));
#endif
#if MAX_PARTS > 10
menu_item_part[10] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/11"));
#endif
#if MAX_PARTS > 11
menu_item_part[11] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/12"));
#endif
#if MAX_PARTS > 12
menu_item_part[12] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/13"));
#endif
#if MAX_PARTS > 13
menu_item_part[13] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/14"));
#endif
#if MAX_PARTS > 14
menu_item_part[14] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/15"));
#endif
#if MAX_PARTS > 15
menu_item_part[15] = GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/Part/16"));
#endif
#if MAX_PARTS > 1
if (visible_part_num <= 16) {
gtk_check_menu_item_set_active(menu_item_part[visible_part_num], TRUE);
}
#endif
/* Bank memory mode radio group */
bank_mem_menu_item[BANK_MEM_AUTOSAVE] = menu_item_autosave = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/Patch/Bank Memory Autosave"));
bank_mem_menu_item[BANK_MEM_WARN] = menu_item_warn = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/Patch/Bank Memory Warn"));
bank_mem_menu_item[BANK_MEM_PROTECT] = menu_item_protect = GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_item(item_factory, "/Patch/Bank Memory Protect"));
switch (mem_mode) {
case BANK_MEM_AUTOSAVE:
gtk_check_menu_item_set_active(menu_item_autosave, TRUE);
break;
case BANK_MEM_PROTECT:
gtk_check_menu_item_set_active(menu_item_protect, TRUE);
break;
case BANK_MEM_WARN:
gtk_check_menu_item_set_active(menu_item_warn, TRUE);
break;
}
/* ALSA Menu */
alsa_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory,
"/ALSA"));
alsa_pcm_hw_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory,
"/ALSA/ALSA PCM HW"));
alsa_seq_hw_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory,
"/ALSA/ALSA Seq HW"));
alsa_seq_sw_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory,
"/ALSA/ALSA Seq SW"));
alsa_rawmidi_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory,
"/ALSA/ALSA Raw MIDI"));
widget_set_custom_font(GTK_WIDGET(alsa_menu_item), phasex_font_desc);
widget_set_custom_font(GTK_WIDGET(alsa_pcm_hw_menu_item), phasex_font_desc);
widget_set_custom_font(GTK_WIDGET(alsa_seq_hw_menu_item), phasex_font_desc);
widget_set_custom_font(GTK_WIDGET(alsa_seq_sw_menu_item), phasex_font_desc);
widget_set_custom_font(GTK_WIDGET(alsa_rawmidi_menu_item), phasex_font_desc);
if ((setting_midi_driver == MIDI_DRIVER_ALSA_SEQ) ||
(setting_midi_driver == MIDI_DRIVER_RAW_ALSA) ||
(setting_audio_driver == AUDIO_DRIVER_ALSA_PCM)) {
gtk_widget_set_sensitive(GTK_WIDGET(alsa_menu_item), TRUE);
}
else {
gtk_widget_set_sensitive(GTK_WIDGET(alsa_menu_item), FALSE);
}
/* Connect handler to build ALSA submenus */
g_signal_connect(G_OBJECT(alsa_menu_item),
"activate",
GTK_SIGNAL_FUNC(on_alsa_menu_activate),
(gpointer) 0);
/* JACK Menu */
jack_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/JACK"));
jack_midi_menu_item = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory, "/JACK/MIDI"));
widget_set_custom_font(GTK_WIDGET(jack_menu_item), phasex_font_desc);
widget_set_custom_font(GTK_WIDGET(jack_midi_menu_item), phasex_font_desc);
if (setting_audio_driver == AUDIO_DRIVER_JACK) {
gtk_widget_set_sensitive(GTK_WIDGET(jack_menu_item), TRUE);
}
else {
gtk_widget_set_sensitive(GTK_WIDGET(jack_menu_item), FALSE);
}
/* Connect handler to build JACK submenus */
g_signal_connect(G_OBJECT(jack_menu_item),
"activate",
GTK_SIGNAL_FUNC(on_jack_menu_activate),
(gpointer) 0);
/* attach menubar's accel group to main window */
gtk_window_add_accel_group(GTK_WINDOW(main_window), accel_group);
/* add the menubar to the box passed in to this function */
main_menubar = gtk_item_factory_get_widget(item_factory, "<main>");
widget_set_custom_font(main_menubar, phasex_font_desc);
widget_set_backing_store(main_menubar);
gtk_box_pack_start(GTK_BOX(box), main_menubar, FALSE, FALSE, 0);
#ifdef CUSTOM_FONTS_IN_MENUS
/* add custom fonts to the menus */
widget = gtk_item_factory_get_widget(item_factory, "/File");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/View");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/Patch");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/MIDI");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/Part");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/JACK");
widget_set_custom_font(widget, phasex_font_desc);
widget = gtk_item_factory_get_widget(item_factory, "/Help");
widget_set_custom_font(widget, phasex_font_desc);
#endif
}
GtkWidget *create_menubar(GtkWidget *window)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
struct dirent **namelist;
int n;
const char *script_path=config_get_string(CONFIG_PATH_SCRIPT);
GtkItemFactoryEntry fentry;
struct menu_script* menu_item;
char *dot;
/* Make an accelerator group (shortcut keys) */
accel_group = gtk_accel_group_new ();
/* Make an ItemFactory (that makes a menubar) */
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>",
accel_group);
/* This function generates the menu items. Pass the item factory,
the number of items in the array, the array itself, and any
callback data for the the menu items. */
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
if (script_path)
{
n = scandir(script_path, &namelist, select_lua, alphasort);
if (n > 0)
{
while(n--)
{
log_printf(LOG_INFO,"Adding %s script to menu", namelist[n]->d_name);
menu_item=(struct menu_script *)malloc(sizeof(struct menu_script));
menu_item->script_name = (char* )malloc(strlen(namelist[n]->d_name)+11);
strcpy(menu_item->script_name,"/Analyser/");
strcat(menu_item->script_name,namelist[n]->d_name);
dot = rindex(menu_item->script_name,'.');
if (dot)
*dot=0;
menu_item->script_file = strdup(namelist[n]->d_name);
menu_item->prev=SCRIPTS;
SCRIPTS = menu_item;
fentry.path=menu_item->script_name;
fentry.callback=G_CALLBACK(gui_run_script_cb);
fentry.callback_action=0;
fentry.item_type="<StockItem>";
fentry.extra_data=GTK_STOCK_PROPERTIES;
gtk_item_factory_create_item(item_factory,&fentry,menu_item,2);
}
free(namelist);
}
else
log_printf(LOG_WARNING,"No scripts found in %s",script_path);
}
/* FIXME: namelist must be deallocated but it holds pointer data for the callback */
/* Attach the new accelerator group to the window. */
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
return gtk_item_factory_get_widget (item_factory, "<main>");
}
void gtkui_create_menu(int live)
{
GtkAccelGroup *accel_group;
GtkWidget *vbox, *item;
GtkItemFactory *root_menu;
int num_items = 0;
DEBUG_MSG("gtk_create_menu");
/* remove old menu, it will be automatically destroyed by gtk_main */
vbox = gtk_bin_get_child(GTK_BIN (window));
gtk_container_remove(GTK_CONTAINER (vbox), main_menu);
/* Prepare to generate menus from the definitions in ec_gtk.h */
accel_group = gtk_accel_group_new ();
root_menu = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Start Menu */
num_items = sizeof (gmenu_start) / sizeof (gmenu_start[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_start, NULL);
/* Targets Menu */
num_items = sizeof (gmenu_targets) / sizeof (gmenu_targets[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_targets, NULL);
/* Hosts Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_hosts) / sizeof (gmenu_hosts[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_hosts, NULL);
}
/* View Menu */
num_items = sizeof (gmenu_view) / sizeof (gmenu_view[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_view, NULL);
/* MITM Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_mitm) / sizeof (gmenu_mitm[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_mitm, NULL);
}
/* Filters Menu */
num_items = sizeof (gmenu_filters) / sizeof (gmenu_filters[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_filters, NULL);
/* Logging Menu */
num_items = sizeof (gmenu_logging) / sizeof (gmenu_logging[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_logging, NULL);
#ifdef HAVE_PLUGINS
/* Plugins Menu */
if(live > 0) {
num_items = sizeof (gmenu_plugins) / sizeof (gmenu_plugins[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_plugins, NULL);
}
#endif
#ifndef OS_WINDOWS
/* Help Menu */
num_items = sizeof (gmenu_help) / sizeof (gmenu_help[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_help, NULL);
#endif
if(GBL_OPTIONS->reversed) {
GBL_OPTIONS->reversed = 0;
item = gtk_item_factory_get_item(root_menu, "/Targets/Reverse matching");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->resolve) {
GBL_OPTIONS->resolve = 0;
item = gtk_item_factory_get_item(root_menu, "/View/Resolve IP addresses");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->compress) {
GBL_OPTIONS->compress = 0;
item = gtk_item_factory_get_item(root_menu, "/Logging/Compressed file");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
/* get the menu widget and add it to the window */
main_menu = gtk_item_factory_get_widget (root_menu, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0);
gtk_widget_show(main_menu);
}
GtkWidget *menubar_new (GtkWidget *Window)
{
GtkWidget *Menu;
GtkItemFactory *ItemFactory;
GtkAccelGroup *AccelGroup;
gchar *AccelRC;
guint NbMenuEntries = sizeof (MenuEntries) / sizeof (MenuEntries[0]);
MsgBarToggleDisplay = FALSE;
ToolBarToggleDisplay = FALSE;
ToggleWordwrap = FALSE;
AccelGroup = gtk_accel_group_new();
ItemFactory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", AccelGroup);
gtk_item_factory_create_items (ItemFactory, NbMenuEntries,
MenuEntries, NULL);
gtk_window_add_accel_group (GTK_WINDOW (Window), AccelGroup);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File/Recent Files")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Edit")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools/Conversions")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Doc Tabs")), Menu);
if (MSGBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Msg Bar")),
TRUE);
if (TOOLBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Tool Bar")),
TRUE);
if (TOGGLE_WORDWRAP)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Wordwrap")),
TRUE);
if (TAB_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Top")),
TRUE);
if (TAB_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Bottom")),
TRUE);
if (TAB_POSITION == 3)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Left")),
TRUE);
if (TAB_POSITION == 4)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Scroll Bar")),
Menu);
if (SCROLLBAR_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Left")),
TRUE);
if (SCROLLBAR_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Languages")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Help")), Menu);
Menu = gtk_item_factory_get_widget (ItemFactory, "<main>");
AccelRC = g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR,
PATH_SEP_STRING, "AccelRC", NULL);
gtk_item_factory_parse_rc (AccelRC);
g_free (AccelRC);
init_recent_files ();
init_languages_menu ();
gtk_menu_bar_set_shadow_type (GTK_MENU_BAR(Menu), GTK_SHADOW_NONE);
return (Menu);
}
GtkWidget*
create_main_window (void)
{
GtkWidget *window;
GtkWidget *vbox, *hbox;
GtkWidget *vbox_scenes, *vbox_sequence, *vbox_channels;
GtkWidget *button;
GtkWidget *menubar;
GtkWidget *notebook;
GtkWidget *status_bar;
GtkWidget *label;
GtkWidget *widget;
GtkAccelGroup *accel_group;
GtkItemFactory *item_factory;
GtkItemFactoryEntry menu_entries[] = {
{ "/_File", NULL, NULL, 0, "<Branch>" },
// { "/File/tear1", NULL, NULL, 0, "<Tearoff>" },
{ "/File/_New", NULL, new_project, 1, "<StockItem>", GTK_STOCK_NEW },
{ "/File/_Open...", NULL, open_file_cb, 1, "<StockItem>", GTK_STOCK_OPEN },
{ "/File/_Save", NULL, save_file, 1, "<StockItem>", GTK_STOCK_SAVE },
{ "/File/Save as...", NULL, save_file_as_cb, 1, "<StockItem>", GTK_STOCK_SAVE_AS },
{ "/File/sep1", NULL, NULL, 0, "<Separator>" },
{ "/File/_Quit", NULL, (GtkItemFactoryCallback) quit,
0, "<StockItem>", GTK_STOCK_QUIT}
};
/*** SETUP GTK MAIN WINDOW ***/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (window), "main_window", window);
// gtk_widget_set_usize (window, 800, 600);
gtk_window_set_title (GTK_WINDOW (window), "GlowControl");
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (quit), NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
/* The menu */
accel_group = gtk_accel_group_new ();
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items (item_factory,
sizeof (menu_entries) / sizeof (menu_entries[0]),
menu_entries,
NULL);
menubar = gtk_item_factory_get_widget (item_factory, "<main>");
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
status_bar = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (vbox), status_bar, FALSE, FALSE, 0);
progress_bar = gtk_progress_bar_new ();
gtk_box_pack_start (GTK_BOX (status_bar), progress_bar, TRUE, TRUE, 0);
/*** PREPARE NOTEBOOK PAGES ***/
/* NOTEBOOK PAGE: SCENES */
vbox_scenes = gtk_vbox_new (FALSE, 0);
widget = gtk_scrolled_window_new (NULL, NULL);
scene_view = setup_list_view (scene_store);
g_signal_connect (G_OBJECT (scene_view), "row-activated",
G_CALLBACK (scene_edit_clicked), NULL);
gtk_tree_view_set_reorderable (scene_view, TRUE);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (scene_view));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox_scenes), widget, TRUE, TRUE, 0);
/* button bar */
hbox = gtk_hbox_new (TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_NEW);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (scene_new_clicked), NULL);
button = gtk_button_new_from_stock (GTK_STOCK_COPY);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (scene_copy_clicked), NULL);
button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (scene_remove_clicked), NULL);
gtk_box_pack_start (GTK_BOX (vbox_scenes), hbox, FALSE, FALSE, 0);
/* NOTEBOOK: SEQUENCE */
vbox_sequence = gtk_vbox_new (FALSE, 0);
widget = gtk_scrolled_window_new (NULL, NULL);
sequence_view = setup_list_view (sequence_store);
g_signal_connect (G_OBJECT (sequence_view), "row-activated",
G_CALLBACK (step_edit_clicked), NULL);
gtk_tree_view_set_reorderable (sequence_view, TRUE);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (sequence_view));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox_sequence), widget, TRUE, TRUE, 0);
hbox = gtk_hbox_new (TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_NEW);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (step_new_clicked), NULL);
button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (step_remove_clicked), NULL);
gtk_box_pack_start (GTK_BOX (vbox_sequence), hbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new (TRUE, 0);
button = button_new ("../pixmaps/first.xpm", _("First"), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (sequence_first), NULL);
button = button_new ("../pixmaps/prev.xpm", _("Previous"), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (sequence_prev), NULL);
play_button = button_new ("../pixmaps/play.xpm", _("Play"), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), play_button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (play_button), "clicked",
G_CALLBACK (sequence_play_clicked), NULL);
button = button_new ("../pixmaps/next.xpm", _("Next"), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (sequence_next_clicked), NULL);
button = button_new ("../pixmaps/sync.xpm", _("Back to sync"), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (sequence_back_to_sync), NULL);
gtk_box_pack_start (GTK_BOX (vbox_sequence), hbox, FALSE, FALSE, 0);
/* NOTEBOOK: CHANNELS */
vbox_channels = gtk_vbox_new (FALSE, 2);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox_channels), widget, TRUE, TRUE, 0);
channel_view = setup_list_view (channel_store);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (channel_view));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
/*** GATHER STUFF FOR NOTEBOOK ***/
label = gtk_label_new (_("Channels"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_channels, label);
label = gtk_label_new (_("Scenes"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_scenes, label);
label = gtk_label_new (_("Sequence"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_sequence, label);
gtk_widget_show_all (window);
main_window = window;
return window;
}
/*
* display the initial menu to setup global options
* at startup.
*/
static void gtkui_setup(void)
{
GtkTextIter iter;
GtkWidget *item, *vbox, *scroll, *vpaned, *logo;
GtkItemFactory *item_factory;
GClosure *closure = NULL;
GdkModifierType mods;
gint keyval, width, height, left, top;
char *path = NULL;
GtkItemFactoryEntry file_menu[] = {
{ "/_File", "<shift>F", NULL, 0, "<Branch>" },
{ "/File/_Open", "<control>O", gtkui_file_open, 0, "<StockItem>", GTK_STOCK_OPEN },
{ "/File/_Save", "<control>S", gtkui_file_write, 0, "<StockItem>", GTK_STOCK_SAVE },
{ "/File/sep1", NULL, NULL, 0, "<Separator>" },
{ "/File/E_xit", "<control>x", gtkui_exit, 0, "<StockItem>", GTK_STOCK_QUIT },
{ "/_Sniff", "<shift>S", NULL, 0, "<Branch>" },
{ "/Sniff/Unified sniffing...", "<shift>U", gtkui_unified_sniff, 0, "<StockItem>", GTK_STOCK_DND },
{ "/Sniff/Bridged sniffing...", "<shift>B", gtkui_bridged_sniff, 0, "<StockItem>", GTK_STOCK_DND_MULTIPLE },
{ "/Sniff/sep2", NULL, NULL, 0, "<Separator>" },
{ "/Sniff/Set pcap filter...", "p", gtkui_pcap_filter, 0, "<StockItem>", GTK_STOCK_PREFERENCES },
{ "/_Options", "<shift>O", NULL, 0, "<Branch>" },
{ "/Options/Unoffensive", NULL, toggle_unoffensive, 0, "<ToggleItem>" },
{ "/Options/Promisc mode", NULL, toggle_nopromisc, 0, "<ToggleItem>" },
{ "/Options/Set netmask", "n", gtkui_set_netmask, 0, "<Item>"}
#ifndef OS_WINDOWS
,{"/_?", NULL, NULL, 0, "<Branch>" },
{"/?/Contents", " ", gtkui_help, 0, "<StockItem>", GTK_STOCK_HELP }
#endif
};
gint nmenu_items = sizeof (file_menu) / sizeof (file_menu[0]);
DEBUG_MSG("gtkui_setup");
width = gtkui_conf_get("window_width");
height = gtkui_conf_get("window_height");
left = gtkui_conf_get("window_left");
top = gtkui_conf_get("window_top");
/* create menu window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), EC_PROGRAM" "EC_VERSION);
gtk_window_set_default_size(GTK_WINDOW (window), width, height);
if(left > 0 || top > 0)
gtk_window_move(GTK_WINDOW(window), left, top);
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtkui_exit), NULL);
accel_group = gtk_accel_group_new ();
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items (item_factory, nmenu_items, file_menu, NULL);
/* hidden shortcut to start Unified Sniffing with default interface */
closure = g_cclosure_new(G_CALLBACK(gtkui_unified_sniff_default), NULL, NULL);
gtk_accelerator_parse ("u", &keyval, &mods);
gtk_accel_group_connect(accel_group, keyval, mods, 0, closure);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
main_menu = gtk_item_factory_get_widget (item_factory, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_widget_show(main_menu);
if(GBL_PCAP->promisc) {
/* setting the menu item active will toggle this setting */
/* it will be TRUE after the menu is updated */
GBL_PCAP->promisc = 0;
item = gtk_item_factory_get_item(item_factory, "/Options/Promisc mode");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->unoffensive) {
GBL_OPTIONS->unoffensive = 0;
item = gtk_item_factory_get_item(item_factory, "/Options/Unoffensive");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
vpaned = gtk_vpaned_new();
/* notebook for MDI pages */
notebook_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME (notebook_frame), GTK_SHADOW_IN);
gtk_paned_pack1(GTK_PANED(vpaned), notebook_frame, TRUE, TRUE);
gtk_widget_show(notebook_frame);
path = INSTALL_DATADIR "/" EC_PROGRAM "/" LOGO_FILE;
if(g_file_test(path, G_FILE_TEST_EXISTS))
logo = gtk_image_new_from_file(path);
else /* if neither path is valid gtk will use a broken image icon */
logo = gtk_image_new_from_file("./share/" LOGO_FILE);
gtk_misc_set_alignment (GTK_MISC (logo), 0.5, 0.5);
gtk_container_add(GTK_CONTAINER (notebook_frame), logo);
gtk_widget_show(logo);
/* messages */
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
gtk_paned_pack2(GTK_PANED (vpaned), scroll, FALSE, TRUE);
gtk_widget_show(scroll);
textview = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (textview), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE);
gtk_widget_set_size_request(textview, -1, 140);
gtk_container_add(GTK_CONTAINER (scroll), textview);
gtk_widget_show(textview);
msgbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview));
gtk_text_buffer_get_end_iter(msgbuffer, &iter);
endmark = gtk_text_buffer_create_mark(msgbuffer, "end", &iter, FALSE);
gtk_box_pack_end(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
gtk_widget_show(vpaned);
gtk_widget_show(window);
DEBUG_MSG("gtk_setup: end");
}
void GTKMusicBrowser::CreateMenu(GtkWidget *topbox)
{
GtkItemFactoryEntry menu_items[] = {
{"/_File", NULL, 0, 0, "<Branch>" },
{"/File/_New Playlist", "<control>N", (GtkItemFactoryCallback)new_plist, 0, 0 },
{"/File/_Open Playlist", "<control>O", (GtkItemFactoryCallback)open_list, 0, 0 },
{"/File/_Save Playlist", "<control>S", (GtkItemFactoryCallback)save_list, 0, 0 },
{"/File/Save Playlist _As","<control>A", (GtkItemFactoryCallback)saveas_list,0, 0 },
{"/File/sep1", NULL, 0, 0, "<Separator>" },
{"/File/_Import Tracks and Playlists","<control>I", (GtkItemFactoryCallback)import_list, 0, 0 },
{"/File/_Export Playlist", NULL, (GtkItemFactoryCallback)export_list, 0, 0 },
{"/File/sep0", NULL, 0, 0, "<Separator>" },
{"/File/Search Computer for Music", NULL, (GtkItemFactoryCallback)music_search, 0, 0 },
{"/File/sep2", NULL, 0, 0, "<Separator>" },
{"/File/_Close", "<control>Q", (GtkItemFactoryCallback)quit_menu, 0, 0 },
{"/_Edit", NULL, 0, 0, "<Branch>" },
{"/_Edit/_Add Items to Playlist", NULL, (GtkItemFactoryCallback)add_track_mb, 0, 0 },
{"/_Edit/Add _Tracks or Playlists from Disk", NULL, (GtkItemFactoryCallback)add_track, 0, 0 },
{"/_Edit/_Remove Items from My Music", NULL,(GtkItemFactoryCallback)delete_sel,0, 0 },
{"/_Edit/Add Stream to Favorites", NULL, (GtkItemFactoryCallback)add_stream, 0, 0 },
{"/_Edit/sep3", NULL, 0, 0, "<Separator>" },
{"/_Edit/Move _Up", NULL, (GtkItemFactoryCallback)move_up, 0, 0 },
{"/_Edit/Move _Down", NULL, (GtkItemFactoryCallback)move_down, 0, 0 },
{"/_Edit/sep4", NULL, 0, 0, "<Separator>" },
{"/_Edit/_Clear Playlist", NULL, (GtkItemFactoryCallback)clear_list, 0, 0 },
{"/_Edit/Edit _Info", NULL, (GtkItemFactoryCallback)infoedit, 0, 0 },
{"/_View", NULL, 0, 0, "<Branch>" },
{"/_View/View _Playlist Only",NULL, (GtkItemFactoryCallback)catalog_tog, 0, 0 },
{"/_View/_Options", NULL, (GtkItemFactoryCallback)options_show, 0, 0 },
{"/_Controls", NULL, 0, 0, "<Branch>" },
{"/_Controls/_Play", NULL, (GtkItemFactoryCallback)play_menu,0, 0 },
{"/_Controls/_Stop", NULL, (GtkItemFactoryCallback)stop_menu, 0, 0 },
{"/_Controls/sep6", NULL, 0, 0, "<Separator>" },
{"/_Controls/_Eject CD", NULL, (GtkItemFactoryCallback)eject_cd, 0, 0 },
{"/_Controls/sep65", NULL, 0, 0, "<Separator>" },
{"/_Controls/_Next Track", NULL, (GtkItemFactoryCallback)next_menu, 0, 0 },
{"/_Controls/Pre_vious Track", NULL, (GtkItemFactoryCallback)prev_menu, 0, 0 },
{"/_Controls/sep7", NULL, 0, 0, "<Separator>" },
{"/_Controls/Play Tracks in Nor_mal Order", NULL, (GtkItemFactoryCallback)sort_normal, 0, "<RadioItem>" },
{"/_Controls/Play Tracks in _Random Order", NULL, (GtkItemFactoryCallback)sort_random2, 0, "/Controls/Play Tracks in Normal Order" },
{"/_Controls/sep8", NULL, 0, 0, "<Separator>" },
{"/_Controls/Repeat N_o Tracks", NULL, (GtkItemFactoryCallback)repeat_none, 0, "<RadioItem>" },
{"/_Controls/Repeat _Current Track", NULL, (GtkItemFactoryCallback)repeat_one, 0, "/Controls/Repeat No Tracks" },
{"/_Controls/Repeat _All Tracks", NULL, (GtkItemFactoryCallback)repeat_all, 0, "/Controls/Repeat No Tracks" },
{"/_Sort Playlist", NULL, 0, 0, "<Branch>" },
{"/_Sort Playlist/by _Artist", NULL, (GtkItemFactoryCallback)sort_artist, 0, 0 },
{"/_Sort Playlist/by A_lbum", NULL, (GtkItemFactoryCallback)sort_album, 0, 0 },
{"/_Sort Playlist/by _Title", NULL, (GtkItemFactoryCallback)sort_title, 0, 0 },
{"/_Sort Playlist/by _Year", NULL, (GtkItemFactoryCallback)sort_year, 0, 0 },
{"/_Sort Playlist/by Trac_k Number", NULL, (GtkItemFactoryCallback)sort_track, 0, 0 },
{"/_Sort Playlist/by _Genre", NULL, (GtkItemFactoryCallback)sort_genre, 0, 0 },
{"/_Sort Playlist/by _Length", NULL, (GtkItemFactoryCallback)sort_time, 0, 0 },
{"/_Sort Playlist/by L_ocation", NULL, (GtkItemFactoryCallback)sort_location, 0, 0 },
{"/_Sort Playlist/by _Filename", NULL, (GtkItemFactoryCallback)sort_filename, 0, 0 },
{"/_Sort Playlist/by _Comment", NULL, (GtkItemFactoryCallback)sort_comment, 0, 0},
{"/_Sort Playlist/_Randomly", NULL, (GtkItemFactoryCallback)sort_random, 0, 0 },
{"/_Help", NULL, 0, 0, "<Branch>" },
{"/_Help/_Zinf Web Site", NULL, (GtkItemFactoryCallback)zinf_web, 0, 0 },
{"/_Help/_About", NULL, (GtkItemFactoryCallback)show_about, 0, 0 }
};
int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
GtkAccelGroup *accel_group;
GtkWidget *separator;
accel_group = gtk_accel_group_new();
menuFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<blah>",
accel_group);
gtk_item_factory_create_items(menuFactory, nmenu_items, menu_items,
(void *)this);
gtk_accel_group_attach(accel_group, GTK_OBJECT(musicBrowser));
gtk_box_pack_start(GTK_BOX(topbox), gtk_item_factory_get_widget(
menuFactory, "<blah>"), FALSE, TRUE, 0);
gtk_widget_show(gtk_item_factory_get_widget(menuFactory, "<blah>"));
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(topbox), separator, FALSE, TRUE, 0);
gtk_widget_show(separator);
}
