static GtkWidget *create_dialog(void)
{
GtkWidget *dialog;
GtkWidget *header_image;
GtkWidget *header_label;
GtkWidget *label_info;
GtkWidget *codename_label;
GtkWidget *builddate_label;
GtkWidget *url_button;
GtkWidget *cop_label;
GtkWidget *label;
GtkWidget *license_textview;
GtkWidget *notebook;
GtkWidget *box;
GtkWidget *credits_scrollwin;
GtkWidget *table;
GtkWidget *license_scrollwin;
GtkWidget *info_box;
GtkWidget *header_hbox;
GtkWidget *header_eventbox;
GtkTextBuffer* tb;
gchar *license_text = NULL;
gchar buffer[512];
gchar buffer2[128];
guint i, row = 0;
gchar *build_date;
dialog = gtk_dialog_new();
/* configure dialog */
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany");
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);
/* create header */
header_eventbox = gtk_event_box_new();
gtk_widget_show(header_eventbox);
header_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
gtk_widget_show(header_hbox);
gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
header_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
/* print the subversion revision generated by ./configure if it is available */
g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
gtk_label_set_markup(GTK_LABEL(header_label), buffer);
gtk_widget_show(header_label);
gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
header_eventbox_style_set(header_eventbox);
header_label_style_set(header_label);
g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0);
/* create notebook */
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0);
/* create "Info" tab */
info_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
gtk_widget_show(info_box);
label_info = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
gtk_label_set_markup(GTK_LABEL(label_info), buffer);
gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);
/* Codename label */
codename_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
gtk_widget_show(codename_label);
gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);
/* build date label */
builddate_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
build_date = utils_parse_and_format_build_date(__DATE__);
g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date);
g_free(build_date);
g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
gtk_widget_show(builddate_label);
gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);
box = gtk_hbutton_box_new();
url_button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(url_button), label);
gtk_widget_show(url_button);
gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);
/* copyright label */
cop_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
gtk_widget_show(cop_label);
gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */
label = gtk_label_new(_("Info"));
gtk_widget_show(label);
gtk_widget_show_all(info_box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);
/* create "Credits" tab */
credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
row = 0;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < translators_len; i++)
{
ROW(translators[i][0], row, 0, 1, 4, 0);
ROW(translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < prev_translators_len; i++)
{
ROW(prev_translators[i][0], row, 0, 1, 4, 0);
ROW(prev_translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
g_snprintf(buffer, sizeof(buffer),
_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
"Thanks.txt"
#else
"THANKS"
#endif
);
label = geany_wrap_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
label = geany_wrap_label_new(contributors);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
gtk_widget_show_all(table);
label = gtk_label_new(_("Credits"));
gtk_widget_show(label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);
/* create "License" tab */
license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
license_textview = gtk_text_view_new();
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_widget_show(license_textview);
gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
label = gtk_label_new(_("License"));
gtk_widget_show(label);
g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);
g_file_get_contents(buffer, &license_text, NULL, NULL);
if (license_text == NULL)
{
license_text = g_strdup(
_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
}
tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
gtk_text_buffer_set_text(tb, license_text, -1);
g_free(license_text);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);
gtk_widget_show_all(dialog);
return dialog;
}
void
gui_editor_set_readonly (GUIEditor * self, gboolean val)
{
gtk_text_view_set_editable (GTK_TEXT_VIEW(self->widget), !val);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(self->widget), !val);
}
int main(int argc, char **argv) {
char line[MAX_MESSAGE_LEN+1];
if (argc < 5) {
printUsage();
}
host = argv[1];
sport = argv[2];
user = argv[3];
password = argv[4];
printf("\nStarting talk-client %s %s %s %s\n", host, sport, user, password);
int i;
for (i = 0; i < 100; i++) {
messages[i] = (char*) malloc(100*sizeof(char));
}
// Convert port to number
sscanf(sport, "%d", &port);
add_user();
create_room();
// Enter room
enter_room();
// Start message thread
startGetMessageThread();
//TODO
GtkWidget *window;
GtkWidget *table;
GtkWidget *title;
GtkWidget *title1;
GtkWidget *title2;
GtkWidget *title3;
GtkWidget *activate;
GtkWidget *halign;
GtkWidget *halign1;
GtkWidget *halign2;
GtkWidget *halign3;
GtkWidget *halign4;
GtkWidget *halign5;
GtkWidget *valign;
GtkWidget *close;
GtkWidget *wins;
GtkWidget *list;
GtkWidget *wins1;
GtkWidget *messages;
GtkWidget *type;
GtkWidget *send;
GtkWidget *createAccount;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request (window, 800, 700);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window), 15);
table = gtk_table_new(8, 8, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
gtk_table_set_row_spacings(GTK_TABLE(table), 10);
title = gtk_label_new("Rooms");
halign = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(halign), title);
gtk_table_attach(GTK_TABLE(table), halign, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
title1 = gtk_label_new("Users");
halign1 = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(halign1), title1);
gtk_table_attach(GTK_TABLE(table), halign1, 4, 5, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
//wins = gtk_text_view_new();
//gtk_text_view_set_editable(GTK_TEXT_VIEW(wins), TRUE);
//gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(wins), TRUE);
wins = create_list("Rooms");
gtk_table_attach(GTK_TABLE(table), wins, 0, 4, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
//wins1 = gtk_text_view_new();
//gtk_text_view_set_editable(GTK_TEXT_VIEW(wins1), TRUE);
//gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(wins1), TRUE);
wins1 = create_list("Users");
gtk_table_attach(GTK_TABLE(table), wins1, 4, 8, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
title2 = gtk_label_new("Messages");
halign4 = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(halign4), title2);
gtk_table_attach(GTK_TABLE(table), halign4, 0, 1, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
messages = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(messages), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(messages), FALSE);
gtk_table_attach(GTK_TABLE(table), messages, 0, 8, 3, 5, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
title3 = gtk_label_new("Type a message:");
halign5 = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(halign5), title3);
gtk_table_attach(GTK_TABLE(table), halign5, 0, 1, 5, 6, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
type = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(type), TRUE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(type), TRUE);
gtk_table_attach(GTK_TABLE(table), type, 0, 8, 6, 7, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 1, 1);
halign2 = gtk_alignment_new(0, 1, 0, 0);
send = gtk_button_new_with_label("Send");
g_signal_connect (send, "clicked", G_CALLBACK (send_message), NULL);
gtk_container_add(GTK_CONTAINER(halign2), send);
gtk_table_attach(GTK_TABLE(table), halign2, 0, 1, 7, 8, GTK_FILL, GTK_FILL, 0, 0);
createAccount = gtk_button_new_with_label("Create Account");
g_signal_connect (createAccount, "clicked", G_CALLBACK (add_user), NULL);
gtk_table_attach(GTK_TABLE(table), createAccount, 5, 8, 7, 8, GTK_FILL, GTK_FILL, 0, 0);
gtk_container_add(GTK_CONTAINER(window), table);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), G_OBJECT(window));
gtk_widget_show_all(window);
gtk_main();
//TODO
while (1) {
printPrompt();
//gtk_main();
//gtk_main_quit();
char * s = fgets(line,MAX_MESSAGE_LEN, stdin);
if (s==NULL) {
leave_room();
printf("talk-client exiting...\n");
exit(1);
}
if (!isatty(0)) {
// If it is not a terminal, echo command as well
printf("%s\n", line);
}
if (line[0]=='-') {
// This is a command process it
if (!strcmp(line,"-help")) {
printHelp();
}
else if (!strcmp(line,"-quit")) {
printf("talk-client exiting...\n");
exit(1);
}
// Put other commands here
}
else if (line[0]==0) {
// Empty line. Print help
printf("Type -help to print the available commands\n");
}
else {
// Send message
}
}
printf("TEST ENDS\n");
return 0;
}
/*
* 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");
}
static GtkWidget *create_window(void)
{
GtkWidget *startwin;
GtkWidget *hlayout;
GtkWidget *banner;
GtkWidget *vlayout;
GtkWidget *tabs;
GtkWidget *configvlayout;
GtkWidget *configlayout;
GtkWidget *fullscreencheck;
GtkWidget *vmode3dlabel;
GtkWidget *inputdevlabel;
GtkWidget *inputmousecheck;
GtkWidget *inputjoycheck;
GtkWidget *vmode3dcombo;
GtkWidget *alwaysshowcheck;
GtkWidget *configtab;
GtkWidget *gamevlayout;
GtkWidget *gamelabel;
GtkWidget *gamescroll;
GtkWidget *gamelist;
GtkWidget *gametab;
GtkWidget *messagesscroll;
GtkWidget *messagestext;
GtkWidget *messagestab;
GtkWidget *buttons;
GtkWidget *cancelbutton;
GtkWidget *cancelbuttonalign;
GtkWidget *cancelbuttonlayout;
GtkWidget *cancelbuttonicon;
GtkWidget *cancelbuttonlabel;
GtkWidget *startbutton;
GtkWidget *startbuttonalign;
GtkWidget *startbuttonlayout;
GtkWidget *startbuttonicon;
GtkWidget *startbuttonlabel;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
// Basic window
startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title
gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
hlayout = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hlayout);
gtk_container_add (GTK_CONTAINER (startwin), hlayout);
// Banner
{
GdkPixbuf *pixbuf = load_banner();
banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_widget_show (banner);
gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
vlayout = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vlayout);
gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0);
// Tab control
tabs = gtk_notebook_new ();
gtk_widget_show (tabs);
gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tabs), 4);
// Vertical layout of config page main body
configvlayout = gtk_vbox_new (FALSE, 0);
gtk_widget_show (configvlayout);
gtk_container_add (GTK_CONTAINER (tabs), configvlayout);
// Fixed-position layout of config page controls
configlayout = gtk_fixed_new ();
gtk_widget_show (configlayout);
gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6);
// Fullscreen checkbox
fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen");
gtk_widget_show (fullscreencheck);
gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0);
gtk_widget_set_size_request (fullscreencheck, 85, 29);
gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group,
GDK_F, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// 3D video mode label
vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:");
gtk_widget_show (vmode3dlabel);
gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0);
gtk_widget_set_size_request (vmode3dlabel, 88, 29);
gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5);
inputdevlabel = gtk_label_new ("Input devices:");
gtk_widget_show (inputdevlabel);
gtk_fixed_put (GTK_FIXED (configlayout), inputdevlabel, 0, 120);
gtk_widget_set_size_request (inputdevlabel, 88, 20);
gtk_misc_set_alignment (GTK_MISC (inputdevlabel), 0, 0.5);
inputmousecheck = gtk_check_button_new_with_mnemonic ("Mo_use");
gtk_widget_show (inputmousecheck);
gtk_fixed_put (GTK_FIXED (configlayout), inputmousecheck, 88, 120);
gtk_widget_set_size_request (inputmousecheck, 80, 20);
gtk_widget_add_accelerator (inputmousecheck, "grab_focus", accel_group,
GDK_U, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
inputjoycheck = gtk_check_button_new_with_mnemonic ("_Joystick");
gtk_widget_show (inputjoycheck);
gtk_fixed_put (GTK_FIXED (configlayout), inputjoycheck, 168, 120);
gtk_widget_set_size_request (inputjoycheck, 80, 20);
gtk_widget_add_accelerator (inputjoycheck, "grab_focus", accel_group,
GDK_J, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL);
}
gtk_widget_show (vmode3dcombo);
gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0);
gtk_widget_set_size_request (vmode3dcombo, 150, 29);
gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group,
GDK_V, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Always show config checkbox
alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start");
gtk_widget_show (alwaysshowcheck);
gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0);
gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group,
GDK_A, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Configuration tab
configtab = gtk_label_new ("Configuration");
gtk_widget_show (configtab);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab);
// Game data layout
gamevlayout = gtk_vbox_new (FALSE, 0);
gtk_widget_show (gamevlayout);
gtk_container_add (GTK_CONTAINER (tabs), gamevlayout);
gtk_container_set_border_width (GTK_CONTAINER (gamevlayout), 4);
// Game data field label
gamelabel = gtk_label_new_with_mnemonic ("_Game or addon:");
gtk_widget_show (gamelabel);
gtk_box_pack_start (GTK_BOX (gamevlayout), gamelabel, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (gamelabel), 0, 0.5);
// Game data scrollable area
gamescroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (gamescroll);
gtk_box_pack_start (GTK_BOX (gamevlayout), gamescroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (gamescroll), GTK_SHADOW_IN);
// Game data list
{
GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);
gamelist = gtk_tree_view_new_with_model (GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col);
col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
gtk_tree_view_column_set_min_width(col, 64);
gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col);
}
gtk_widget_show (gamelist);
gtk_container_add (GTK_CONTAINER (gamescroll), gamelist);
gtk_widget_add_accelerator (gamelist, "grab_focus", accel_group,
GDK_G, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gamelist), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (gamelist), FALSE);
// Game tab
gametab = gtk_label_new ("Game");
gtk_widget_show (gametab);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), gametab);
// Messages scrollable area
messagesscroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (messagesscroll);
gtk_container_add (GTK_CONTAINER (tabs), messagesscroll);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
messagestext = gtk_text_view_new ();
gtk_widget_show (messagestext);
gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext);
gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2);
// Messages tab
messagestab = gtk_label_new ("Messages");
gtk_widget_show (messagestab);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 2), messagestab);
// Dialogue box buttons layout
buttons = gtk_hbutton_box_new ();
gtk_widget_show (buttons);
gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (buttons), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END);
// Cancel button
cancelbutton = gtk_button_new ();
gtk_widget_show (cancelbutton);
gtk_container_add (GTK_CONTAINER (buttons), cancelbutton);
GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group,
GDK_C, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group,
GDK_Escape, 0,
GTK_ACCEL_VISIBLE);
cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (cancelbuttonalign);
gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign);
cancelbuttonlayout = gtk_hbox_new (FALSE, 2);
gtk_widget_show (cancelbuttonlayout);
gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout);
cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (cancelbuttonicon);
gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0);
cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel");
gtk_widget_show (cancelbuttonlabel);
gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
startbutton = gtk_button_new ();
gtk_widget_show (startbutton);
gtk_container_add (GTK_CONTAINER (buttons), startbutton);
GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group,
GDK_S, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (startbutton, "clicked", accel_group,
GDK_Return, 0,
GTK_ACCEL_VISIBLE);
startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (startbuttonalign);
gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign);
startbuttonlayout = gtk_hbox_new (FALSE, 2);
gtk_widget_show (startbuttonlayout);
gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout);
startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (startbuttonicon);
gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0);
startbuttonlabel = gtk_label_new_with_mnemonic ("_Start");
gtk_widget_show (startbuttonlabel);
gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect ((gpointer) startwin, "delete_event",
G_CALLBACK (on_startwin_delete_event),
NULL);
g_signal_connect ((gpointer) fullscreencheck, "toggled",
G_CALLBACK (on_fullscreencheck_toggled),
NULL);
g_signal_connect ((gpointer) inputmousecheck, "toggled",
G_CALLBACK (on_inputmousecheck_toggled),
NULL);
g_signal_connect ((gpointer) inputjoycheck, "toggled",
G_CALLBACK (on_inputjoycheck_toggled),
NULL);
g_signal_connect ((gpointer) vmode3dcombo, "changed",
G_CALLBACK (on_vmode3dcombo_changed),
NULL);
g_signal_connect ((gpointer) alwaysshowcheck, "toggled",
G_CALLBACK (on_alwaysshowcheck_toggled),
NULL);
g_signal_connect ((gpointer) cancelbutton, "clicked",
G_CALLBACK (on_cancelbutton_clicked),
NULL);
g_signal_connect ((gpointer) startbutton, "clicked",
G_CALLBACK (on_startbutton_clicked),
NULL);
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gamelist));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
g_signal_connect ((gpointer) sel, "changed",
G_CALLBACK (on_gamelist_selection_changed),
NULL);
}
// Associate labels with their controls
gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo);
gtk_label_set_mnemonic_widget (GTK_LABEL (gamelabel), gamelist);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin");
GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout");
GLADE_HOOKUP_OBJECT (startwin, banner, "banner");
GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout");
GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs");
GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout");
GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout");
GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck");
GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel");
GLADE_HOOKUP_OBJECT (startwin, inputdevlabel, "inputdevlabel");
GLADE_HOOKUP_OBJECT (startwin, inputmousecheck, "inputmousecheck");
GLADE_HOOKUP_OBJECT (startwin, inputjoycheck, "inputjoycheck");
GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo");
GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck");
GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab");
GLADE_HOOKUP_OBJECT (startwin, gamevlayout, "gamevlayout");
GLADE_HOOKUP_OBJECT (startwin, gamelabel, "gamelabel");
GLADE_HOOKUP_OBJECT (startwin, gamescroll, "gamescroll");
GLADE_HOOKUP_OBJECT (startwin, gamelist, "gamelist");
GLADE_HOOKUP_OBJECT (startwin, gametab, "gametab");
GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll");
GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext");
GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab");
GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons");
GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel");
GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton");
GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign");
GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout");
GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon");
GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel");
gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group);
return startwin;
}
GtkWidget*
create_windowMain ()
{
GtkWidget *vbox1;
GtkWidget *hpaned1;
GtkWidget *scrolledwindow1;
GtkWidget *hbuttonbox1;
GtkWidget *buttonRefresh;
GtkWidget *buttonConfigure;
GtkWidget *buttonClose;
GtkWidget *buttonAbout;
GdkPixbuf *icon;
GtkCellRenderer *treeRenderer;
GtkTreeViewColumn *treeColumn;
windowMain = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (windowMain, "windowMain");
gtk_window_set_title (GTK_WINDOW (windowMain), "USB Viewer");
gtk_window_set_default_size (GTK_WINDOW (windowMain), 600, 300);
icon = gdk_pixbuf_new_from_xpm_data((const char **)usbview_icon);
gtk_window_set_icon(GTK_WINDOW(windowMain), icon);
vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_name (vbox1, "vbox1");
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (windowMain), vbox1);
hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_name (hpaned1, "hpaned1");
gtk_widget_show (hpaned1);
gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
treeStore = gtk_tree_store_new (N_COLUMNS,
G_TYPE_STRING, /* NAME_COLUMN */
G_TYPE_INT, /* DEVICE_ADDR_COLUMN */
G_TYPE_STRING /* COLOR_COLUMN */);
treeUSB = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treeStore));
treeRenderer = gtk_cell_renderer_text_new ();
treeColumn = gtk_tree_view_column_new_with_attributes (
"USB devices",
treeRenderer,
"text", NAME_COLUMN,
"foreground", COLOR_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeUSB), treeColumn);
gtk_widget_set_name (treeUSB, "treeUSB");
gtk_widget_show (treeUSB);
gtk_paned_pack1 (GTK_PANED (hpaned1), treeUSB, FALSE, FALSE);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow1, "scrolledwindow1");
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_show (scrolledwindow1);
gtk_paned_pack2 (GTK_PANED (hpaned1), scrolledwindow1, TRUE, FALSE);
textDescriptionBuffer = gtk_text_buffer_new(NULL);
//textDescription = gtk_text_new (NULL, NULL);
textDescriptionView = gtk_text_view_new_with_buffer(textDescriptionBuffer);
gtk_widget_set_name (textDescriptionView, "textDescription");
gtk_text_view_set_editable(GTK_TEXT_VIEW(textDescriptionView), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textDescriptionView), FALSE);
gtk_widget_show (textDescriptionView);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), textDescriptionView);
hbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_name (hbuttonbox1, "hbuttonbox1");
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 5);
//gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
//gtk_button_box_set_child_size (GTK_BUTTON_BOX (hbuttonbox1), 50, 25);
//gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (hbuttonbox1), 25, 10);
buttonRefresh = gtk_button_new_with_label("Refresh");
gtk_widget_set_name (buttonRefresh, "buttonRefresh");
gtk_widget_show (buttonRefresh);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonRefresh);
gtk_container_set_border_width (GTK_CONTAINER (buttonRefresh), 4);
gtk_widget_set_can_default (buttonRefresh, TRUE);
buttonConfigure = gtk_button_new_with_label ("Configure...");
gtk_widget_set_name (buttonConfigure, "buttonConfigure");
gtk_widget_show (buttonConfigure);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonConfigure);
gtk_container_set_border_width (GTK_CONTAINER (buttonConfigure), 4);
gtk_widget_set_can_default (buttonConfigure, TRUE);
buttonAbout = gtk_button_new_with_label("About");
gtk_widget_set_name (buttonAbout, "buttonAbout");
gtk_widget_show (buttonAbout);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonAbout);
gtk_container_set_border_width (GTK_CONTAINER (buttonAbout), 4);
gtk_widget_set_can_default (buttonAbout, TRUE);
buttonClose = gtk_button_new_with_label("Quit");
gtk_widget_set_name (buttonClose, "buttonClose");
gtk_widget_show (buttonClose);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonClose);
gtk_container_set_border_width (GTK_CONTAINER (buttonClose), 4);
gtk_widget_set_can_default (buttonClose, TRUE);
g_signal_connect (G_OBJECT (windowMain), "delete_event",
G_CALLBACK (on_window1_delete_event),
NULL);
g_signal_connect (G_OBJECT (buttonRefresh), "clicked",
G_CALLBACK (on_buttonRefresh_clicked),
NULL);
g_signal_connect (G_OBJECT (buttonConfigure), "clicked",
G_CALLBACK (on_buttonConfigure_clicked),
NULL);
g_signal_connect (G_OBJECT (buttonAbout), "clicked",
G_CALLBACK (on_buttonAbout_clicked),
NULL);
g_signal_connect (G_OBJECT (buttonClose), "clicked",
G_CALLBACK (on_buttonClose_clicked),
NULL);
/* create our timer */
//timer = gtk_timeout_add (2000, on_timer_timeout, 0);
return windowMain;
}
static void
display_fortune_dialog (FishApplet *fish)
{
GError *error = NULL;
gboolean user_command;
int output;
const char *charset;
int argc;
char **argv;
GdkScreen *screen;
char *display;
/* if there is still a pipe, close it */
if (fish->source_id)
g_source_remove (fish->source_id);
fish->source_id = 0;
fish_close_channel (fish);
user_command = locate_fortune_command (fish, &argc, &argv);
if (!argv)
return;
if (!fish->fortune_dialog) {
GtkWidget *scrolled;
GtkWidget *vbox;
GdkScreen *screen;
int screen_width;
int screen_height;
fish->fortune_dialog =
gtk_dialog_new_with_buttons (
"", NULL, 0,
_("_Speak again"), FISH_RESPONSE_SPEAK,
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (fish->fortune_dialog),
FISH_ICON);
gtk_dialog_set_default_response (
GTK_DIALOG (fish->fortune_dialog), GTK_RESPONSE_CLOSE);
g_signal_connect (fish->fortune_dialog, "delete_event",
G_CALLBACK (delete_event), fish);
g_signal_connect (fish->fortune_dialog, "response",
G_CALLBACK (handle_fortune_response), fish);
gtk_window_set_wmclass (GTK_WINDOW (fish->fortune_dialog), "fish", "Fish");
screen = gtk_widget_get_screen (GTK_WIDGET (fish));
screen_width = gdk_screen_get_width (screen);
screen_height = gdk_screen_get_height (screen);
gtk_window_set_default_size (GTK_WINDOW (fish->fortune_dialog),
MIN (600, screen_width * 0.9),
MIN (350, screen_height * 0.9));
fish->fortune_view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (fish->fortune_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (fish->fortune_view), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (fish->fortune_view), 10);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (fish->fortune_view), 10);
fish->fortune_buffer =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (fish->fortune_view));
gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (fish->fortune_buffer),
"monospace_tag", "family",
"Monospace", NULL);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (scrolled), fish->fortune_view);
fish->fortune_label = gtk_label_new ("");
gtk_label_set_ellipsize (GTK_LABEL (fish->fortune_label),
PANGO_ELLIPSIZE_MIDDLE);
fish->fortune_cmd_label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (fish->fortune_cmd_label),
0, 0.5);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (fish->fortune_dialog));
gtk_box_pack_start (GTK_BOX (vbox),
fish->fortune_label,
FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox),
scrolled,
TRUE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (vbox),
fish->fortune_cmd_label,
FALSE, FALSE, 6);
update_fortune_dialog (fish);
/* We don't show_all for the dialog since fortune_cmd_label
* might need to be hidden
* The dialog will be shown with gtk_window_present later */
gtk_widget_show (scrolled);
gtk_widget_show (fish->fortune_view);
gtk_widget_show (fish->fortune_label);
}
if (!user_command) {
char *command;
char * text;
command = g_markup_printf_escaped ("<tt>%s</tt>", argv[0]);
text = g_strdup_printf (_("The configured command is not "
"working and has been replaced by: "
"%s"), command);
gtk_label_set_markup (GTK_LABEL (fish->fortune_cmd_label),
text);
g_free (command);
g_free (text);
gtk_widget_show (fish->fortune_cmd_label);
} else {
gtk_widget_hide (fish->fortune_cmd_label);
}
clear_fortune_text (fish);
screen = gtk_widget_get_screen (GTK_WIDGET (fish));
display = gdk_screen_make_display_name (screen);
g_spawn_async_with_pipes (NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH|G_SPAWN_STDERR_TO_DEV_NULL,
set_environment,
&display,
NULL, /* child pid */
NULL, /* stdin */
&output,
NULL, /* stderr */
&error);
g_free (display);
if (error) {
char *message;
message = g_strdup_printf (_("Unable to execute '%s'\n\nDetails: %s"),
argv[0], error->message);
something_fishy_going_on (fish, message);
g_free (message);
g_error_free (error);
g_strfreev (argv);
return;
}
fish->io_channel = g_io_channel_unix_new (output);
/* set the correct encoding if the locale is not using UTF-8 */
if (!g_get_charset (&charset))
g_io_channel_set_encoding(fish->io_channel, charset, &error);
if (error) {
char *message;
message = g_strdup_printf (_("Unable to read from '%s'\n\nDetails: %s"),
argv[0], error->message);
something_fishy_going_on (fish, message);
g_free (message);
g_error_free (error);
g_strfreev (argv);
return;
}
g_strfreev (argv);
fish->source_id = g_io_add_watch (fish->io_channel,
G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL,
fish_read_output, fish);
gtk_window_set_screen (GTK_WINDOW (fish->fortune_dialog),
gtk_widget_get_screen (GTK_WIDGET (fish)));
gtk_window_present (GTK_WINDOW (fish->fortune_dialog));
}
//================================================================
MemObj GUI_msgwin__ (MemObj *o_par, char *opts) {
//================================================================
/// \code
/// create textwindow
/// o_par parentBox
/// opts options; (HorSiz,VertSiz)
/// HorSiz,VertSiz: size in characters; default is automatic size.
/// 'e' = expand widget; default is fixed size.
/// negative values: size in pixels.
/// Examples: "" or "10" or "10e,e"
/// "10e,e" horiz. size 10 chars, hor. and vert. expandable.
/// \endcode
// Create ein Editfenster
int pTyp;
void *w_par;
Obj_Unknown *go;
GtkWidget *sw;
GtkTextBuffer *TxBuf;
GtkWidget *TxView;
printf("GUI_msgwin__ |%s|\n",opts);
// get gtk-widget for parentBox from MemObj
w_par = GUI_obj_parent__ (&pTyp, o_par);
if(!w_par) return (UME_obj_invalid_set (-3));
// get address & memspc
GUI_obj_spc ((void**)&go, sizeof(Obj_Unknown));
if(!go) return (UME_obj_invalid_set (-1));
//----------------------------------------------------------------
TxView = gtk_text_view_new ();
TxBuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (TxView));
gtk_text_buffer_set_text (TxBuf, "", -1);
//----------------------------------------------------------------
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (sw), TxView);
gtk_widget_show (TxView);
gtk_text_view_set_editable ((GtkTextView *)TxView, FALSE);
gtk_text_view_set_cursor_visible ((GtkTextView *)TxView, FALSE);
/*
// hsiz,vsiz size of window; >0=size in characters, <0=size in pixels
// size
if(hsiz != 0) {
if(hsiz < 0) {
ih = -hsiz;
} else {
ih = UI_fontsizX * hsiz;
}
}
if(vsiz != 0) {
if(vsiz < 0) {
iv = -vsiz;
} else {
iv = UI_fontsizY * (vsiz + 1);
}
}
if((ih) || (iv)) {
// printf(" winSiz %d %d\n",ih,iv);
GUI_siz_set (sw, ih, iv);
}
*/
GUI_w_pack2 (pTyp, w_par, sw, opts);
// gtk_container_add (GTK_CONTAINER (w_par), sw);
// gtk_widget_show (sw);
go->gio_typ = TYP_GUI_MsgWin;
go->widget = TxView;
// printf("exit GUI_msgwin__ \n");
return (((Obj_Unknown*)go)->mem_obj);
}
FileViewer* file_viewer_construct (GType object_type, const gchar* filename) {
FileViewer * self = NULL;
const gchar* _tmp0_ = NULL;
gchar* _tmp1_ = NULL;
gchar* _tmp2_ = NULL;
GtkTextView* _tmp8_ = NULL;
GtkTextView* _tmp9_ = NULL;
GtkTextView* _tmp10_ = NULL;
GtkTextView* _tmp11_ = NULL;
GtkTextView* _tmp12_ = NULL;
GtkScrolledWindow* scroll = NULL;
GtkScrolledWindow* _tmp13_ = NULL;
GtkTextView* _tmp14_ = NULL;
GtkButton* btn_close = NULL;
GtkButton* _tmp15_ = NULL;
GtkBox* vbox = NULL;
GtkBox* _tmp16_ = NULL;
const gchar* _tmp17_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (filename != NULL, NULL);
self = (FileViewer*) g_object_new (object_type, NULL);
_tmp0_ = filename;
_tmp1_ = g_strconcat ("Content of ", _tmp0_, NULL);
_tmp2_ = _tmp1_;
gtk_window_set_title ((GtkWindow*) self, _tmp2_);
_g_free0 (_tmp2_);
g_object_set ((GtkWindow*) self, "window-position", GTK_WIN_POS_CENTER, NULL);
gtk_window_set_default_size ((GtkWindow*) self, 600, 400);
{
GdkPixbuf* _tmp3_ = NULL;
GdkPixbuf* _tmp4_ = NULL;
_tmp4_ = gdk_pixbuf_new_from_file ("tar.ico", &_inner_error_);
_tmp3_ = _tmp4_;
if (G_UNLIKELY (_inner_error_ != NULL)) {
goto __catch6_g_error;
}
gtk_window_set_icon ((GtkWindow*) self, _tmp3_);
_g_object_unref0 (_tmp3_);
}
goto __finally6;
__catch6_g_error:
{
GError* e = NULL;
FILE* _tmp5_ = NULL;
GError* _tmp6_ = NULL;
const gchar* _tmp7_ = NULL;
e = _inner_error_;
_inner_error_ = NULL;
_tmp5_ = stderr;
_tmp6_ = e;
_tmp7_ = _tmp6_->message;
fprintf (_tmp5_, "Could not load application icon: %s\n", _tmp7_);
_g_error_free0 (e);
}
__finally6:
if (G_UNLIKELY (_inner_error_ != NULL)) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
_tmp8_ = (GtkTextView*) gtk_text_view_new ();
g_object_ref_sink (_tmp8_);
_g_object_unref0 (self->priv->text_view);
self->priv->text_view = _tmp8_;
_tmp9_ = self->priv->text_view;
gtk_text_view_set_editable (_tmp9_, FALSE);
_tmp10_ = self->priv->text_view;
gtk_text_view_set_cursor_visible (_tmp10_, FALSE);
_tmp11_ = self->priv->text_view;
gtk_widget_set_margin_left ((GtkWidget*) _tmp11_, 8);
_tmp12_ = self->priv->text_view;
gtk_widget_set_margin_right ((GtkWidget*) _tmp12_, 8);
_tmp13_ = (GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL);
g_object_ref_sink (_tmp13_);
scroll = _tmp13_;
gtk_scrolled_window_set_policy (scroll, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
_tmp14_ = self->priv->text_view;
gtk_container_add ((GtkContainer*) scroll, (GtkWidget*) _tmp14_);
_tmp15_ = (GtkButton*) gtk_button_new_with_label ("Close");
g_object_ref_sink (_tmp15_);
btn_close = _tmp15_;
g_signal_connect_object (btn_close, "clicked", (GCallback) _gtk_window_close_gtk_button_clicked, (GtkWindow*) self, 0);
_tmp16_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_ref_sink (_tmp16_);
vbox = _tmp16_;
gtk_box_pack_start (vbox, (GtkWidget*) scroll, TRUE, TRUE, (guint) 0);
gtk_box_pack_start (vbox, (GtkWidget*) btn_close, FALSE, FALSE, (guint) 0);
gtk_container_add ((GtkContainer*) self, (GtkWidget*) vbox);
_tmp17_ = filename;
file_viewer_open_file (self, _tmp17_);
_g_object_unref0 (vbox);
_g_object_unref0 (btn_close);
_g_object_unref0 (scroll);
return self;
}
//===============================================================================
MemObj GUI_edi__ (MemObj *o_par, void *funcnam, int mode, char *opts) {
//===============================================================================
/// \code
/// o_par parentBox
/// funcnam callback-function for Keypress & FocusIn-Events (none: NULL)
/// mode 0 = do not wrap lines; 1=yes, wrap lines
/// opts options; (HorSiz,VertSiz)
/// HorSiz,VertSiz: size in characters; default is automatic size.
/// negative values: size in pixels.
/// 'e' = expand widget; default is fixed size.
/// Examples: "" or "10" or "10e,e"
/// "10e,e" horiz. size 10 chars, hor. and vert. expandable.
///
/// prototyp funcnam:
/// int funcnam (MemObj *mo, void **data);
/// // data=table of 3 pointers;
/// GUI_DATA_EVENT =*(int*)data[0]=TYP_EventEnter
/// GUI_DATA_L1 =*(long*)data[1]=act.cursorPosition
/// GUI_DATA_L2 =*(long*)data[2]=act.lineNr.
///
/// GUI_DATA_EVENT =*(int*)data[0]=TYP_EventPress|TYP_EventRelease
/// GUI_DATA_I1 =*(int*)data[1]=keyvalue; eg 'a'
/// GUI_DATA_I2 =*(int*)data[2]=state of modifierkeys;
/// &1=shift; &4=ctrl; &8=alt.
/// GUI_OBJ_TYP(mo) = TYP_GUI_Editor
///
/// Example without callback-function:
/// ed1 = GUI_edi__ (&box1, NULL, "");
///
///
/// Example with callback-function:
/// ed2 = GUI_edi__ (&box1, ed1_cb, "50,40");
/// ..
/// int ed1_cb (MemObj *mo, void **data) {
/// printf(" event=%d typ=%d\n",GUI_DATA_EVENT,GUI_OBJ_TYP(mo));
/// printf(" key=%d modi=%d\n",GUI_DATA_I1,GUI_DATA_I2);
/// }
///
/// \endcode
int i1, pTyp;
void *w_par, *wb;
GtkWidget *wev, *wsw;
GtkTextBuffer *web;
Obj_gui1 *go;
// printf("GUI_edi__ |%s|\n",opts);
i1 = g_get_charset ((const char **)&GUI_ed1_lcSet); // i1=TRUE if lcSet==UTF8.
// printf(" charSet %d |%s|\n",i1,GUI_ed1_lcSet);
if(i1 != 0) GUI_ed1_lcSet = NULL;
// get gtk-widget for parentBox from MemObj
w_par = GUI_obj_parent__ (&pTyp, o_par);
if(!w_par) return (UME_obj_invalid_set (-3));
// get address & memspc
GUI_obj_spc ((void**)&go, sizeof(Obj_gui1));
if(!go) return (UME_obj_invalid_set (-1));
wev = gtk_text_view_new ();
web = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wev));
gtk_widget_set_can_focus(wev, TRUE);
wsw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (wsw),
GTK_POLICY_AUTOMATIC, // hor GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC); // vert
// gtk_widget_set_can_focus(wsw, TRUE);
// wrap: GTK_WRAP_NONE GTK_WRAP_CHAR GTK_WRAP_WORD
if(mode == 1)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (wev), GTK_WRAP_CHAR);
else
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (wev), GTK_WRAP_NONE);
gtk_text_view_set_editable ((GtkTextView*)wev, TRUE);
gtk_text_view_set_cursor_visible ((GtkTextView*)wev, TRUE);
//----------------------------------------------------------------
if (funcnam) {
gtk_widget_set_events (GTK_WIDGET(wsw),
// GDK_FOCUS_CHANGE_MASK|
// GDK_ENTER_NOTIFY_MASK |
// GDK_BUTTON_PRESS_MASK|
GDK_BUTTON_RELEASE_MASK);
//----------------------------------------------------------------
// attach "enter-window" (for eg click into window).
// geht nicht: wsw|web|wev"enter-notify-event";
// web"mark-set" zu oft;
g_signal_connect (G_OBJECT (web), "mark-set",
G_CALLBACK (GUI_ed1_cb2),
PTR_MEMOBJ(go->mem_obj));
// button-press: reports the old cursor-position; useless ..
// g_signal_connect (G_OBJECT (wev), "button-press-event",
// G_CALLBACK (GUI_ed1_cb1),
// PTR_MEMOBJ(go->mem_obj));
// cannot use focus-in-event; does not report click into window !
// g_signal_connect (G_OBJECT (wev), "focus-in-event",
// G_CALLBACK (GUI_ed1_cb1),
// PTR_MEMOBJ(go->mem_obj));
//----------------------------------------------------------------
g_signal_connect (G_OBJECT (web), // wev wsw
"paste-done",
G_CALLBACK (GUI_ed1_cb3),
PTR_MEMOBJ(go->mem_obj));
g_signal_connect (G_OBJECT (wsw),
"key-press-event",
G_CALLBACK (GUI_ed1_cb1),
PTR_MEMOBJ(go->mem_obj));
// focus-in-event erforderlich f CAD-select-objects
g_signal_connect (G_OBJECT (wsw),
"key-release-event",
G_CALLBACK (GUI_ed1_cb1),
PTR_MEMOBJ(go->mem_obj));
}
gtk_widget_set_hexpand (wev, TRUE); // else no resize !!
gtk_widget_set_vexpand (wev, TRUE); // else no resize !!
//----------------------------------------------------------------
gtk_container_add (GTK_CONTAINER (wsw), wev);
gtk_widget_show (wev);
// GUI_packwn (w_par, wsw, hsiz, vsiz);
GUI_w_pack1 (pTyp, w_par, wsw, opts);
//----------------------------------------------------------------
// fill obj
go->gio_typ = TYP_GUI_Editor;
go->widget = wev; //wsw;
go->uFunc = funcnam;
GUI_ed1_view = NULL; // makes error after recalling this edi ! 2014-01-17
// return memObj
return (go->mem_obj);
}
GtkWidget*
create_lshw (void)
{
GtkWidget *lshw;
GtkWidget *vbox1;
GtkWidget *menu;
GtkWidget *menuitem4;
GtkWidget *menuitem4_menu;
GtkWidget *save;
GtkWidget *quit1;
GtkWidget *menuitem6;
GtkWidget *menuitem6_menu;
GtkWidget *refresh1;
GtkWidget *menuitem7;
GtkWidget *menuitem7_menu;
GtkWidget *about1;
GtkWidget *toolbar1;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *upbutton;
GtkWidget *refreshbutton;
GtkWidget *savebutton;
GtkWidget *quitbutton;
GtkWidget *scrolledwindow1;
GtkWidget *viewport2;
GtkWidget *hbox1;
GtkWidget *hpaned1;
GtkWidget *hbox3;
GtkWidget *scrolledwindow10;
GtkWidget *treeview1;
GtkWidget *scrolledwindow11;
GtkWidget *treeview2;
GtkWidget *scrolledwindow12;
GtkWidget *treeview3;
GtkWidget *vbox2;
GtkWidget *scrolledwindow13;
GtkWidget *viewport3;
GtkWidget *scrolledwindow14;
GtkWidget *description;
GtkWidget *statusbar;
GtkAccelGroup *accel_group;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
lshw = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (lshw), "lshw");
gtk_window_set_default_size (GTK_WINDOW (lshw), 700, 480);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (lshw), vbox1);
menu = gtk_menu_bar_new ();
gtk_widget_show (menu);
gtk_box_pack_start (GTK_BOX (vbox1), menu, FALSE, FALSE, 0);
menuitem4 = gtk_menu_item_new_with_mnemonic ("_File");
gtk_widget_show (menuitem4);
gtk_container_add (GTK_CONTAINER (menu), menuitem4);
menuitem4_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu);
save = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group);
gtk_widget_show (save);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), save);
gtk_widget_set_sensitive (save, FALSE);
quit1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_widget_show (quit1);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), quit1);
menuitem6 = gtk_menu_item_new_with_mnemonic ("_View");
gtk_widget_show (menuitem6);
gtk_container_add (GTK_CONTAINER (menu), menuitem6);
menuitem6_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem6), menuitem6_menu);
refresh1 = gtk_image_menu_item_new_from_stock ("gtk-refresh", accel_group);
gtk_widget_show (refresh1);
gtk_container_add (GTK_CONTAINER (menuitem6_menu), refresh1);
gtk_widget_add_accelerator (refresh1, "activate", accel_group,
GDK_F5, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
menuitem7 = gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (menuitem7);
gtk_container_add (GTK_CONTAINER (menu), menuitem7);
menuitem7_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem7), menuitem7_menu);
about1 = gtk_menu_item_new_with_mnemonic ("_About");
gtk_widget_show (about1);
gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1);
toolbar1 = gtk_toolbar_new ();
gtk_widget_show (toolbar1);
gtk_box_pack_start (GTK_BOX (vbox1), toolbar1, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH);
tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1));
upbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-up");
gtk_widget_show (upbutton);
gtk_container_add (GTK_CONTAINER (toolbar1), upbutton);
gtk_widget_set_sensitive (upbutton, FALSE);
refreshbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-refresh");
gtk_widget_show (refreshbutton);
gtk_container_add (GTK_CONTAINER (toolbar1), refreshbutton);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (refreshbutton), tooltips, "Rescan the hardware", NULL);
savebutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save");
gtk_widget_show (savebutton);
gtk_container_add (GTK_CONTAINER (toolbar1), savebutton);
gtk_widget_set_sensitive (savebutton, FALSE);
quitbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-quit");
gtk_widget_show (quitbutton);
gtk_container_add (GTK_CONTAINER (toolbar1), quitbutton);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport2);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport2);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (viewport2), hbox1);
hpaned1 = gtk_hpaned_new ();
gtk_widget_show (hpaned1);
gtk_box_pack_start (GTK_BOX (hbox1), hpaned1, TRUE, TRUE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_paned_pack1 (GTK_PANED (hpaned1), hbox3, FALSE, TRUE);
scrolledwindow10 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow10);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow10, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow10), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_SHADOW_ETCHED_IN);
treeview1 = gtk_tree_view_new ();
gtk_widget_show (treeview1);
gtk_container_add (GTK_CONTAINER (scrolledwindow10), treeview1);
gtk_widget_set_size_request (treeview1, 128, -1);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE);
scrolledwindow11 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow11);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow11, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow11), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_SHADOW_ETCHED_IN);
treeview2 = gtk_tree_view_new ();
gtk_widget_show (treeview2);
gtk_container_add (GTK_CONTAINER (scrolledwindow11), treeview2);
gtk_widget_set_size_request (treeview2, 128, -1);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE);
scrolledwindow12 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow12);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow12, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow12), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_SHADOW_ETCHED_IN);
treeview3 = gtk_tree_view_new ();
gtk_widget_show (treeview3);
gtk_container_add (GTK_CONTAINER (scrolledwindow12), treeview3);
gtk_widget_set_size_request (treeview3, 128, -1);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview3), FALSE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, TRUE);
scrolledwindow13 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow13);
gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow13, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow13), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport3 = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport3);
gtk_container_add (GTK_CONTAINER (scrolledwindow13), viewport3);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport3), GTK_SHADOW_NONE);
scrolledwindow14 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow14);
gtk_container_add (GTK_CONTAINER (viewport3), scrolledwindow14);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow14), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow14), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow14), GTK_SHADOW_ETCHED_IN);
description = gtk_text_view_new ();
gtk_widget_show (description);
gtk_container_add (GTK_CONTAINER (scrolledwindow14), description);
GTK_WIDGET_UNSET_FLAGS (description, GTK_CAN_FOCUS);
gtk_tooltips_set_tip (tooltips, description, "This pane displays detailed information about the selected hardware node", NULL);
gtk_text_view_set_editable (GTK_TEXT_VIEW (description), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (description), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (description), 10);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (description), 10);
gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (description)), "no information available.\n\nclick on Refresh to query hardware", -1);
statusbar = gtk_statusbar_new ();
gtk_widget_show (statusbar);
gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0);
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), FALSE);
g_signal_connect ((gpointer) lshw, "delete_event",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_after ((gpointer) lshw, "map",
G_CALLBACK (on_lshw_map),
NULL);
g_signal_connect ((gpointer) save, "activate",
G_CALLBACK (on_save_activate),
NULL);
g_signal_connect ((gpointer) quit1, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) refresh1, "activate",
G_CALLBACK (refresh_display),
NULL);
g_signal_connect ((gpointer) about1, "activate",
G_CALLBACK (on_about1_activate),
NULL);
g_signal_connect ((gpointer) upbutton, "clicked",
G_CALLBACK (go_up),
NULL);
g_signal_connect ((gpointer) refreshbutton, "clicked",
G_CALLBACK (refresh_display),
NULL);
g_signal_connect ((gpointer) savebutton, "clicked",
G_CALLBACK (on_savebutton_clicked),
NULL);
g_signal_connect ((gpointer) quitbutton, "clicked",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) treeview1, "row_activated",
G_CALLBACK (on_treeview1_row_activated),
NULL);
g_signal_connect ((gpointer) treeview1, "cursor_changed",
G_CALLBACK (on_treeview1_cursor_changed),
NULL);
g_signal_connect ((gpointer) treeview2, "row_activated",
G_CALLBACK (on_treeview2_row_activated),
NULL);
g_signal_connect ((gpointer) treeview2, "cursor_changed",
G_CALLBACK (on_treeview2_cursor_changed),
NULL);
g_signal_connect ((gpointer) treeview3, "row_activated",
G_CALLBACK (on_treeview3_row_activated),
NULL);
g_signal_connect ((gpointer) treeview3, "cursor_changed",
G_CALLBACK (on_treeview3_cursor_changed),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (lshw, lshw, "lshw");
GLADE_HOOKUP_OBJECT (lshw, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (lshw, menu, "menu");
GLADE_HOOKUP_OBJECT (lshw, menuitem4, "menuitem4");
GLADE_HOOKUP_OBJECT (lshw, menuitem4_menu, "menuitem4_menu");
GLADE_HOOKUP_OBJECT (lshw, save, "save");
GLADE_HOOKUP_OBJECT (lshw, quit1, "quit1");
GLADE_HOOKUP_OBJECT (lshw, menuitem6, "menuitem6");
GLADE_HOOKUP_OBJECT (lshw, menuitem6_menu, "menuitem6_menu");
GLADE_HOOKUP_OBJECT (lshw, refresh1, "refresh1");
GLADE_HOOKUP_OBJECT (lshw, menuitem7, "menuitem7");
GLADE_HOOKUP_OBJECT (lshw, menuitem7_menu, "menuitem7_menu");
GLADE_HOOKUP_OBJECT (lshw, about1, "about1");
GLADE_HOOKUP_OBJECT (lshw, toolbar1, "toolbar1");
GLADE_HOOKUP_OBJECT (lshw, upbutton, "upbutton");
GLADE_HOOKUP_OBJECT (lshw, refreshbutton, "refreshbutton");
GLADE_HOOKUP_OBJECT (lshw, savebutton, "savebutton");
GLADE_HOOKUP_OBJECT (lshw, quitbutton, "quitbutton");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow1, "scrolledwindow1");
GLADE_HOOKUP_OBJECT (lshw, viewport2, "viewport2");
GLADE_HOOKUP_OBJECT (lshw, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (lshw, hpaned1, "hpaned1");
GLADE_HOOKUP_OBJECT (lshw, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow10, "scrolledwindow10");
GLADE_HOOKUP_OBJECT (lshw, treeview1, "treeview1");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow11, "scrolledwindow11");
GLADE_HOOKUP_OBJECT (lshw, treeview2, "treeview2");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow12, "scrolledwindow12");
GLADE_HOOKUP_OBJECT (lshw, treeview3, "treeview3");
GLADE_HOOKUP_OBJECT (lshw, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow13, "scrolledwindow13");
GLADE_HOOKUP_OBJECT (lshw, viewport3, "viewport3");
GLADE_HOOKUP_OBJECT (lshw, scrolledwindow14, "scrolledwindow14");
GLADE_HOOKUP_OBJECT (lshw, description, "description");
GLADE_HOOKUP_OBJECT (lshw, statusbar, "statusbar");
GLADE_HOOKUP_OBJECT_NO_REF (lshw, tooltips, "tooltips");
gtk_window_add_accel_group (GTK_WINDOW (lshw), accel_group);
return lshw;
}
void
gui_create_tasks(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table;
GtkWidget *label;
GtkWidget *top_scrolledwindow;
GtkWidget *hseparator;
GtkWidget *close_button;
GtkCellRenderer *renderer;
GtkWidget *top_viewport;
GtkWidget *bottom_viewport;
GtkTextBuffer *text_buffer;
GError *error = NULL;
GtkActionGroup *action_group = NULL;
gchar tmpbuf[BUFFER_SIZE];
const gchar *ui_info =
" <toolbar name=\"toolbar\">\n"
" <toolitem name=\"add\" action=\"add\" />\n"
" <toolitem name=\"delete\" action=\"delete\" />\n"
" <separator name=\"sep1\" />\n"
" <toolitem name=\"edit\" action=\"edit\" />\n"
" </toolbar>\n";
GtkActionEntry entries[] = {
{ "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL },
{ "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL },
{ "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL },
};
guint n_entries = G_N_ELEMENTS (entries);
appGUI->tsk->filter_index = 0;
vbox1 = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks"));
gui_add_to_notebook (vbox1, tmpbuf, appGUI);
appGUI->tsk->vbox = GTK_BOX(vbox1);
if (config.hide_tasks == TRUE) {
gtk_widget_hide(GTK_WIDGET(appGUI->tsk->vbox));
}
/*-------------------------------------------------------------------------------------*/
action_group = gtk_action_group_new ("_actions");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_set_sensitive(action_group, TRUE);
appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0);
g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI);
if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) {
g_message ("building toolbar failed: %s", error->message);
g_error_free (error);
}
gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget);
gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips);
/*-------------------------------------------------------------------------------------*/
/* assign callbacks */
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked",
G_CALLBACK(tasks_add_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked",
G_CALLBACK(tasks_edit_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked",
G_CALLBACK(tasks_remove_item_cb), appGUI);
/*-------------------------------------------------------------------------------------*/
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Category filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
appGUI->tsk->cf_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->cf_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(appGUI->tsk->cf_combobox, "changed",
G_CALLBACK(category_filter_cb), appGUI);
g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus",
G_CALLBACK(category_combo_box_focus_cb), NULL);
appGUI->tsk->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->tsk->n_items_label);
gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
/*-------------------------------------------------------------------------------------*/
appGUI->tsk->tasks_paned = gtk_vpaned_new();
gtk_widget_show (appGUI->tsk->tasks_paned);
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0);
top_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (top_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE);
gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE);
top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (top_scrolledwindow);
gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter),
(GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb,
appGUI, NULL);
appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter));
appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint);
gtk_widget_show (appGUI->tsk->tasks_list);
GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT);
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED]));
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event",
G_CALLBACK(list_dbclick_cb), appGUI);
appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed",
G_CALLBACK(tasks_item_selected), appGUI);
/* create columns */
renderer = gtk_cell_renderer_toggle_new();
appGUI->tsk->tasks_columns[TA_COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"),
renderer,
"active", TA_COLUMN_DONE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DONE]);
g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"),
renderer,
"text", TA_COLUMN_DUE_DATE,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE], config.visible_due_date_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", TA_COLUMN_DUE_DATE_JULIAN,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", TA_COLUMN_START_DATE_JULIAN,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"),
renderer,
"text", TA_COLUMN_PRIORITY,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY], config.visible_priority_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"),
renderer,
"text", TA_COLUMN_CATEGORY,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY], config.visible_category_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY]);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size(renderer, 0, -1);
appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"),
renderer,
"text", TA_COLUMN_SUMMARY,
"strikethrough", TA_COLUMN_DONE,
"foreground", TA_COLUMN_COLOR,
"weight", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"),
renderer,
"text", TA_COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", TA_COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_COLOR], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_COLOR]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[TA_COLUMN_BOLD] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", TA_COLUMN_BOLD,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_BOLD], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_BOLD]);
/* configure list options */
gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE);
/* configure sorting */
gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0,
(GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DUE_DATE, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_PRIORITY, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DONE, config.tasks_sorting_order);
/*----------------------------------------------------------------------------*/
bottom_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (bottom_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE);
gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0);
gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2);
appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0);
gtk_widget_show(appGUI->tsk->panel_hbox);
sprintf(tmpbuf, "%s:", _("Task details"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0);
if (config.default_stock_icons) {
close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE);
} else {
close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL);
gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (panel_close_desc_cb), appGUI);
appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (appGUI->tsk->panel_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_widget_show (appGUI->tsk->tasks_desc_textview);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gtk_text_buffer_create_tag (text_buffer, "italic",
"style", PANGO_STYLE_ITALIC, NULL);
appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font",
"font", (gchar *) config.task_info_font, NULL);
}
static GtkWidget *create_window(void)
{
stwidgets.accel_group = gtk_accel_group_new();
// Basic window
stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
// banner
{
GdkPixbuf *pixbuf = load_banner();
stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);
// Tab control
stwidgets.tabs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);
// layout table of config page
stwidgets.configtlayout = gtk_table_new(4, 3, FALSE);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);
// 2D video mode label
stwidgets.vmode2dlabel = gtk_label_new_with_mnemonic("_2D Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode2dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6);
// 2D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode2dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dcombo, 1,2, 0,1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.vmode2dcombo, "grab_focus", stwidgets.accel_group,
GDK_2, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Fullscreen checkbox
stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.fullscreencheck, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.fullscreencheck, "grab_focus", stwidgets.accel_group,
GDK_F, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// 3D video mode label
stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_3D Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 6);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 1,2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
gtk_widget_add_accelerator(stwidgets.vmode3dcombo, "grab_focus", stwidgets.accel_group,
GDK_3, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Empty horizontal layout
stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,1, 2,3, (GtkAttachOptions)0,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
// Always show config checkbox
stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show configuration on start");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,2, 3,4, GTK_FILL, (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.alwaysshowcheck, "grab_focus", stwidgets.accel_group,
GDK_A, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Configuration tab
stwidgets.configtab = gtk_label_new("Configuration");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);
// Messages scrollable area
stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
stwidgets.messagestext = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
// Messages tab
stwidgets.messagestab = gtk_label_new("Messages");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.messagestab);
// Dialogue box buttons layout
stwidgets.buttons = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);
// Cancel button
stwidgets.cancelbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(stwidgets.cancelbutton, "grab_focus", stwidgets.accel_group,
GDK_C, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(stwidgets.cancelbutton, "clicked", stwidgets.accel_group,
GDK_Escape, (GdkModifierType)0,
GTK_ACCEL_VISIBLE);
stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);
stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);
stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);
stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
stwidgets.startbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(stwidgets.startbutton, "grab_focus", stwidgets.accel_group,
GDK_S, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(stwidgets.startbutton, "clicked", stwidgets.accel_group,
GDK_Return, (GdkModifierType)0,
GTK_ACCEL_VISIBLE);
stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);
stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);
stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);
stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) stwidgets.vmode2dcombo, "changed",
G_CALLBACK(on_vmode2dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode2dlabel), stwidgets.vmode2dcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
gtk_window_add_accel_group(GTK_WINDOW(stwidgets.startwin), stwidgets.accel_group);
return stwidgets.startwin;
}
GtkWidget* create_Chat (void)
{
GtkWidget *Chat;
GtkWidget *vbox2;
GtkWidget *vbox4;
GtkWidget *scrolledwindow3;
GtkWidget *txtDisplay;
GtkWidget *vbox3;
GtkWidget *hbox4;
GtkWidget *scrolledwindow2;
GtkWidget *viewport2;
GtkWidget *entInput;
GtkWidget *hbuttonbox1;
GtkWidget *butSend;
GtkWidget *alignment1;
GtkWidget *hbox5;
GtkWidget *image10;
GtkWidget *label8;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
Chat = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (Chat, 450, 280);
gtk_window_set_title (GTK_WINDOW (Chat), _("gchat - Client"));
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (Chat), vbox2);
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (vbox2), vbox4, TRUE, TRUE, 0);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow3);
gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow3, TRUE, TRUE, 0);
gtk_widget_set_usize (scrolledwindow3, -2, 215);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
txtDisplay = gtk_text_view_new ();
gtk_widget_show (txtDisplay);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), txtDisplay);
gtk_container_set_border_width (GTK_CONTAINER (txtDisplay), 4);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txtDisplay), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (txtDisplay), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (txtDisplay), FALSE);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (txtDisplay), 2);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (txtDisplay), 5);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (vbox2), vbox3, TRUE, TRUE, 0);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox3), hbox4, TRUE, TRUE, 0);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_box_pack_start (GTK_BOX (hbox4), scrolledwindow2, TRUE, TRUE, 7);
gtk_widget_set_usize (scrolledwindow2, 280, 20);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport2);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), viewport2);
entInput = gtk_entry_new ();
gtk_widget_show (entInput);
gtk_container_add (GTK_CONTAINER (viewport2), entInput);
gtk_tooltips_set_tip (tooltips, entInput, _("Enter the message to be sent"), NULL);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (hbox4), hbuttonbox1, TRUE, TRUE, 0);
gtk_widget_set_usize (hbuttonbox1, 40, -2);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 0);
butSend = gtk_button_new ();
gtk_widget_show (butSend);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), butSend);
GTK_WIDGET_SET_FLAGS (butSend, GTK_CAN_DEFAULT);
gtk_tooltips_set_tip (tooltips, butSend, _("Click to send the message"), NULL);
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (butSend), alignment1);
hbox5 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox5);
gtk_container_add (GTK_CONTAINER (alignment1), hbox5);
image10 = gtk_image_new_from_stock ("gnome-stock-mail-snd", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image10);
gtk_box_pack_start (GTK_BOX (hbox5), image10, FALSE, FALSE, 0);
label8 = gtk_label_new_with_mnemonic (_("Send"));
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_signal_connect (GTK_OBJECT (Chat), "destroy",
G_CALLBACK (on_Chat_destroy),
NULL);
gtk_signal_connect (GTK_OBJECT (entInput), "activate",
G_CALLBACK (on_entInput_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (butSend), "clicked",
G_CALLBACK (on_butSend_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (Chat, Chat, "Chat");
GLADE_HOOKUP_OBJECT (Chat, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (Chat, vbox4, "vbox4");
GLADE_HOOKUP_OBJECT (Chat, scrolledwindow3, "scrolledwindow3");
GLADE_HOOKUP_OBJECT (Chat, txtDisplay, "txtDisplay");
GLADE_HOOKUP_OBJECT (Chat, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (Chat, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (Chat, scrolledwindow2, "scrolledwindow2");
GLADE_HOOKUP_OBJECT (Chat, viewport2, "viewport2");
GLADE_HOOKUP_OBJECT (Chat, entInput, "entInput");
GLADE_HOOKUP_OBJECT (Chat, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT (Chat, butSend, "butSend");
GLADE_HOOKUP_OBJECT (Chat, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (Chat, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT (Chat, image10, "image10");
GLADE_HOOKUP_OBJECT (Chat, label8, "label8");
GLADE_HOOKUP_OBJECT_NO_REF (Chat, tooltips, "tooltips");
return Chat;
}
static void
jana_gtk_recurrence_init (JanaGtkRecurrence *self)
{
GtkWidget *label, *hbox, *sub_hbox, *arrow, *button;
GtkSizeGroup *size_group;
JanaGtkRecurrencePrivate *priv = RECURRENCE_PRIVATE (self);
gtk_box_set_spacing (GTK_BOX (self), 6);
/* Create preview text-view */
priv->preview_frame = gtk_frame_new (NULL);
priv->preview_textview = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (
priv->preview_textview), FALSE);
gtk_text_view_set_cursor_visible (
GTK_TEXT_VIEW (priv->preview_textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (priv->preview_textview),
GTK_WRAP_WORD_CHAR);
gtk_container_add (GTK_CONTAINER (priv->preview_frame),
priv->preview_textview);
gtk_box_pack_end (GTK_BOX (self), priv->preview_frame, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (
GTK_FRAME (priv->preview_frame), GTK_SHADOW_NONE);
gtk_widget_show_all (priv->preview_frame);
priv->edit_vbox = gtk_vbox_new (FALSE, 6);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* 'Repeats' (recurrence type) combo box */
hbox = gtk_hbox_new (FALSE, 6);
label = gtk_label_new ("Repeats:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size_group, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
priv->type_combo = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->type_combo), "None");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->type_combo),
"Every day");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->type_combo),
"Every week");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->type_combo),
"Every year");
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->type_combo), 0);
gtk_box_pack_start (GTK_BOX (hbox), priv->type_combo, TRUE, TRUE, 0);
g_signal_connect (priv->type_combo, "changed",
G_CALLBACK (type_combo_changed_cb), self);
/* Interval buttons */
sub_hbox = gtk_hbox_new (TRUE, 0);
priv->interval_dec_button = gtk_button_new ();
arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (priv->interval_dec_button), arrow);
gtk_box_pack_start (GTK_BOX (sub_hbox), priv->interval_dec_button,
FALSE, TRUE, 0);
priv->interval_inc_button = gtk_button_new ();
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (priv->interval_inc_button), arrow);
gtk_box_pack_start (GTK_BOX (sub_hbox), priv->interval_inc_button,
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), sub_hbox, FALSE, TRUE, 0);
g_signal_connect (priv->interval_inc_button, "clicked",
G_CALLBACK (interval_inc_clicked_cb), self);
g_signal_connect (priv->interval_dec_button, "clicked",
G_CALLBACK (interval_dec_clicked_cb), self);
gtk_widget_show_all (hbox);
gtk_box_pack_start (GTK_BOX (priv->edit_vbox), hbox, FALSE, TRUE, 0);
/* Weekly recurrence day-chooser */
priv->week_hbox = gtk_hbox_new (FALSE, 6);
label = gtk_label_new ("On:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size_group, label);
gtk_box_pack_start (GTK_BOX (priv->week_hbox), label, FALSE, TRUE, 0);
sub_hbox = gtk_hbox_new (TRUE, 0);
/* Weekday toggle widgets */
#define day_toggle_widget(x) \
button = gtk_toggle_button_new_with_label (jana_utils_ab_day (x)); \
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); \
gtk_box_pack_start (GTK_BOX (sub_hbox), button, TRUE, TRUE, 0); \
priv->week_buttons[x] = GTK_TOGGLE_BUTTON (button); \
g_signal_connect (button, "toggled", \
G_CALLBACK (day##x##_toggled_cb), self)
day_toggle_widget(0);
day_toggle_widget(1);
day_toggle_widget(2);
day_toggle_widget(3);
day_toggle_widget(4);
day_toggle_widget(5);
day_toggle_widget(6);
gtk_box_pack_start (GTK_BOX (priv->week_hbox), sub_hbox, TRUE, TRUE, 0);
gtk_widget_show_all (priv->week_hbox);
gtk_box_pack_start (GTK_BOX (priv->edit_vbox), priv->week_hbox,
FALSE, TRUE, 0);
/* Monthly recurrence by date/day chooser */
priv->month_hbox = gtk_hbox_new (FALSE, 6);
label = gtk_label_new ("By:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size_group, label);
gtk_box_pack_start (GTK_BOX (priv->month_hbox), label, FALSE, TRUE, 0);
sub_hbox = gtk_hbox_new (TRUE, 0);
/* By day */
priv->byday_button = GTK_TOGGLE_BUTTON (
gtk_radio_button_new_with_label (NULL, "Day"));
gtk_toggle_button_set_mode (priv->byday_button, FALSE);
gtk_box_pack_start (GTK_BOX (sub_hbox), GTK_WIDGET (
priv->byday_button), FALSE, TRUE, 0);
/* By date */
priv->bydate_button = GTK_TOGGLE_BUTTON (
gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON (priv->byday_button), "Date"));
gtk_toggle_button_set_mode (priv->bydate_button, FALSE);
g_signal_connect (priv->bydate_button, "toggled",
G_CALLBACK (bydate_toggled_cb), self);
gtk_box_pack_start (GTK_BOX (sub_hbox), GTK_WIDGET (
priv->bydate_button), FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (priv->month_hbox), sub_hbox,
FALSE, TRUE, 0);
gtk_widget_show_all (priv->month_hbox);
gtk_box_pack_start (GTK_BOX (priv->edit_vbox), priv->month_hbox,
FALSE, TRUE, 0);
/* Until time editor */
priv->end_hbox = gtk_hbox_new (FALSE, 6);
label = gtk_label_new ("Until:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size_group, label);
gtk_box_pack_start (GTK_BOX (priv->end_hbox), label, FALSE, TRUE, 0);
priv->end_button = gtk_button_new ();
hbox = gtk_hbox_new (FALSE, 6);
priv->end_label = gtk_label_new (NULL);
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), priv->end_label, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (priv->end_button), hbox);
g_signal_connect (priv->end_button, "clicked",
G_CALLBACK (end_clicked_cb), self);
gtk_box_pack_start (GTK_BOX (priv->end_hbox), priv->end_button,
FALSE, TRUE, 0);
gtk_widget_show_all (priv->end_hbox);
gtk_box_pack_start (GTK_BOX (priv->edit_vbox), priv->end_hbox,
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (self), priv->edit_vbox, FALSE, TRUE, 0);
gtk_widget_set_no_show_all (priv->edit_vbox, TRUE);
gtk_widget_set_no_show_all (priv->preview_frame, TRUE);
refresh (self);
}
