static void serverstats_init(void)
{
/** Get an allready exposed widgets to grab theme colors from. */
GtkWidget *colw = (GtkWidget *) playlist3_get_category_tree_view();
GtkWidget *label = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
GtkWidget *event = NULL;
GtkWidget *serverstats_vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *serverstats_event;
gchar *markup = NULL;
int i = 0;
serverstats_sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
serverstats_event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(serverstats_event), TRUE);
gtk_container_add(GTK_CONTAINER(serverstats_event), serverstats_vbox);
/* wrap in event box to set bg color */
event = gtk_event_box_new();
gtk_widget_set_app_paintable(event, TRUE);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE);
gtk_widget_set_state(GTK_WIDGET(event), GTK_STATE_SELECTED);
g_signal_connect(G_OBJECT(event), "expose-event", G_CALLBACK(misc_header_expose_event), NULL);
gtk_widget_modify_bg(serverstats_event, GTK_STATE_NORMAL, &(colw->style->base[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(serverstats_vbox), "style-set", G_CALLBACK(serverstats_header_style_changed),
serverstats_event);
/* set label and padding */
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_image_new_from_icon_name("mpd", GTK_ICON_SIZE_DND);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='xx-large' weight='bold'>%s</span>", _("Server Information"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(event), hbox);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_box_pack_start(GTK_BOX(serverstats_vbox), event, FALSE, TRUE, 0);
gtk_widget_show_all(event);
label = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(serverstats_vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/**
* Data list
*/
table = gtk_table_new(SERVERSTATS_NUM_FIELDS + 2, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_table_set_row_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 12);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Server"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
i = 1;
/** Mpd version */
serverstats_add_entry(table, i++, _("Version"), SERVERSTATS_MPD_VERSION);
serverstats_add_entry(table, i++, _("Uptime"), SERVERSTATS_MPD_UPTIME);
serverstats_add_entry(table, i++, _("Time Playing"), SERVERSTATS_MPD_PLAYTIME);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Database"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, i, i + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
i++;
/** Mpd Playtime */
serverstats_add_entry(table, i++, _("Total Playtime"), SERVERSTATS_MPD_DB_PLAYTIME);
/** Mpd Artists*/
serverstats_add_entry(table, i++, _("Number of artists"), SERVERSTATS_MPD_DB_ARTISTS);
/** Mpd Albums */
serverstats_add_entry(table, i++, _("Number of albums"), SERVERSTATS_MPD_DB_ALBUMS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Number of songs"), SERVERSTATS_MPD_DB_SONGS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("URL Handlers"), SERVERSTATS_MPD_URLHANDLERS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Tag Types"), SERVERSTATS_MPD_TAG_TYPES);
/** Stats */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Tag statistics"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, i, i + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
i++;
gtk_widget_show_all(table);
/**
* Stats treeview
*/
{
GtkWidget *combo = NULL;
GtkWidget *sw = NULL, *cancel;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkWidget *pb = gtk_progress_bar_new();
combo = gtk_combo_box_new_text();
for (i = 0; i < MPD_TAG_NUM_OF_ITEM_TYPES - 1; i++)
{
if (mpd_server_tag_supported(connection, i))
{
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), mpdTagItemKeys[i]);
}
}
gtk_table_attach(GTK_TABLE(table), combo, 0, 2, 12, 13, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show(combo);
hbox = gtk_hbox_new(FALSE, 6);
cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(cancel_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), pb, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cancel, FALSE, TRUE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 2, 13, 14, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(serverstats_combo_changed), pb);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width(GTK_CONTAINER(sw), 6);
store = gtk_list_store_new(4, G_TYPE_ULONG, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_DESCENDING);
serverstats_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(serverstats_tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(serverstats_tree), TRUE);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30,
NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "text", 1, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree),
-1, "", renderer, "value", 2, "text", 3, NULL);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_container_add(GTK_CONTAINER(sw), serverstats_tree);
gtk_table_attach(GTK_TABLE(table), sw, 0, 2, 14, 15, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show_all(sw);
}
/**
* Add table
*/
gtk_box_pack_start(GTK_BOX(serverstats_vbox), table, TRUE, TRUE, 0);
/* maintain my own reference to the widget, so it won't get destroyed removing
* from view
*/
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(serverstats_sw), serverstats_event);
gtk_widget_show(serverstats_vbox);
gtk_widget_show(serverstats_event);
gtk_widget_show(serverstats_sw);
g_object_ref_sink(serverstats_sw);
}
int main(int argc, char **argv) {
char buf[1024], *usage =
"usage: deepstripper-gtk [-d[ebug]] [-h[elp]] [-o[utput] <path>]\n"
" [-dps12|-dps16 <path>] [-e[xtract] <project>]\n";
GtkWidget *vbox, *men, *paned, *note, *frame, *scroll;
GtkItemFactory *fac;
GtkAccelGroup *acc;
int i, dps = -1;
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d")==0) {
g_dbg = g_dbg<<1 | 1;
} else if (strncmp(argv[i], "-h", 2)==0) {
g_print("%s", usage);
return 0;
}
}
gtk_init(&argc, &argv);
g_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(g_main), 600, 400);
set_title("?", GETCWD(buf, sizeof(buf)), "");
g_signal_connect(G_OBJECT(g_main), "delete_event", G_CALLBACK(quit), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(g_main), vbox);
gtk_widget_show(vbox);
acc = gtk_accel_group_new();
fac = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<deepstripper-main>", acc);
gtk_item_factory_create_items(fac, MENU_SIZE, root_menu, 0);
men = gtk_item_factory_get_widget(fac, "<deepstripper-main>");
gtk_box_pack_start(GTK_BOX(vbox), men, FALSE, FALSE, 0);
gtk_window_add_accel_group(GTK_WINDOW(g_main), acc);
gtk_widget_show(men);
g_multi = gtk_item_factory_get_item(fac, "/Multi");
paned = gtk_hpaned_new();
gtk_container_set_border_width(GTK_CONTAINER(paned), 5);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
gtk_widget_show(paned);
note = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(note), GTK_POS_BOTTOM);
gtk_notebook_set_show_border(GTK_NOTEBOOK(note), TRUE);
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(note), TRUE);
gtk_widget_set_size_request(note, 150, 200);
gtk_paned_pack1(GTK_PANED(paned), note, TRUE, FALSE);
gtk_widget_show(note);
for (i=0; i<N_TABS; i++) {
GtkWidget *l = gtk_label_new(g_tabs[i].tab);
gtk_widget_show(l);
gtk_notebook_append_page(GTK_NOTEBOOK(note),
make_list(g_tabs[i].data, i), l);
}
frame = gtk_frame_new("Item properties:");
gtk_widget_set_size_request(frame, 150, 200);
gtk_paned_pack2(GTK_PANED(paned), frame, TRUE, FALSE);
gtk_widget_show(frame);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame), scroll);
gtk_widget_show(scroll);
g_info = gtk_label_new(DEFAULT_INFO);
gtk_label_set_justify(GTK_LABEL(g_info), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(g_info), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), g_info);
gtk_widget_show(g_info);
g_stat = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(vbox), g_stat, FALSE, FALSE, 0);
gtk_widget_show(g_stat);
set_status("status");
// Display everything
gtk_widget_show(g_main);
// Process all other command line switches
for (i=1; i<argc; i++) {
if (strncmp(argv[i], "-o", 2)==0) {
if (chdir(argv[++i]))
about_box("unable to change directory");
else
set_title(NULL, GETCWD(buf, sizeof(buf)), NULL);
} else if (strncmp(argv[i], "-dps", 4)==0) {
open_backup(argv[i], argv[i+1]);
if (strcmp(argv[i], "-dps12")==0)
dps = AOSP_DPS12;
else
dps = AOSP_DPS16;
++i;
} else if (strncmp(argv[i], "-e", 2)==0) {
if (dps<0)
about_box("No backup specified to extract from");
else {
open_project(dps, akaiosdisk_project_byname(&g_disk, argv[++i]));
select_tracks(MID_SELNOE);
extract_tracks();
}
} else if (strncmp(argv[i], "-d", 2)==0 ||
strncmp(argv[i], "-h", 2)==0) {
; // Skip earlier opts
} else {
about_box(usage);
}
}
// Run message pump..
gtk_main();
return 0;
}
int geanypg_encrypt_selection_dialog(encrypt_data * ed, gpgme_key_t ** selected, int * sign)
{
GtkWidget * dialog = gtk_dialog_new();
unsigned long idx, sidx, capacity;
int response;
GtkWidget * contentarea, * listview, * scrollwin, * combobox;
GtkTreeIter iter;
listdata data;
gboolean active;
*sign = 0;
GtkListStore * list = geanypg_makelist(ed->key_array, ed->nkeys, 0);
listview = geanypg_listview(list, &data);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwin),
listview);
gtk_widget_set_size_request(scrollwin, 500, 160);
combobox = geanypg_combobox(geanypg_makelist(ed->skey_array, ed->nskeys, 1));
contentarea = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Please select any recipients")), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(contentarea), scrollwin, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Sign the message as:")), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(contentarea), combobox, FALSE, FALSE, 0);
// add ok and cancel buttons
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_title(GTK_WINDOW(dialog), _("Select recipients"));
gtk_widget_show_all(dialog);
// make sure dialog is destroyed when user responds
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_CANCEL)
{
gtk_widget_destroy(dialog);
return 0;
}
idx = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox));
if (idx && idx <= ed->nskeys)
{
*sign = 1;
gpgme_signers_add(ed->ctx, ed->skey_array[idx - 1]); // -1 because the first option is `None'
}
// try to loop all the keys in the list
// if they are active (the user checked the checkbox in front of the key)
// add it to the selected array, finaly make sure that the array
// is NULL terminated
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list), &iter))
{
capacity = SIZE;
*selected = (gpgme_key_t*) malloc(SIZE * sizeof(gpgme_key_t));
idx = 0;
sidx = 0;
gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1);
if (active)
(*selected)[sidx++] = ed->key_array[idx];
while (gtk_tree_model_iter_next(GTK_TREE_MODEL(list), &iter))
{
++idx;
gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1);
if (active)
(*selected)[sidx++] = ed->key_array[idx];
if (sidx >= capacity - 1)
{
capacity += SIZE;
*selected = (gpgme_key_t*) realloc(*selected, capacity * sizeof(gpgme_key_t));
}
}
(*selected)[sidx] = NULL;
}
else
{
gtk_widget_destroy(dialog);
return 0;
}
gtk_widget_destroy(dialog);
return 1;
}
int destination_address(struct navit *nav)
{
GtkWidget *window2, *keyboard, *vbox, *table;
GtkWidget *label_country;
GtkWidget *label_postal, *label_city, *label_district;
GtkWidget *label_street, *label_number;
GtkWidget *hseparator1,*hseparator2;
GtkWidget *button1,*button2,*button3;
int i;
struct search_param *search=&search_param;
struct attr search_attr, country_name, *country_attr;
struct tracking *tracking;
struct country_search *cs;
struct item *item;
search->nav=nav;
search->ms=navit_get_mapset(nav);
search->sl=search_list_new(search->ms);
window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination"));
gtk_window_set_wmclass (GTK_WINDOW (window2), "navit", "Navit");
vbox = gtk_vbox_new(FALSE, 0);
table = gtk_table_new(3, 8, FALSE);
search->entry_country = gtk_entry_new();
label_country = gtk_label_new(_("Country"));
search->entry_postal = gtk_entry_new();
gtk_widget_set_sensitive(GTK_WIDGET(search->entry_postal), FALSE);
label_postal = gtk_label_new(_("Zip Code"));
search->entry_city = gtk_entry_new();
label_city = gtk_label_new(_("City"));
search->entry_district = gtk_entry_new();
gtk_widget_set_sensitive(GTK_WIDGET(search->entry_district), FALSE);
label_district = gtk_label_new(_("District/Township"));
hseparator1 = gtk_vseparator_new();
search->entry_street = gtk_entry_new();
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
label_number = gtk_label_new(_("Number"));
search->treeview=gtk_tree_view_new();
search->listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);
{
GType types[COL_COUNT+1];
for(i=0;i<COL_COUNT;i++)
types[i]=G_TYPE_STRING;
types[i]=G_TYPE_POINTER;
search->liststore=gtk_list_store_newv(COL_COUNT+1,types);
search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 3, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
}
hseparator2 = gtk_vseparator_new();
button1 = gtk_button_new_with_label(_("Map"));
button2 = gtk_button_new_with_label(_("Bookmark"));
button3 = gtk_button_new_with_label(_("Destination"));
gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);
g_signal_connect(G_OBJECT(search->treeview), "button-release-event", G_CALLBACK(tree_view_button_release), search);
g_signal_connect(G_OBJECT(search->treeview), "row_activated", G_CALLBACK(row_activated), search);
gtk_widget_grab_focus(search->entry_city);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
keyboard=gtk_socket_new();
gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window2), vbox);
#if 0
g_signal_connect(G_OBJECT(listbox), "select-row", G_CALLBACK(select_row), NULL);
#endif
gtk_widget_show_all(window2);
#ifndef _WIN32
gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));
#endif
country_attr=country_default();
tracking=navit_get_tracking(nav);
if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL))
country_attr=&search_attr;
if (country_attr) {
cs=country_search_new(country_attr, 0);
item=country_search_get_item(cs);
if (item && item_attr_get(item, attr_country_name, &country_name))
gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str);
country_search_destroy(cs);
} else {
dbg(0,"warning: no default country found\n");
}
search->partial=1;
return 0;
}
static void
update_editor_sheet (EggToolbarEditor *editor)
{
gint y;
GPtrArray *items;
GList *to_move = NULL, *to_copy = NULL;
GtkWidget *table;
GtkWidget *viewport;
g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));
/* Create new table. */
table = gtk_table_new (0, 0, TRUE);
editor->priv->table = table;
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 24);
gtk_widget_show (table);
gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,
dest_drag_types, G_N_ELEMENTS (dest_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Build two lists of items (one for copying, one for moving). */
items = egg_toolbars_model_get_name_avail (editor->priv->model);
while (items->len > 0)
{
GtkWidget *item;
const char *name;
gint flags;
name = g_ptr_array_index (items, 0);
g_ptr_array_remove_index_fast (items, 0);
flags = egg_toolbars_model_get_name_flags (editor->priv->model, name);
if ((flags & EGG_TB_MODEL_NAME_INFINITE) == 0)
{
item = editor_create_item_from_name (editor, name, GDK_ACTION_MOVE);
if (item != NULL)
to_move = g_list_insert_sorted (to_move, item, compare_items);
}
else
{
item = editor_create_item_from_name (editor, name, GDK_ACTION_COPY);
if (item != NULL)
to_copy = g_list_insert_sorted (to_copy, item, compare_items);
}
}
/* Add them to the sheet. */
y = 0;
y = append_table (GTK_TABLE (table), to_move, y, 4);
y = append_table (GTK_TABLE (table), to_copy, y, 4);
g_list_free (to_move);
g_list_free (to_copy);
g_ptr_array_free (items, TRUE);
/* Delete old table. */
viewport = gtk_bin_get_child (GTK_BIN (editor->priv->scrolled_window));
if (viewport)
{
gtk_container_remove (GTK_CONTAINER (viewport),
gtk_bin_get_child (GTK_BIN (viewport)));
}
/* Add table to window. */
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);
}
GtkWidget *load_gtk_widget(void)
{
GtkTreeStore *store;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *pScrollbar, *pvbox;
GtkTreeSelection *selection;
/* Create a list for keyboards */
store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
viewlayout = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("X Layout"), renderer, "text", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("X Variant"), renderer, "text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("Console keymap"), renderer, "text", 3, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
/* change tree selection mode */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (viewlayout));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed", G_CALLBACK (selection_changed),NULL);
pScrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrollbar), viewlayout);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
pvbox = gtk_vbox_new(FALSE, 5);
/* top info label */
GtkWidget *labelhelp = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(labelhelp), _("<b>You may select one of the following keyboard maps.</b>"));
gtk_box_pack_start(GTK_BOX(pvbox), labelhelp, FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(pvbox), pScrollbar, TRUE, TRUE, 0);
/* lower label and button for personalized keyboard */
GtkWidget *hboxbas = gtk_hbox_new(FALSE, 5);
GtkWidget *entrytest = gtk_entry_new();
GtkWidget *labeltest = gtk_label_new(_("Test your keyboard here :"));
GtkWidget *persokeyb = gtk_button_new_with_label(_("Personalized keyboard"));
char *imgpath = g_strdup_printf("%s/key24.png", IMAGEDIR);
GtkWidget *image = gtk_image_new_from_file(imgpath);
free(imgpath);
gtk_button_set_image(GTK_BUTTON(persokeyb), image);
g_signal_connect (persokeyb, "clicked", G_CALLBACK (add_keyboard),NULL);
gtk_box_pack_start(GTK_BOX(hboxbas), labeltest, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hboxbas), entrytest, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hboxbas), persokeyb, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(pvbox), hboxbas, FALSE, FALSE, 5);
/* Load keymaps use for personalized keyboard */
find_console_layout(CKEYDIR);
find_x_layout(XKEYDIR);
/* Loads keymaps from files */
find_languages(KEYDIR);
return pvbox;
}
static void
netselect_dlg_show()
{
struct netselect_dlg * dlg;
GtkWidget * main_vbox, * scrolled,
* button_box, * manual_hbox,
* hbox, * vbox, * frame, * settings_vbox;
GtkTreeViewColumn * column;
gchar * text;
if(main_netselect_dlg) {
/* dialog is shown already */
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
return;
}
dlg = main_netselect_dlg = g_new(struct netselect_dlg, 1);
dlg->detect_timeout_id = 0;
dlg->dlg_w = gtk_dialog_new_with_buttons(
_("Network detection and configuration"), gui_get_main_window(), 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dlg->dlg_w), "response",
G_CALLBACK(dlg_response), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->dlg_w), "delete-event", G_CALLBACK(gtk_true), NULL);
/* upper vertical box for list and port range controls
*/
main_vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg->dlg_w)->vbox), main_vbox, TRUE, TRUE, 0);
frame = gtk_frame_new(_("Detected networks"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0);
dlg->list = gtk_list_store_new(
NETLISTCOL_NUM,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
dlg->tree_w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dlg->list));
g_signal_connect(G_OBJECT(dlg->tree_w), "row-activated",
G_CALLBACK(list_row_activated), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->tree_w), "cursor-changed",
G_CALLBACK(list_cursor_changed), (gpointer)dlg);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_TYPE),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_TYPE_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_PORT),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_PORT_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 1);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_USE_MULTICAST),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_USE_MULTICAST_STR, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrolled, -1, LIST_MIN_HEIGHT);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), dlg->tree_w);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
/* Make hbox for lower control frames */
manual_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), manual_hbox, FALSE, FALSE, 0);
/*
* "Automatic scan" frame
*/
frame = gtk_frame_new(_("Automatic scan"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* progress bar
*/
dlg->detect_progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_progress, FALSE, FALSE, 0);
/* the 'reset' and 'refresh' buttons
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button_box = gtk_hbutton_box_new();
gtk_box_pack_end(GTK_BOX(hbox), button_box, FALSE, FALSE, 0);
dlg->detect_btn = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
g_signal_connect(G_OBJECT(dlg->detect_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_btn, FALSE, FALSE, 0);
dlg->detect_stop_btn = gtk_button_new_from_stock(GTK_STOCK_STOP);
g_signal_connect(G_OBJECT(dlg->detect_stop_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_stop_btn, FALSE, FALSE, 0);
/* settings vbox */
settings_vbox = gtk_vbox_new(FALSE, 4);
/* port range start spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_begin_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_begin_spin), DEFAULT_DETECT_RANGE_BEGIN);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_begin_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("Scan UDP ports from")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_begin_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* port range end spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_end_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_end_spin), DEFAULT_DETECT_RANGE_END);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_end_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("to (including)")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_end_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* broadcast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_broadcast_mask_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_broadcast_mask_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_BROADCAST_MASK)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_broadcast_mask_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_BROADCAST_MASK)), FALSE, FALSE, 0);
/* multicast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_multicast_addr_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_multicast_addr_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_MULTICAST_ADDR)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_multicast_addr_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_MULTICAST_ADDR)), FALSE, FALSE, 0);
/* pack settings vbox in to the window (through the expander widget) */
#if(HAVE_EXPANDER_WIDGET)
dlg->detect_expander_w = gtk_expander_new_with_mnemonic(_("Detection settings"));
gtk_container_add(GTK_CONTAINER(dlg->detect_expander_w), settings_vbox);
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_expander_w, FALSE, FALSE, 0);
#else
gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), settings_vbox, FALSE, FALSE, 0);
#endif
/*
* Manual port/network entry frame
*/
frame = gtk_frame_new(_("Network settings"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* use multicast toggle */
dlg->net_use_multicast_w = gtk_check_button_new_with_label(
prefs_description(PREFS_NET_USE_MULTICAST));
gtk_widget_set_sensitive(
dlg->net_use_multicast_w, prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dlg->net_use_multicast_w),
prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS
? prefs_bool(PREFS_NET_USE_MULTICAST): FALSE);
/* network type option */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_type_option = util_net_type_option(
(util_option_changed_cb)dlg_net_type_option_changed, (gpointer)dlg);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_type_option, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_TYPE)), FALSE, FALSE, 0);
gtk_option_menu_set_history(
GTK_OPTION_MENU(dlg->net_type_option), prefs_int(PREFS_NET_TYPE));
/* network port number */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_port_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_port_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_PORT)), FALSE, FALSE, 0);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->net_port_spin),
prefs_int(PREFS_NET_PORT));
/* append the multicast toggle */
gtk_box_pack_start(GTK_BOX(vbox), dlg->net_use_multicast_w, FALSE, FALSE, 0);
/* show dialog to the user */
dlg_search_mode(dlg, FALSE);
gtk_widget_show_all(dlg->dlg_w);
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
}
/* cvs_add_task */
static int _cvs_add_task(CVS * cvs, char const * title,
char const * directory, char * argv[])
{
BrowserPluginHelper * helper = cvs->helper;
CVSTask ** p;
CVSTask * task;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD;
gboolean res;
GError * error = NULL;
PangoFontDescription * font;
char buf[256];
GtkWidget * vbox;
GtkWidget * widget;
if((p = realloc(cvs->tasks, sizeof(*p) * (cvs->tasks_cnt + 1))) == NULL)
return -helper->error(helper->browser, strerror(errno), 1);
cvs->tasks = p;
if((task = object_new(sizeof(*task))) == NULL)
return -helper->error(helper->browser, error_get(), 1);
task->cvs = cvs;
#ifdef DEBUG
argv[0] = "echo";
#endif
res = g_spawn_async_with_pipes(directory, argv, NULL, flags, NULL, NULL,
&task->pid, NULL, &task->o_fd, &task->e_fd, &error);
if(res != TRUE)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
object_delete(task);
return -1;
}
cvs->tasks[cvs->tasks_cnt++] = task;
/* widgets */
font = pango_font_description_new();
pango_font_description_set_family(font, "monospace");
task->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(task->window), 600, 400);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(task->window), plugin.icon);
#endif
snprintf(buf, sizeof(buf), "%s - %s (%s)", _("CVS"), title, directory);
gtk_window_set_title(GTK_WINDOW(task->window), buf);
g_signal_connect_swapped(task->window, "delete-event", G_CALLBACK(
_cvs_task_on_closex), task);
vbox = gtk_vbox_new(FALSE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
task->view = gtk_text_view_new();
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(task->view), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(task->view), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(task->view),
GTK_WRAP_WORD_CHAR);
gtk_widget_modify_font(task->view, font);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(widget),
task->view);
gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
task->statusbar = gtk_statusbar_new();
task->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), task->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(task->window), vbox);
gtk_widget_show_all(task->window);
pango_font_description_free(font);
/* events */
task->source = g_child_watch_add(task->pid, _cvs_task_on_child_watch,
task);
task->o_channel = g_io_channel_unix_new(task->o_fd);
if((g_io_channel_set_encoding(task->o_channel, NULL, &error))
!= G_IO_STATUS_NORMAL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
}
task->o_source = g_io_add_watch(task->o_channel, G_IO_IN,
_cvs_task_on_io_can_read, task);
task->e_channel = g_io_channel_unix_new(task->e_fd);
if((g_io_channel_set_encoding(task->e_channel, NULL, &error))
!= G_IO_STATUS_NORMAL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
}
task->e_source = g_io_add_watch(task->e_channel, G_IO_IN,
_cvs_task_on_io_can_read, task);
_cvs_task_set_status(task, _("Running command..."));
return 0;
}
static GtkWidget* create_window (void)
{
GtkWidget *window;
GtkScrolledWindow *scrolledWindow;
GtkWidget *button;
GtkWidget *image;
GdkPixbuf *imageBuf;
GError *error = NULL;
GtkWidget *box;
int width, height;
// Window.
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "image-viewer-c");
// Signal to Exit when the window is closed.
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show(window);
// Container Box.
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
// Add to the container.
gtk_container_add (GTK_CONTAINER (window), box);
// Scrolled Window to include image.
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledWindow);
// Button.
button = gtk_button_new_with_label (("Open image"));
gtk_widget_show(button);
// Image Buffer.
imageBuf = gdk_pixbuf_new_from_file ("images/doors.jpg", &error);
width = gdk_pixbuf_get_width (imageBuf);
height = gdk_pixbuf_get_height (imageBuf);
// Image.
image = gtk_image_new_from_file("images/doors.jpg");
// Default size for the window.
gtk_widget_set_size_request (window, width<500?width:500,
height<500?height:500);
gtk_widget_show(image);
// Use ViewPort to set scrollWidow to image.
gtk_scrolled_window_add_with_viewport(scrolledWindow, image);
// Add Widgets.
gtk_box_pack_start (GTK_BOX (box), scrolledWindow, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), image, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
// Show open dialog when opening a file.
g_signal_connect (button, "clicked", G_CALLBACK (on_open_image), image);
return window;
}
static GtkWidget*
previews_of_button_layouts (void)
{
static gboolean initted = FALSE;
GtkWidget *box;
GtkWidget *sw;
GdkColor desktop_color;
int i;
GtkWidget *eventbox;
if (!initted)
{
init_layouts ();
initted = TRUE;
}
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
box = gtk_vbox_new (FALSE, 0);
gtk_box_set_spacing (GTK_BOX (box), 20);
gtk_container_set_border_width (GTK_CONTAINER (box), 20);
eventbox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (eventbox), box);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);
desktop_color.red = 0x5144;
desktop_color.green = 0x75D6;
desktop_color.blue = 0xA699;
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, &desktop_color);
i = 0;
while (i < BUTTON_LAYOUT_COMBINATIONS)
{
GtkWidget *align;
double xalign, yalign;
GtkWidget *eventbox2;
GtkWidget *preview;
char *title;
eventbox2 = gtk_event_box_new ();
preview = meta_preview_new ();
gtk_container_add (GTK_CONTAINER (eventbox2), preview);
meta_preview_set_theme (META_PREVIEW (preview), global_theme);
title = g_strdup_printf (_("Button layout test %d"), i+1);
meta_preview_set_title (META_PREVIEW (preview), title);
g_free (title);
meta_preview_set_button_layout (META_PREVIEW (preview),
&different_layouts[i]);
xalign = 0.5;
yalign = 0.5;
align = gtk_alignment_new (0.0, 0.0, xalign, yalign);
gtk_container_add (GTK_CONTAINER (align), eventbox2);
gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);
previews[META_FRAME_TYPE_LAST*FONT_SIZE_LAST + i] = preview;
++i;
}
return sw;
}
/*void destroy( GtkWidget *widget,
gpointer data )
{
send(data->sockfd,"exit",200,0);
gtk_main_quit();
}*/
void talk(struct args *data)
{
puts("step 1");
puts(data->u_id1);
//g_print ("Hello World\n");
GtkWidget *window2;
GtkWidget *button1;
GtkWidget *table;
GtkWidget *entry1,*entry2;
GtkWidget *scroller;
GtkWidget *label,*label2;
// GtkWidget *view;
GtkTextBuffer *buffer;
pthread_t thread_id;
pthread_create(&thread_id,NULL,&recv_server,data);
// puts("step 1");
// pthread_create();
window2=gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable(GTK_WINDOW(window2),FALSE);
gtk_signal_connect (GTK_OBJECT (window2), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL);
puts("step 2");
gtk_container_set_border_width(GTK_CONTAINER(window2),20);
table=gtk_table_new(15,15,TRUE);
gtk_container_add(GTK_CONTAINER(window2),table);
gtk_widget_set_size_request(table,400,250);
gtk_table_set_row_spacings(GTK_TABLE(table),10);
gtk_widget_show(table);
gchar *server_msg;
// if(recv(sockfd,server_msg,100,0))
label2=gtk_label_new("**welcome to sudhanshu's chat client**");
gtk_table_attach_defaults(GTK_TABLE(table),label2,0,15,0,1);
gtk_widget_show(label2);
//if(send(sockfd,data->u_id,50,0)<0);
// perror("send");
//if(send(sockfd,data->me_id,50,0)<0);
// perror("send");
//perror("recv");
//puts(server_msg);
/*-------------------------scroller--------------------------------------*/
// scroller=gtk_vscrollbar_new(GTK_TEXT(entry1));
// gtk_table_attach_defaults(GTK_TABLE(table),scroller,14,15,0,13);
//gtk_widget_show(scroller);
/*--------------------------------------------
text area one
-------------------------------------*/
// entry1=gtk_entry_new_with_max_length(100000);
// gtk_entry_get_text_area(entry1,20);
data->entry1 = gtk_text_view_new();
GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll),data->entry1);
GIOChannel *sfd;
sfd=g_io_channel_unix_new(data->sockfd);
//buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry1));
//gtk_text_buffer_set_text(buffer,"helladfafd",-1);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data->entry1),FALSE);
gtk_widget_set_size_request(scroll,350,150);
// gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(data->entry1),GTK_TEXT_WINDOW_RIGHT,5);
// gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(data->entry1),GTK_TEXT_WINDOW_LEFT,10);
// gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(data->entry1),GTK_TEXT_WINDOW_RIGHT,10);
// gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(data->entry1),GTK_TEXT_WINDOW_TOP,10);
// gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(data->entry1),GTK_TEXT_WINDOW_BOTTOM,10);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(data->entry1),GTK_WRAP_CHAR);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(data->entry1),0);
int x;
// x=gtk_text_view_get_wrap_mode(GTK_TEXT_VIEW(data->entry1));
// printf("wrap mode $$$$ %d and real %d $$$$\n",GTK_WRAP_CHAR,x);
// g_io_add_watch(sfd,G_IO_IN,(GIOFunc)print_inbox,(struct args*)data);
gchar msgr[200];
puts("step 3");
// recv(data->sockfd,msgr,200,0);
// strcat(data->u_id,msgr);
// puts(data->u_id);
// gtk_text_insert(GTK_TEXT(data->entry1),NULL,NULL,NULL,msgr,-1);
// puts("step 4");
//gtk_widget_set_size_request(data->entry1,350,0);
GtkWidget *fix=gtk_alignment_new(0.5,0.2,1,0);
gtk_container_add(GTK_CONTAINER(fix),scroll);
gtk_table_attach_defaults(GTK_TABLE(table),fix,0,14,1,12);
gtk_widget_show(scroll);
gtk_widget_show(fix);
gtk_widget_show(data->entry1);
/*******************lable***********************************************/
label=gtk_label_new("CHAT");
gtk_table_attach_defaults(GTK_TABLE(table),label,0,2,12,13);
gtk_widget_show(label);
/*--------------------text area two------------------------------------*/
data->entry2=gtk_entry_new_with_max_length(200);
gtk_signal_connect(GTK_OBJECT(data->entry2),"activate",
GTK_SIGNAL_FUNC(sending_server),
(struct args *)data);
gtk_table_attach_defaults(GTK_TABLE(table),data->entry2,2,15,12,13);
gtk_widget_show(data->entry2);
/*-----------------------------text areas ends--------------------------*/
button1=gtk_button_new_with_label("exit");
//gtk_container_add(GTK_CONTAINER(window2),button1);
gtk_signal_connect(GTK_OBJECT(button1),"clicked",
GTK_SIGNAL_FUNC(destroy),NULL);
gtk_table_attach_defaults(GTK_TABLE(table),button1,6,9,13,15);
gtk_widget_show(button1);
gtk_widget_show(window2);
//gtk_widget_show_all(table);
}
static GtkWidget*
preview_collection (int font_size,
PangoFontDescription *base_desc)
{
GtkWidget *box;
GtkWidget *sw;
GdkColor desktop_color;
int i;
GtkWidget *eventbox;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
box = gtk_vbox_new (FALSE, 0);
gtk_box_set_spacing (GTK_BOX (box), 20);
gtk_container_set_border_width (GTK_CONTAINER (box), 20);
eventbox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (eventbox), box);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);
desktop_color.red = 0x5144;
desktop_color.green = 0x75D6;
desktop_color.blue = 0xA699;
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, &desktop_color);
i = 0;
while (i < META_FRAME_TYPE_LAST)
{
const char *title = NULL;
GtkWidget *contents;
GtkWidget *align;
double xalign, yalign;
GtkWidget *eventbox2;
GtkWidget *preview;
PangoFontDescription *font_desc;
double scale;
eventbox2 = gtk_event_box_new ();
preview = meta_preview_new ();
gtk_container_add (GTK_CONTAINER (eventbox2), preview);
meta_preview_set_frame_type (META_PREVIEW (preview), i);
meta_preview_set_frame_flags (META_PREVIEW (preview),
get_window_flags (i));
meta_preview_set_theme (META_PREVIEW (preview), global_theme);
contents = get_window_contents (i, &title);
meta_preview_set_title (META_PREVIEW (preview), title);
gtk_container_add (GTK_CONTAINER (preview), contents);
if (i == META_FRAME_TYPE_MENU)
{
xalign = 0.0;
yalign = 0.0;
}
else
{
xalign = 0.5;
yalign = 0.5;
}
align = gtk_alignment_new (0.0, 0.0, xalign, yalign);
gtk_container_add (GTK_CONTAINER (align), eventbox2);
gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);
switch (font_size)
{
case FONT_SIZE_SMALL:
scale = PANGO_SCALE_XX_SMALL;
break;
case FONT_SIZE_LARGE:
scale = PANGO_SCALE_XX_LARGE;
break;
default:
scale = 1.0;
break;
}
if (scale != 1.0)
{
font_desc = pango_font_description_new ();
pango_font_description_set_size (font_desc,
MAX (pango_font_description_get_size (base_desc) * scale, 1));
gtk_widget_modify_font (preview, font_desc);
pango_font_description_free (font_desc);
}
previews[font_size*META_FRAME_TYPE_LAST + i] = preview;
++i;
}
return sw;
}
static GtkWidget *build_map_panel(void)
{
GtkWidget *lbl;
GtkWidget *legend_content;
map_notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(map_notebook), GTK_POS_TOP);
gtk_widget_show(map_notebook);
/* Tab page name */
lbl = gtk_label_new(_("Map"));
gtk_widget_show(lbl);
gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook),
build_map_area(), lbl, MAP_PAGE);
/* Tab page name */
lbl = gtk_label_new(_("Trade"));
gtk_widget_show(lbl);
trade_page = trade_build_page();
gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook),
trade_page, lbl, TRADE_PAGE);
gtk_widget_hide(trade_page);
/* Tab page name */
lbl = gtk_label_new(_("Quote"));
gtk_widget_show(lbl);
quote_page = quote_build_page();
gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook),
quote_page, lbl, QUOTE_PAGE);
gtk_widget_hide(quote_page);
/* Tab page name */
lbl = gtk_label_new(_("Legend"));
gtk_widget_show(lbl);
legend_content = legend_create_content();
legend_page = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(legend_page),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
(legend_page),
GTK_SHADOW_NONE);
gtk_widget_show(legend_page);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
(legend_page),
legend_content);
gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook),
legend_page, lbl, LEGEND_PAGE);
if (!legend_page_enabled)
gui_show_legend_page(FALSE);
theme_register_callback(G_CALLBACK(gui_theme_changed));
/* Tab page name, shown for the splash screen */
lbl = gtk_label_new(_("Welcome to Pioneers"));
gtk_widget_show(lbl);
splash_page = splash_build_page();
gtk_notebook_insert_page(GTK_NOTEBOOK(map_notebook),
splash_page, lbl, SPLASH_PAGE);
return map_notebook;
}
int destination_address(struct navit *nav)
{
GtkWidget *window2, *keyboard, *vbox, *table;
GtkWidget *label_country;
GtkWidget *label_postal, *label_city, *label_district;
GtkWidget *label_street, *label_number;
GtkWidget *hseparator1,*hseparator2;
GtkWidget *button1,*button2,*button3;
int i;
struct search_param *search=&search_param;
search->nav=nav;
search->ms=navit_get_mapset(nav);
search->sl=search_list_new(search->ms);
window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_vbox_new(FALSE, 0);
table = gtk_table_new(3, 8, FALSE);
search->entry_country = gtk_entry_new();
label_country = gtk_label_new(_("Country"));
search->entry_postal = gtk_entry_new();
label_postal = gtk_label_new(_("Zip Code"));
search->entry_city = gtk_entry_new();
label_city = gtk_label_new(_("City"));
search->entry_district = gtk_entry_new();
label_district = gtk_label_new(_("District/Township"));
hseparator1 = gtk_vseparator_new();
search->entry_street = gtk_entry_new();
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
label_number = gtk_label_new(_("Number"));
search->treeview=gtk_tree_view_new();
search->listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);
{
GType types[COL_COUNT+1];
for(i=0;i<COL_COUNT;i++)
types[i]=G_TYPE_STRING;
types[i]=G_TYPE_POINTER;
search->liststore=gtk_list_store_newv(COL_COUNT+1,types);
search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 0, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
}
hseparator2 = gtk_vseparator_new();
button1 = gtk_button_new_with_label("Karte");
button2 = gtk_button_new_with_label("Bookmark");
button3 = gtk_button_new_with_label("Ziel");
gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);
gtk_widget_grab_focus(search->entry_city);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
keyboard=gtk_socket_new();
gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window2), vbox);
#if 0
g_signal_connect(G_OBJECT(listbox), "select-row", G_CALLBACK(select_row), NULL);
#endif
gtk_widget_show_all(window2);
gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));
return 0;
}
/*
* Windows Main
* Twitter TimeLine Cntent
*
*/
int windows_main(int argc, char **argv){
gtk_init (&argc, &argv);
char *configFile = NULL;
GError *error = NULL;
GtkWidget *window,
*table,
*scroll,
*icon_menu,
*table_into,
//*tweet,
//*avatar,
*scrolled_window,
*menu_bar,
*layout,
*toolbar,
*statusbar,
*statusbar_char,
*new_button,
*text,
*file_menu_obj,
*file_menu_root,
*file_menu_items,
*aiuto_menu_obj,
*aiuto_menu_root,
*aiuto_menu_items;
GtkTextBuffer *buffer;
asprintf(&configFile, "%s%s", g_get_home_dir(), "/.twc/config/user.twc");
/* Set all window options (color, size, position, logo, icon, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 315, 650);
gtk_widget_set_size_request (window, 315, 400);
gtk_window_set_title (GTK_WINDOW(window), "TwitCrusader");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_FAVICON, &error);
/* CALLBACK: exit event */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
/* GTK Widget: Menu */
file_menu_obj = gtk_menu_new();
aiuto_menu_obj = gtk_menu_new();
/* SuBMenu File
* Fix Icons Linux
* gconftool-2 --type boolean --set /desktop/gnome/interface/buttons_have_icons true
* gconftool-2 --type boolean --set /desktop/gnome/interface/menus_have_icons true
* */
file_menu_items = gtk_image_menu_item_new_with_label("Nuovo Utente");
icon_menu = gtk_image_new_from_file(ICON_ADDUSER);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_adduser), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Opzioni");
icon_menu = gtk_image_new_from_file(ICON_SETTINGS);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_setting), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Esci");
icon_menu = gtk_image_new_from_file(ICON_CLOSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (gtk_main_quit), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_root = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (file_menu_root), file_menu_obj);
/* SubMenu: Help */
aiuto_menu_items = gtk_image_menu_item_new_with_label("Updates");
icon_menu = gtk_image_new_from_file(ICON_UPGRADE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_upgrade), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_items = gtk_image_menu_item_new_with_label("Informazioni");
icon_menu = gtk_image_new_from_file(ICON_STAR);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_about), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_root = gtk_menu_item_new_with_label("Aiuto");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (aiuto_menu_root), aiuto_menu_obj);
/* Set Layout Position */
layout = gtk_vbox_new(0, 1);
gtk_container_add(GTK_CONTAINER(window), layout);
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(layout), menu_bar, FALSE, FALSE, 0);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file_menu_root);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), aiuto_menu_root);
/* Status Bar */
statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar), TRUE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar), 0, "TwitCrusader...");
gtk_box_pack_end (GTK_BOX (layout), statusbar, FALSE, FALSE, 0);
/* GTK Widget: Twitter Menu */
toolbar = gtk_toolbar_new ();
gtk_box_pack_end (GTK_BOX (layout), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
/* Twitter Menu: Buttons */
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_HOME);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_UPDATE);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_MENTION);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_DM);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_FAVORITES);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_LINK);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_PHOTO);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
/* Status Bar: Twitter 140char */
statusbar_char = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar_char), FALSE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar_char), 0, "140");
gtk_box_pack_end (GTK_BOX (layout), statusbar_char, FALSE, FALSE, 0);
/* Table Content Tweet/Mentions */
table = gtk_table_new (9, 3, TRUE);
gtk_container_add(GTK_CONTAINER(layout), table);
/* Scrolled */
table_into = gtk_table_new (1, 3, TRUE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_table_attach (GTK_TABLE (table), scrolled_window, 0, 3, 0, 8, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table_into);
/*for ( rows = 0; rows < 40; rows = rows + 4 ) {
for ( cols = 0; cols < 3; cols++ ) {
avatar = gtk_image_new_from_file ("");
tweet = gtk_label_new ("");
gtk_label_set_justify (GTK_LABEL(tweet),GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap_mode (GTK_LABEL(tweet), GTK_WRAP_WORD_CHAR);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 0, 1,rows, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows, rows + 1, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
tweet = gtk_label_new ("");
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows + 1, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
}
}*/
// TextArea + Scrollbar
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_table_attach (GTK_TABLE (table), scroll, 0, 3,8, 9, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_set_text (buffer, "", -1);
g_signal_connect(buffer, "changed", G_CALLBACK(update_statusbar), statusbar_char);
g_signal_connect(text, "key-press-event", G_CALLBACK(send_tweet_gtk), buffer);
gtk_container_add(GTK_CONTAINER(scroll), text);
// Widget Show
gtk_widget_show_all (window);
//Exist Config File?
if(readUserFile()==1) windows_adduser();
//Show GTK Main
gtk_main ();
return 0;
}
Chattab *
ui_tab_create(const gchar *jid, const gchar *title, gint active)
{
Chattab *tab;
GtkWidget *evbox;
tab = g_malloc(sizeof(Chattab));
if(jid == NULL) {
tab->jid = NULL;
status_tab = tab;
}
else
tab->jid = g_strdup(jid);
tab->title = g_strdup(title);
/* setting up a place for a tab title */
evbox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE);
tab->label = gtk_label_new(tab->title);
gtk_container_add(GTK_CONTAINER(evbox), tab->label);
gtk_widget_show(tab->label);
g_signal_connect(G_OBJECT(evbox), "button-press-event",
G_CALLBACK(tab_label_click_cb), (gpointer)tab);
/* creating GtkTextView for status messages */
tab->tview = gtk_text_view_new();
tab->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tab->tview));
gtk_text_view_set_editable(GTK_TEXT_VIEW(tab->tview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tab->tview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tab->tview), GTK_WRAP_WORD);
tab->mk = gtk_text_buffer_get_mark(tab->buffer, "insert");
/* we're putting this in a scrolled window */
tab->scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab->scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tab->scrolled),
tab->tview);
/* setting up the entry field */
if (jid) {
tab->entry = mlentry_new(tab_entry_handler, tab);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tab->entry), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(tab->entry), FALSE);
}
/* some vbox to put it together */
tab->vbox = gtk_vpaned_new();
/* this will help us finding Chattab struct by some of its properties */
g_object_set_data(G_OBJECT(tab->vbox), "chattab-data", tab);
/* now let's put it all together */
gtk_paned_pack1(GTK_PANED(tab->vbox), tab->scrolled, TRUE, FALSE);
if(jid) {
gtk_paned_pack2(GTK_PANED(tab->vbox), tab->entry, FALSE, FALSE);
}
gtk_widget_show_all(tab->vbox);
/* aaand, launch! */
gtk_notebook_append_page(GTK_NOTEBOOK(nbook), tab->vbox, evbox);
tabs = g_slist_prepend(tabs, tab);
if(active && jid) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(nbook),
gtk_notebook_page_num(GTK_NOTEBOOK(nbook),
tab->vbox));
gtk_widget_grab_focus(tab->entry);
}
return tab;
} /* ui_tab_create */
GtkWidget* create_list(void)
{
#if 0
//int i;
GtkWidget *scrolled_window;
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *tree_view;
GtkListStore *listmodel;
GtkTreeIter iter;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
//builder
builder = gtk_builder_new();
gtk_builder_add_from_file (builder, "list-store.glade", NULL);
//window
scrolled_window = GTK_WIDGET(gtk_builder_get_object(builder, "window1"));
tree_view = GTK_WIDGET(gtk_builder_get_object(builder, "treeview1"));
//listmodel = (GtkListStore *)gtk_builder_get_object(builder, "liststore1");
//listmodel = gtk_list_store_new(1, G_TYPE_STRING);
// gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), GTK_TREE_MODEL(listmodel));
gtk_widget_show(tree_view);
/*for (i = 0; i < 10; i++)
{
gchar *msg = g_strdup_printf("Message #%d", i);
gtk_list_store_append(GTK_LIST_STORE(listmodel), &iter);
gtk_list_store_set(GTK_LIST_STORE(listmodel),
&iter,
0, msg,
-1);
g_free(msg);
}*/
//cell = gtk_cell_renderer_text_new();
// column = gtk_tree_view_column_new_with_attributes ("Message",
// cell,
// "text", 0,
// NULL);
// gtk_tree_view_append_column(GTK_TREE_VIEW (tree_view),
// GTK_TREE_VIEW_COLUMN (column));
#endif
#if 0
int i;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkListStore *listmodel;
GtkTreeIter iter;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
//scroll when need
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
listmodel = gtk_list_store_new(1, G_TYPE_STRING);
tree_view = gtk_tree_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
tree_view);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), GTK_TREE_MODEL(listmodel));
gtk_widget_show(tree_view);
/* 在窗口中添加一些消息 */
for (i = 0; i < 10; i++)
{
gchar *msg = g_strdup_printf("Message #%d", i);
gtk_list_store_append(GTK_LIST_STORE(listmodel), &iter);
gtk_list_store_set(GTK_LIST_STORE(listmodel),
&iter,
0, msg,
-1);
g_free(msg);
}
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Message",
cell,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (tree_view),
GTK_TREE_VIEW_COLUMN (column));
#endif
return NULL;
}
int main(int argc, char *argv[]){
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *scrollw1;
GtkWidget *canvas;
GtkPlotCanvasChild *child;
gint page_width, page_height;
gfloat scale = 1.;
page_width = GTK_PLOT_LETTER_W * scale;
page_height = GTK_PLOT_LETTER_H * scale;
gtk_init(&argc,&argv);
window1=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window1), "GtkPlotFlux Demo");
gtk_widget_set_usize(window1,550,650);
gtk_container_border_width(GTK_CONTAINER(window1),0);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
vbox1=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window1),vbox1);
gtk_widget_show(vbox1);
scrollw1=gtk_scrolled_window_new(NULL, NULL);
gtk_container_border_width(GTK_CONTAINER(scrollw1),0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollw1),
GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1),scrollw1, TRUE, TRUE,0);
gtk_widget_show(scrollw1);
canvas = gtk_plot_canvas_new(page_width, page_height, 1.);
GTK_PLOT_CANVAS_SET_FLAGS(GTK_PLOT_CANVAS(canvas), GTK_PLOT_CANVAS_DND_FLAGS);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollw1), canvas);
/*
gdk_color_parse("light blue", &color);
gdk_color_alloc(gtk_widget_get_colormap(canvas), &color);
gtk_plot_canvas_set_background(GTK_PLOT_CANVAS(canvas), &color);
*/
gtk_widget_show(canvas);
active_plot = new_layer(canvas);
gtk_plot_set_range(GTK_PLOT(active_plot), -1. ,1., -1., 1.4);
gtk_plot_legends_move(GTK_PLOT(active_plot), .500, .05);
gtk_plot_set_legends_border(GTK_PLOT(active_plot), 0, 0);
gtk_plot_axis_hide_title(gtk_plot_get_axis(GTK_PLOT(active_plot), GTK_PLOT_AXIS_TOP));
gtk_plot_axis_show_ticks(gtk_plot_get_axis(GTK_PLOT(active_plot), 3), 15, 3);
gtk_plot_axis_set_ticks(gtk_plot_get_axis(GTK_PLOT(active_plot), 0), 1., 1);
gtk_plot_axis_set_ticks(gtk_plot_get_axis(GTK_PLOT(active_plot), 1), 1., 1);
gtk_plot_axis_set_visible(gtk_plot_get_axis(GTK_PLOT(active_plot), GTK_PLOT_AXIS_TOP), TRUE);
gtk_plot_axis_set_visible(gtk_plot_get_axis(GTK_PLOT(active_plot), GTK_PLOT_AXIS_RIGHT), TRUE);
gtk_plot_x0_set_visible(GTK_PLOT(active_plot), TRUE);
gtk_plot_y0_set_visible(GTK_PLOT(active_plot), TRUE);
gtk_plot_grids_set_visible(GTK_PLOT(active_plot), TRUE, TRUE, TRUE, TRUE);
child = gtk_plot_canvas_plot_new(GTK_PLOT(active_plot));
gtk_plot_canvas_put_child(GTK_PLOT_CANVAS(canvas), child, .15, .06, .65, .31);
gtk_widget_show(active_plot);
build_example1(active_plot);
gtk_signal_connect(GTK_OBJECT(canvas), "select_item",
(GtkSignalFunc) select_item, NULL);
gtk_widget_show(window1);
gtk_plot_canvas_export_ps(GTK_PLOT_CANVAS(canvas), "demoflux.ps", 0, 0,
GTK_PLOT_LETTER);
gtk_main();
return(0);
}
/*********************************************
* AddReferenceImage関数 *
* 参考用画像の表示を追加 *
* 引数 *
* reference : 参考用画像表示ウィンドウの情報 *
* file_name : 追加するファイル名 *
* pixels : 画像のピクセルデータ *
* width : 画像の幅 *
* height : 画像の高さ *
* stride : 画像の1行分のバイト数 *
* channel : 画像のチャンネル数 *
*********************************************/
static void AddReferenceImage(
REFERENCE_WINDOW* reference,
const char* file_name,
uint8* pixels,
int width,
int height,
int stride,
int channel
)
{
GtkWidget *tab_label;
GtkWidget *alignment;
cairo_format_t format = (stride / width == 4) ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24;
REFERENCE_IMAGE *image;
image = reference->data->images[reference->data->num_image] =
(REFERENCE_IMAGE*)MEM_ALLOC_FUNC(sizeof(**reference->data->images));
image->pixels = pixels;
image->width = width;
image->height = height;
image->stride = stride;
image->channel = (uint8)channel;
image->surface_p = cairo_image_surface_create_for_data(image->pixels,
format, image->width, image->height, image->stride);
image->zoom = image->rev_zoom = 1;
image->app = reference->app;
image->draw_area = gtk_drawing_area_new();
gtk_widget_set_size_request(image->draw_area, image->width, image->height);
gtk_widget_set_events(image->draw_area, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
(void)g_signal_connect(G_OBJECT(image->draw_area), "destroy",
G_CALLBACK(OnDestroyReferenceImageDrawArea), image);
#if GTK_MAJOR_VERSION <= 2
(void)g_signal_connect(G_OBJECT(image->draw_area), "expose_event",
G_CALLBACK(DisplayReferenceImage), image);
#else
(void)g_signal_connect(G_OBJECT(image->draw_area), "draw",
G_CALLBACK(DisplayReferenceImage), image);
#endif
(void)g_signal_connect(G_OBJECT(image->draw_area), "button_press_event",
G_CALLBACK(ReferenceImageButtonPress), image);
alignment = gtk_alignment_new(0.5f, 0.5f, 0.0f, 0.0f);
gtk_container_add(GTK_CONTAINER(alignment), image->draw_area);
image->scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(image->scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(image->scroll), alignment);
tab_label = CreateNotebookLabel(file_name, reference->data->note_book, reference->data->num_image,
OnCloseReferenceImage, reference);
gtk_notebook_append_page(GTK_NOTEBOOK(reference->data->note_book), image->scroll, tab_label);
gtk_widget_show_all(image->scroll);
gtk_widget_set_sensitive(reference->data->scale, TRUE);
reference->data->active_image = reference->data->num_image;
#if GTK_MAJOR_VERSION <= 2
gtk_notebook_set_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image);
#else
gtk_notebook_set_current_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image);
#endif
reference->data->num_image++;
}
GtkWidget * create_layer_view_widget (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *hide_button;
GtkRcStyle *rcstyle; /* For hide_button */
GtkWidget *image; /* For hide_button */
GtkWidget *list;
GtkWidget *separator;
GtkWidget *scrolled_win;
GtkWidget *button_box;
/* if layer_dialog were renamed to layer_view_data this would make
* more sense.
*/
layer_dialog = g_new (struct LayerDialog, 1);
layer_dialog->diagram = NULL;
layer_dialog->dialog = vbox = gtk_vbox_new (FALSE, 1);
hbox = gtk_hbox_new (FALSE, 1);
label = gtk_label_new (_ ("Layers:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_widget_show (label);
layer_dialog->diagram_omenu = NULL;
/* Hide Button */
hide_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (hide_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (hide_button), FALSE);
/* make it as small as possible */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (hide_button, rcstyle);
g_object_unref (rcstyle);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER(hide_button), image);
gtk_signal_connect (GTK_OBJECT (hide_button), "clicked",
GTK_SIGNAL_FUNC (layer_view_hide_button_clicked), NULL);
gtk_box_pack_start (GTK_BOX (hbox), hide_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
gtk_widget_show_all (hbox);
button_box = create_button_box(vbox, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
gtk_widget_show (button_box);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 2);
gtk_widget_show (separator);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 2);
layer_dialog->layer_list = list = gtk_list_new();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
gtk_widget_show (scrolled_win);
gtk_widget_show (list);
g_signal_connect (GTK_OBJECT (list), "event",
(GtkSignalFunc) layer_list_events,
NULL);
return vbox;
}
int main( int argc,char *argv[] )
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget* menubar;
GtkWidget* main_toolbar;
GtkWidget* tools_toolbar;
GtkWidget* colortable;
GtkWidget* frame;
gtk_init (&argc, &argv);
modified=0;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Illuminati");
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (delete_event), NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
/*To create the menu bar*/
menubar = get_menubar_menu (window);
gtk_box_pack_start (GTK_BOX(vbox),menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
main_toolbar=get_main_toolbar();
/* to make it nice we'll put the toolbar into the handle box,
* so that it can be detached from the main window */
mainhandlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (vbox),mainhandlebox, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (mainhandlebox), main_toolbar);
gtk_widget_show (main_toolbar);
gtk_widget_show (mainhandlebox);
/*hbox for tools_toolbar and drawing area*/
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox),hbox, FALSE, FALSE, 0);
tools_toolbar=get_tools_toolbar();
toolhandlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX(hbox),toolhandlebox, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (toolhandlebox), tools_toolbar);
gtk_widget_show (tools_toolbar);
gtk_widget_show (toolhandlebox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (GTK_WIDGET (scrolled_win),400,400);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_win, TRUE, TRUE, 0);
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (drawing_area),800,600);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),drawing_area);
gtk_widget_show (drawing_area);
gtk_widget_show (scrolled_win);
gtk_widget_show (hbox);
/* Signals used to handle backing pixmap */
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
g_signal_connect (G_OBJECT (drawing_area),"configure_event",
G_CALLBACK (configure_event), NULL);
/* Event signals */
g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
G_CALLBACK (motion_notify_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
G_CALLBACK (button_press_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "button_release_event",
G_CALLBACK(button_release_event),NULL);
gtk_widget_set_events (drawing_area,GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_RELEASE_MASK);
hbox = gtk_hbox_new (FALSE,0);
gtk_box_pack_start(GTK_BOX (vbox),hbox, FALSE, FALSE, 2);
frame=get_fgbgframe();
gtk_box_pack_start(GTK_BOX (hbox),frame, FALSE, FALSE, 2);
gtk_widget_show(frame);
colortable=get_system_color_table();
frame=gtk_frame_new("select color");
gtk_widget_set_size_request (GTK_WIDGET (frame),400,75);
gtk_box_pack_start(GTK_BOX (hbox),frame, TRUE, TRUE, 2);
gtk_container_add(GTK_CONTAINER(frame),colortable);
gtk_widget_show (colortable);
gtk_widget_show(frame);
gtk_widget_show (hbox);
gtk_widget_show(vbox);
gtk_widget_show(window);
/*Initial tool set to PENCIL */
display=gdk_display_get_default();
cursor=gdk_cursor_new(GDK_PENCIL);
gdk_window_set_cursor(drawing_area->window,cursor);
tool=PENCIL;
gtk_button_set_relief(GTK_BUTTON(pencil_button),GTK_RELIEF_NORMAL);
filename=g_strdup("Untitled.jpeg");
pixmap = gdk_pixmap_new (drawing_area->window,
drawing_area->allocation.width,
drawing_area->allocation.height,
-1);
gdk_draw_rectangle (pixmap,
drawing_area->style->white_gc,
TRUE,
0, 0,
drawing_area->allocation.width,
drawing_area->allocation.height);
gtk_main ();
return 0;
}
void
create_layer_dialog(void)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *omenu;
GtkWidget *menu;
GtkWidget *list;
GtkWidget *separator;
GtkWidget *scrolled_win;
GtkWidget *button_box;
GtkWidget *button;
layer_dialog = g_new(struct LayerDialog, 1);
layer_dialog->diagram = NULL;
layer_dialog->dialog = dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), _("Layers"));
gtk_window_set_role (GTK_WINDOW (dialog), "layer_window");
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
g_signal_connect (GTK_OBJECT (dialog), "delete_event",
G_CALLBACK(layer_dialog_delete), NULL);
g_signal_connect (GTK_OBJECT (dialog), "destroy",
G_CALLBACK(gtk_widget_destroyed),
&(layer_dialog->dialog));
vbox = GTK_DIALOG(dialog)->vbox;
hbox = gtk_hbox_new(FALSE, 1);
label = gtk_label_new(_("Diagram:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
gtk_widget_show (label);
layer_dialog->diagram_omenu = omenu = gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 2);
gtk_widget_show (omenu);
menu = gtk_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(omenu), menu);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
gtk_widget_show (hbox);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 2);
gtk_widget_show (separator);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 2);
layer_dialog->layer_list = list = gtk_list_new();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
gtk_widget_show (scrolled_win);
gtk_widget_show (list);
g_signal_connect (GTK_OBJECT (list), "event",
(GtkSignalFunc) layer_list_events,
NULL);
button_box = create_button_box(dialog, TRUE);
gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
gtk_widget_show (button_box);
gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
2);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect_swapped(GTK_OBJECT (button), "clicked",
G_CALLBACK(gtk_widget_hide),
GTK_OBJECT(dialog));
gtk_widget_show (button);
persistence_register_window(GTK_WINDOW(dialog));
layer_dialog_update_diagram_list();
}
/*--------------------------- file chooser dialog ----------------------------*/
void video_tab(struct ALL_DATA *all_data)
{
struct GLOBAL *global = all_data->global;
struct vdIn *videoIn = all_data->videoIn;
struct GWIDGET *gwidget = all_data->gwidget;
//struct paRecordData *pdata = all_data->pdata;
GtkWidget *table2;
GtkWidget *scroll2;
GtkWidget *Tab2;
GtkWidget *Tab2Label;
GtkWidget *Tab2Icon;
GtkWidget *label_Device;
//GtkWidget *FrameRate;
GtkWidget *label_FPS;
GtkWidget *ShowFPS;
GtkWidget *labelResol;
GtkWidget *label_InpType;
GtkWidget *label_videoFilters;
GtkWidget *table_filt;
GtkWidget *FiltMirrorEnable;
GtkWidget *FiltUpturnEnable;
GtkWidget *FiltNegateEnable;
GtkWidget *FiltMonoEnable;
GtkWidget *FiltPiecesEnable;
GtkWidget *FiltParticlesEnable;
GtkWidget *set_jpeg_comp;
GtkWidget *label_jpeg_comp;
int line = 0;
int i = 0;
VidFormats *listVidFormats;
//TABLE
table2 = gtk_grid_new();
gtk_grid_set_column_homogeneous (GTK_GRID(table2), FALSE);
gtk_widget_set_hexpand (table2, TRUE);
gtk_widget_set_halign (table2, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID(table2), 4);
gtk_grid_set_column_spacing (GTK_GRID (table2), 4);
gtk_container_set_border_width (GTK_CONTAINER (table2), 2);
gtk_widget_show (table2);
//SCROLL
scroll2 = gtk_scrolled_window_new(NULL,NULL);
//ADD TABLE TO SCROLL
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll2),table2);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(scroll2), GTK_CORNER_TOP_LEFT);
gtk_widget_show(scroll2);
//new hbox for tab label and icon
Tab2 = gtk_grid_new();
Tab2Label = gtk_label_new(_("Video"));
gtk_widget_show (Tab2Label);
gchar* Tab2IconPath = g_strconcat (PACKAGE_DATA_DIR,"/pixmaps/guvcview/video_controls.png",NULL);
//don't test for file - use default empty image if load fails
//get icon image
Tab2Icon = gtk_image_new_from_file(Tab2IconPath);
g_free(Tab2IconPath);
gtk_widget_show (Tab2Icon);
gtk_grid_attach (GTK_GRID(Tab2), Tab2Icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(Tab2), Tab2Label, 1, 0, 1, 1);
gtk_widget_show (Tab2);
gtk_notebook_append_page(GTK_NOTEBOOK(gwidget->boxh),scroll2,Tab2);
//Devices
label_Device = gtk_label_new(_("Device:"));
gtk_misc_set_alignment (GTK_MISC (label_Device), 1, 0.5);
gtk_grid_attach (GTK_GRID(table2), label_Device, 0, line, 1, 1);
gtk_widget_show (label_Device);
gwidget->Devices = gtk_combo_box_text_new ();
gtk_widget_set_halign (gwidget->Devices, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gwidget->Devices, TRUE);
if (videoIn->listDevices->num_devices < 1)
{
//use current
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices),
videoIn->videodevice);
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),0);
}
else
{
for(i=0;i<(videoIn->listDevices->num_devices);i++)
{
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices),
videoIn->listDevices->listVidDevices[i].name);
if(videoIn->listDevices->listVidDevices[i].current)
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),i);
}
}
gtk_grid_attach (GTK_GRID(table2), gwidget->Devices, 1, line, 1 ,1);
gtk_widget_show (gwidget->Devices);
g_signal_connect (GTK_COMBO_BOX_TEXT(gwidget->Devices), "changed",
G_CALLBACK (Devices_changed), all_data);
// Resolution
gwidget->Resolution = gtk_combo_box_text_new ();
gtk_widget_set_halign (gwidget->Resolution, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gwidget->Resolution, TRUE);
char temp_str[20];
int defres=0;
{
int current_format = videoIn->listFormats->current_format;
listVidFormats = &videoIn->listFormats->listVidFormats[current_format];
}
if (global->debug)
g_print("resolutions of format(%d) = %d \n",
videoIn->listFormats->current_format+1,
listVidFormats->numb_res);
for(i = 0 ; i < listVidFormats->numb_res ; i++)
{
if (listVidFormats->listVidCap[i].width>0)
{
g_snprintf(temp_str,18,"%ix%i", listVidFormats->listVidCap[i].width,
listVidFormats->listVidCap[i].height);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Resolution),temp_str);
if ((global->width == listVidFormats->listVidCap[i].width) &&
(global->height == listVidFormats->listVidCap[i].height))
defres=i;//set selected resolution index
}
}
// Frame Rate
line++;
gwidget->FrameRate = gtk_combo_box_text_new ();
gtk_widget_set_halign (gwidget->FrameRate, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gwidget->FrameRate, TRUE);
int deffps=0;
if (global->debug)
g_print("frame rates of %dº resolution=%d \n",
defres+1,
listVidFormats->listVidCap[defres].numb_frates);
for ( i = 0 ; i < listVidFormats->listVidCap[defres].numb_frates ; i++)
{
g_snprintf(temp_str,18,"%i/%i fps", listVidFormats->listVidCap[defres].framerate_denom[i],
listVidFormats->listVidCap[defres].framerate_num[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->FrameRate),temp_str);
if (( global->fps_num == listVidFormats->listVidCap[defres].framerate_num[i]) &&
(global->fps == listVidFormats->listVidCap[defres].framerate_denom[i]))
deffps=i;//set selected
}
gtk_grid_attach (GTK_GRID(table2), gwidget->FrameRate, 1, line, 1 ,1);
gtk_widget_show (gwidget->FrameRate);
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->FrameRate),deffps);
if (deffps==0)
{
if (listVidFormats->listVidCap[defres].framerate_denom)
global->fps = listVidFormats->listVidCap[defres].framerate_denom[0];
if (listVidFormats->listVidCap[defres].framerate_num)
global->fps_num = listVidFormats->listVidCap[defres].framerate_num[0];
g_print("fps is set to %i/%i\n", global->fps_num, global->fps);
}
gtk_widget_set_sensitive (gwidget->FrameRate, TRUE);
g_signal_connect (GTK_COMBO_BOX_TEXT(gwidget->FrameRate), "changed",
G_CALLBACK (FrameRate_changed), all_data);
label_FPS = gtk_label_new(_("Frame Rate:"));
gtk_misc_set_alignment (GTK_MISC (label_FPS), 1, 0.5);
gtk_grid_attach (GTK_GRID(table2), label_FPS, 0, line, 1, 1);
gtk_widget_show (label_FPS);
ShowFPS=gtk_check_button_new_with_label (_(" Show"));
gtk_grid_attach (GTK_GRID(table2), ShowFPS, 2, line, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ShowFPS),(global->FpsCount > 0));
gtk_widget_show (ShowFPS);
g_signal_connect (GTK_CHECK_BUTTON(ShowFPS), "toggled",
G_CALLBACK (ShowFPS_changed), all_data);
// add resolution combo box
line++;
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Resolution),defres);
if(global->debug)
g_print("Def. Res: %i numb. fps:%i\n",defres,videoIn->listFormats->listVidFormats[videoIn->listFormats->current_format].listVidCap[defres].numb_frates);
gtk_grid_attach (GTK_GRID(table2), gwidget->Resolution, 1, line, 1 ,1);
gtk_widget_show (gwidget->Resolution);
gtk_widget_set_sensitive (gwidget->Resolution, TRUE);
g_signal_connect (gwidget->Resolution, "changed",
G_CALLBACK (resolution_changed), all_data);
labelResol = gtk_label_new(_("Resolution:"));
gtk_misc_set_alignment (GTK_MISC (labelResol), 1, 0.5);
gtk_grid_attach (GTK_GRID(table2), labelResol, 0, line, 1, 1);
gtk_widget_show (labelResol);
// Input Format
line++;
gwidget->InpType= gtk_combo_box_text_new ();
gtk_widget_set_halign (gwidget->InpType, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gwidget->InpType, TRUE);
int fmtind=0;
for (fmtind=0; fmtind < videoIn->listFormats->numb_formats; fmtind++)
{
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->InpType),videoIn->listFormats->listVidFormats[fmtind].fourcc);
if(global->format == videoIn->listFormats->listVidFormats[fmtind].format)
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->InpType),fmtind); /*set active*/
}
gtk_grid_attach (GTK_GRID(table2), gwidget->InpType, 1, line, 1 ,1);
gtk_widget_set_sensitive (gwidget->InpType, TRUE);
g_signal_connect (GTK_COMBO_BOX_TEXT(gwidget->InpType), "changed",
G_CALLBACK (InpType_changed), all_data);
gtk_widget_show (gwidget->InpType);
label_InpType = gtk_label_new(_("Camera Output:"));
gtk_misc_set_alignment (GTK_MISC (label_InpType), 1, 0.5);
gtk_grid_attach (GTK_GRID(table2), label_InpType, 0, line, 1, 1);
gtk_widget_show (label_InpType);
//jpeg compression quality for MJPEG and JPEG input formats
if((global->format == V4L2_PIX_FMT_MJPEG || global->format == V4L2_PIX_FMT_JPEG) && videoIn->jpgcomp.quality > 0)
{
line++;
gwidget->jpeg_comp = gtk_spin_button_new_with_range(0,100,1);
gtk_widget_set_halign (gwidget->jpeg_comp, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gwidget->jpeg_comp, TRUE);
/*can't edit the spin value by hand*/
gtk_editable_set_editable(GTK_EDITABLE(gwidget->jpeg_comp),FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(gwidget->jpeg_comp), videoIn->jpgcomp.quality);
gtk_grid_attach (GTK_GRID(table2), gwidget->jpeg_comp, 1, line, 1 ,1);
gtk_widget_set_sensitive (gwidget->jpeg_comp, TRUE);
gtk_widget_show (gwidget->jpeg_comp);
set_jpeg_comp = gtk_button_new_with_label(_("Apply"));
gtk_grid_attach (GTK_GRID(table2), set_jpeg_comp, 2, line, 1 ,1);
g_signal_connect (GTK_BUTTON (set_jpeg_comp), "clicked",
G_CALLBACK (set_jpeg_comp_clicked), all_data);
gtk_widget_set_sensitive (set_jpeg_comp, TRUE);
gtk_widget_show (set_jpeg_comp);
label_jpeg_comp = gtk_label_new(_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label_jpeg_comp), 1, 0.5);
gtk_grid_attach (GTK_GRID(table2), label_jpeg_comp, 0, line, 1 ,1);
gtk_widget_show (label_jpeg_comp);
}
// Filter controls
line++;
label_videoFilters = gtk_label_new(_("---- Video Filters ----"));
gtk_misc_set_alignment (GTK_MISC (label_videoFilters), 0.5, 0.5);
gtk_grid_attach (GTK_GRID(table2), label_videoFilters, 0, line, 3, 1);
gtk_widget_show (label_videoFilters);
line++;
table_filt = gtk_grid_new();
gtk_grid_set_row_spacing (GTK_GRID (table_filt), 4);
gtk_grid_set_column_spacing (GTK_GRID (table_filt), 4);
gtk_container_set_border_width (GTK_CONTAINER (table_filt), 4);
gtk_widget_set_size_request (table_filt, -1, -1);
gtk_widget_set_halign (table_filt, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (table_filt, TRUE);
gtk_grid_attach (GTK_GRID(table2), table_filt, 0, line, 3, 1);
gtk_widget_show (table_filt);
// Mirror
FiltMirrorEnable=gtk_check_button_new_with_label (_(" Mirror"));
g_object_set_data (G_OBJECT (FiltMirrorEnable), "filt_info", GINT_TO_POINTER(YUV_MIRROR));
gtk_widget_set_halign (FiltMirrorEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltMirrorEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltMirrorEnable, 0, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltMirrorEnable),(global->Frame_Flags & YUV_MIRROR)>0);
gtk_widget_show (FiltMirrorEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltMirrorEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
// Upturn
FiltUpturnEnable=gtk_check_button_new_with_label (_(" Invert"));
g_object_set_data (G_OBJECT (FiltUpturnEnable), "filt_info", GINT_TO_POINTER(YUV_UPTURN));
gtk_widget_set_halign (FiltUpturnEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltUpturnEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltUpturnEnable, 1, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltUpturnEnable),(global->Frame_Flags & YUV_UPTURN)>0);
gtk_widget_show (FiltUpturnEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltUpturnEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
// Negate
FiltNegateEnable=gtk_check_button_new_with_label (_(" Negative"));
g_object_set_data (G_OBJECT (FiltNegateEnable), "filt_info", GINT_TO_POINTER(YUV_NEGATE));
gtk_widget_set_halign (FiltNegateEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltNegateEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltNegateEnable, 2, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltNegateEnable),(global->Frame_Flags & YUV_NEGATE)>0);
gtk_widget_show (FiltNegateEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltNegateEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
// Mono
FiltMonoEnable=gtk_check_button_new_with_label (_(" Mono"));
g_object_set_data (G_OBJECT (FiltMonoEnable), "filt_info", GINT_TO_POINTER(YUV_MONOCR));
gtk_widget_set_halign (FiltMonoEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltMonoEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltMonoEnable, 3, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltMonoEnable),(global->Frame_Flags & YUV_MONOCR)>0);
gtk_widget_show (FiltMonoEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltMonoEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
// Pieces
FiltPiecesEnable=gtk_check_button_new_with_label (_(" Pieces"));
g_object_set_data (G_OBJECT (FiltPiecesEnable), "filt_info", GINT_TO_POINTER(YUV_PIECES));
gtk_widget_set_halign (FiltPiecesEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltPiecesEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltPiecesEnable, 4, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltPiecesEnable),(global->Frame_Flags & YUV_PIECES)>0);
gtk_widget_show (FiltPiecesEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltPiecesEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
// Particles
FiltParticlesEnable=gtk_check_button_new_with_label (_(" Particles"));
g_object_set_data (G_OBJECT (FiltParticlesEnable), "filt_info", GINT_TO_POINTER(YUV_PARTICLES));
gtk_widget_set_halign (FiltParticlesEnable, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (FiltParticlesEnable, TRUE);
gtk_grid_attach(GTK_GRID(table_filt), FiltParticlesEnable, 5, 0, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FiltParticlesEnable),(global->Frame_Flags & YUV_PARTICLES)>0);
gtk_widget_show (FiltParticlesEnable);
g_signal_connect (GTK_CHECK_BUTTON(FiltParticlesEnable), "toggled",
G_CALLBACK (FiltEnable_changed), all_data);
}
static void configuration_received_callback(bool_t res)
{
char labels[1024];
char values[1024];
int i,nb_values=0;
gdk_threads_enter();
PRINT("%s %s\n",__FILE__,__FUNCTION__);
GtkRcStyle *rc_style1,*rc_style2;
GdkColor color1,white;
color1.red=40000;
color1.blue=40000;
color1.green=65535;
color1.pixel=0;
rc_style1=gtk_rc_style_new();
// rc_style1->bg[GTK_STATE_NORMAL]=color1;
rc_style1->base[GTK_STATE_NORMAL]=color1;
// rc_style1->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BG;
rc_style1->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BASE;
white.red=0xffff;
white.blue=0xffff;
white.green=0xffff;
white.pixel=0;
rc_style2=gtk_rc_style_new();
//rc_style2->bg[GTK_STATE_NORMAL]=color2;
rc_style2->base[GTK_STATE_NORMAL]=white;
//rc_style2->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BG;
rc_style2->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BASE;
if (!GTK_IS_WIDGET(ihm_config.config_values_frame)) //{ gtk_widget_destroy(ihm_config.config_values_frame); ihm_config.config_values_frame = NULL; }
{
if (ihm_config.config_values!=NULL){ vp_os_free(ihm_config.config_values); ihm_config.config_values = NULL; }
ihm_config.config_values_frame = gtk_scrolled_window_new(NULL,NULL);
gtk_box_pack_start(GTK_BOX(ihm_config.config_frame_vbox),ihm_config.config_values_frame,TRUE, TRUE, 0);
ihm_config.config_values_hbox = gtk_hbox_new(FALSE,0);
ihm_config.config_values_vbox1 = gtk_vbox_new(FALSE,0);
ihm_config.config_values_vbox2 = gtk_vbox_new(FALSE,0);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW (ihm_config.config_values_frame),ihm_config.config_values_hbox);
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_hbox),ihm_config.config_values_vbox1,TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_hbox),ihm_config.config_values_vbox2,TRUE, TRUE, 0);
#define DISPLAY(KEY,NAME,C_TYPE,RW)\
ihm_config.config_values = vp_os_realloc(ihm_config.config_values,(nb_values+1)*sizeof(ihm_config_value_t)); \
sprintf(labels,"%s:%s",KEY,CFG_STRINGIFY(NAME)); \
ihm_config.config_values[nb_values].label = gtk_label_new(labels); \
ihm_config.config_values[nb_values].value = gtk_entry_new(); \
ihm_config.config_values[nb_values].hbox = gtk_hbox_new(FALSE,0); \
if ((RW)&K_WRITE) ihm_config.config_values[nb_values].send_button = gtk_button_new_with_label("send"); else ihm_config.config_values[nb_values].send_button=NULL; \
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_vbox1),ihm_config.config_values[nb_values].label,FALSE, FALSE, ((RW)&K_WRITE)?6:5);\
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_vbox2),ihm_config.config_values[nb_values].hbox,FALSE, FALSE, 0);\
gtk_box_pack_start(GTK_BOX(ihm_config.config_values[nb_values].hbox),ihm_config.config_values[nb_values].value,TRUE, TRUE, 0);\
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[nb_values].value),rc_style2); \
if (ihm_config.config_values[nb_values].send_button)\
{gtk_box_pack_start(GTK_BOX(ihm_config.config_values[nb_values].hbox),ihm_config.config_values[nb_values].send_button,FALSE, FALSE, 0);\
gtk_signal_connect(GTK_OBJECT(ihm_config.config_values[nb_values].send_button), "clicked", G_CALLBACK(set_configuration_callback), NULL);}\
nb_values++;
#undef ARDRONE_CONFIG_KEY_IMM
#undef ARDRONE_CONFIG_KEY_REF
#undef ARDRONE_CONFIG_KEY_STR
#define ARDRONE_CONFIG_KEY_IMM(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#define ARDRONE_CONFIG_KEY_REF(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#define ARDRONE_CONFIG_KEY_STR(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#include <config_keys.h>
}
//sprintf(labels,"%s:%s",STRINGIFY(abc),STRINGIFY(def));
// sprintf(values,PRINTF_KEY(C_TYPE)),get_##NAME());
//gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[nb_values].value) , values );
//sprintf(values,PRINTF_KEY(uint32_t),123);
i=0;
#define CONFIGURATION_GETTER(x) ardrone_control_config.x
#define ARDRONE_CONFIG_KEY_IMM(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
if(strcmp("" #INI_TYPE, "INI_FLOAT") == 0) { sprintf( values,"%f",(float)CONFIGURATION_GETTER(NAME)); } \
else if(strcmp("" #INI_TYPE, "INI_INT") == 0) { sprintf( values,"%d",(int)CONFIGURATION_GETTER(NAME)); } \
else if(strcmp("" #INI_TYPE, "INI_BOOLEAN") == 0) { sprintf( values,"%s",(CONFIGURATION_GETTER(NAME)) ? "TRUE" : "FALSE"); } \
if (strcmp(gtk_entry_get_text(GTK_ENTRY(ihm_config.config_values[i].value)),values)!=0) \
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style1); \
else gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style2); \
gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[i].value) , values );\
i++;
//PRINT(" Received parameter <%s:%s> with value <%f>\n",#KEY,#NAME,(float)CONFIGURATION_GETTER(NAME) );
#define ARDRONE_CONFIG_KEY_REF(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
i++;
#define ARDRONE_CONFIG_KEY_STR(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
if (strcmp(gtk_entry_get_text(GTK_ENTRY(ihm_config.config_values[i].value)),CONFIGURATION_GETTER(NAME))!=0) \
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style1); \
else gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style2); \
gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[i].value) , CONFIGURATION_GETTER(NAME) ); i++;
#include <config_keys.h>
ihm_config.nb_config_values = i;
gtk_widget_show_all(ihm_config.window);
gtk_rc_style_unref(rc_style1);
gtk_rc_style_unref(rc_style2);
gdk_threads_leave();
}
static void description_create(DescriptionWindow * dwindow)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *hbbox;
GtkWidget *ok_btn;
GtkWidget *scrolledwin;
int i;
int sz;
int line;
int j;
dwindow->window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_widget_set_usize(dwindow->window,400,450);
gtk_window_set_title(GTK_WINDOW(dwindow->window),
gettext(dwindow->title));
gtk_container_set_border_width(GTK_CONTAINER(dwindow->window), 8);
gtk_window_set_modal(GTK_WINDOW(dwindow->window), TRUE);
gtk_window_set_policy(GTK_WINDOW(dwindow->window), FALSE, TRUE, FALSE);
/* Check number of lines to be show */
sz = 0;
for (i = 0; dwindow->symbol_table[i] != NULL; i = i + dwindow->columns) {
sz++;
}
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwin);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(sz, dwindow->columns, FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolledwin), table);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
line = 0;
for(i = 0; dwindow->symbol_table[i] != NULL; i = i + dwindow->columns) {
if(dwindow->symbol_table[i][0] != '\0') {
GtkWidget *label;
for (j = 0; j < dwindow->columns; j++) {
gint col = j;
gint colend = j+1;
/* Expand using next NULL columns */
while ((colend < dwindow->columns) &&
(dwindow->symbol_table[i+colend] == NULL)) {
colend++;
j++;
}
label = gtk_label_new(gettext(dwindow->symbol_table[i+col]));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC(label), 0, 0);
gtk_table_attach(GTK_TABLE(table), label,
col, colend, line, line+1,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
}
} else {
GtkWidget *separator;
separator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table), separator,
0, dwindow->columns, line, line+1,
GTK_EXPAND | GTK_FILL, 0,
0, 4);
}
line++;
}
gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
NULL, NULL, NULL, NULL);
gtk_widget_show(hbbox);
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(dwindow->window), vbox);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scrolledwin),
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbbox),
FALSE, FALSE, 3);
/* OLD CODE
gtk_table_attach_defaults(GTK_TABLE(table), hbbox,
1, 2, i, i+1);
*/
gtk_widget_grab_default(ok_btn);
gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect
(GTK_OBJECT(dwindow->window), "key_press_event",
GTK_SIGNAL_FUNC(description_window_key_pressed),
NULL);
gtk_signal_connect(GTK_OBJECT(dwindow->window), "delete_event",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_widget_show_all(table);
}
static void
textures_switch_page (GtkNotebook *notebook, GtkWidget *page, guint page_num, const gchar *texture_path)
{
if (page_num == 0 || g_array_index (textures_timestamps, time_t, page_num) > 0)
return;
// fix gtk2
page = gtk_notebook_get_nth_page (notebook, page_num);
gtk_container_set_border_width (GTK_CONTAINER (page), 0);
gtk_widget_set_size_request (page, -1, 480);
const gchar *category = gtk_notebook_get_tab_label_text(notebook, page);
/* scrolled window */
GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (page), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
/* table */
gint rows = 5;
gint cols = 3;
GtkWidget *table = gtk_table_new (rows, cols, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
gtk_widget_show (table);
gint row = 1;
gint col = 1;
const gchar *gimp_dir = gimp_directory ();
const gchar *texture_dir = g_build_filename (gimp_dir, texture_path, NULL);
const gchar *path = g_build_filename (texture_dir, category, NULL);
GDir *dir = g_dir_open (path, 0, NULL);
if (dir)
{
const gchar *dir_ent;
while (dir_ent = g_dir_read_name (dir))
{
if (is_hidden (dir_ent))
continue;
gchar *filename = g_build_filename (path, dir_ent, NULL);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
pixbuf = gdk_pixbuf_scale_simple (pixbuf, THUMBNAIL_SIZE, THUMBNAIL_SIZE, GDK_INTERP_BILINEAR);
GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf);
GtkWidget *event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), image);
gtk_widget_show (image);
gtk_table_attach_defaults (GTK_TABLE (table), event_box, col - 1, col, row - 1, row);
gtk_widget_show (event_box);
col++;
if (col > cols)
{
row++;
col = 1;
}
g_signal_connect (event_box, "button_press_event", G_CALLBACK (custom_texture_press), filename);
}
}
g_array_index (textures_timestamps, time_t, page_num) = time (NULL);
}
int
main (int argc, char *argv[])
{
GtkWidget *win, *overlay, *grid, *main_child, *child, *label, *sw;
GdkRGBA color;
gchar *str;
gtk_init (&argc, &argv);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 600, 600);
grid = gtk_grid_new ();
child = gtk_event_box_new ();
gdk_rgba_parse (&color, "red");
gtk_widget_override_background_color (child, 0, &color);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_vexpand (child, TRUE);
gtk_container_add (GTK_CONTAINER (grid), child);
label = gtk_label_new ("Out of overlay");
gtk_container_add (GTK_CONTAINER (child), label);
overlay = gtk_overlay_new ();
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (overlay), sw);
main_child = gtk_event_box_new ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
main_child);
gdk_rgba_parse (&color, "green");
gtk_widget_override_background_color (main_child, 0, &color);
gtk_widget_set_hexpand (main_child, TRUE);
gtk_widget_set_vexpand (main_child, TRUE);
label = gtk_label_new ("Main child");
gtk_container_add (GTK_CONTAINER (main_child), label);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Bottom/Right child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Left/Top child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Right/Center child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
gtk_widget_set_margin_left (child, 55);
gtk_widget_set_margin_top (child, 4);
g_print ("Left/Top margined child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Custom get-child-position child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
g_signal_connect (overlay, "get-child-position",
G_CALLBACK (overlay_get_child_position), child);
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3);
gtk_container_add (GTK_CONTAINER (win), grid);
g_print ("\n");
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
static void
update_editor_sheet (EggToolbarEditor *editor)
{
GList *l;
GList *to_drag;
int x, y, height, width;
GtkWidget *table;
GtkWidget *viewport;
GtkWidget *item;
GtkWidget *icon;
g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));
viewport = GTK_BIN (editor->priv->scrolled_window)->child;
if (viewport)
{
table = GTK_BIN (viewport)->child;
gtk_container_remove (GTK_CONTAINER (viewport), table);
}
table = gtk_table_new (0, 0, TRUE);
editor->priv->table = table;
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_widget_show (table);
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);
gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,
dest_drag_types, n_dest_drag_types, GDK_ACTION_MOVE);
g_signal_connect (table, "drag_data_received",
G_CALLBACK (editor_drag_data_received_cb), editor);
to_drag = editor->priv->actions_list;
x = y = 0;
width = 4;
height = (g_list_length (to_drag)) / width + 1;
gtk_table_resize (GTK_TABLE (editor->priv->table), height, width);
for (l = to_drag; l != NULL; l = l->next)
{
GtkAction *action = (l->data);
const char *stock_id, *short_label;
GValue value = { 0, };
g_value_init (&value, G_TYPE_STRING);
g_object_get_property (G_OBJECT (action), "stock_id", &value);
stock_id = g_value_get_string (&value);
icon = gtk_image_new_from_stock
(stock_id ? stock_id : GTK_STOCK_DND,
GTK_ICON_SIZE_LARGE_TOOLBAR);
g_value_unset (&value);
g_value_init (&value, G_TYPE_STRING);
g_object_get_property (G_OBJECT (action), "short_label", &value);
short_label = g_value_get_string (&value);
item = editor_create_item (editor, GTK_IMAGE (icon),
short_label, GDK_ACTION_MOVE);
g_value_unset (&value);
g_object_set_data (G_OBJECT (item), "egg-action", action);
gtk_table_attach_defaults (GTK_TABLE (editor->priv->table),
item, x, x + 1, y, y + 1);
x++;
if (x >= width)
{
x = 0;
y++;
}
}
icon = _egg_editable_toolbar_new_separator_image ();
item = editor_create_item (editor, GTK_IMAGE (icon), _("Separator"),
GDK_ACTION_COPY);
gtk_table_attach_defaults (GTK_TABLE (editor->priv->table),
item, x, x + 1, y, y + 1);
}
static void
grub_choose_default_window_init (GrubChooseDefaultWindow *self)
{
GrubChooseDefaultWindowPrivate *priv = GET_PRIVATE (GRUB_CHOOSE_DEFAULT_WINDOW (self));
GtkWidget *scrolled;
GtkRequisition req, req_hbox;
GtkWidget *check_reboot;
GtkWidget *button_cancel, *button_help;
GtkWidget *hsep;
GtkWidget *vbox, *vbox_buttons, *hbox_radio, *hbox;
GtkWidget *radio_once, *radio_default;
#ifdef G_OS_WIN32
/* FIXME: doesn't seem to help much... buttons still don't have images in win32 */
g_object_set (gtk_settings_get_default (), "gtk-button-images", TRUE, NULL);
#endif
priv->config_fn = g_build_filename (g_get_user_config_dir (), "grub-choose-default", "config", NULL);
priv->config = g_key_file_new ();
gtk_window_set_icon_name (GTK_WINDOW (self), "grub-choose-default");
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, PADDING);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled);
priv->box = GRUB_CHOOSE_DEFAULT_WIDGET (grub_choose_default_button_box_new (priv->grub_dir));
g_signal_connect (priv->box, "selected", G_CALLBACK (handle_selected), self);
g_object_set (priv->box, "auto-commit", TRUE, NULL);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled), GTK_WIDGET (priv->box));
gtk_widget_show (GTK_WIDGET (priv->box));
vbox_buttons = gtk_vbox_new (FALSE, PADDING);
hbox_radio = gtk_hbox_new (FALSE, PADDING);
hbox = gtk_hbox_new (FALSE, PADDING);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, PADDING);
priv->button_help = button_help = gtk_button_new_from_stock (GTK_STOCK_HELP);
gtk_box_pack_start (GTK_BOX (hbox), button_help, FALSE, FALSE, 0);
g_signal_connect (button_help, "clicked", G_CALLBACK (handle_help), self);
priv->radio_default = radio_default = gtk_radio_button_new_with_label (NULL, "Set default");
gtk_widget_set_tooltip_markup (radio_default, "Use the boot entry selected above as the new default.");
priv->radio_once = radio_once = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_default),
"Next reboot only");
gtk_widget_set_tooltip_markup (radio_once, "Use the boot entry selected above as the default <b>once</b> for the next boot process.");
gtk_box_pack_start (GTK_BOX (hbox_radio), radio_default, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox_radio), radio_once, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox_buttons), hbox_radio, TRUE, TRUE, 0);
hsep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox_buttons), hsep, TRUE, TRUE, 0);
priv->check_reboot = check_reboot = gtk_check_button_new_with_label ("End session immediately");
gtk_widget_set_tooltip_markup (check_reboot, "If checked, end the session (e.g. show the logout menu) after selecting a boot entry above.");
gtk_box_pack_start (GTK_BOX (vbox_buttons), check_reboot, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox_buttons, TRUE, TRUE, 0);
button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_box_pack_start (GTK_BOX (hbox), button_cancel, FALSE, FALSE, 0);
g_signal_connect (button_cancel, "clicked", G_CALLBACK (handle_cancel), self);
gtk_widget_show_all (hbox);
gtk_widget_size_request (GTK_WIDGET (priv->box), &req);
gtk_widget_size_request (GTK_WIDGET (hbox), &req_hbox);
req.height += req_hbox.height + 6*PADDING;
req.width += 2*PADDING;
if (req.width > 600 )
req.width = 600;
if (req.height > 800)
req.height = 800;
DBG ("Will request size %d by %d", req.width, req.height);
gtk_window_set_default_size (GTK_WINDOW (self), req.width, req.height);
load_settings (self);
g_signal_connect (radio_default, "toggled", G_CALLBACK (handle_once), self);
g_signal_connect (radio_once, "toggled", G_CALLBACK (handle_once), self);
g_signal_connect (check_reboot, "toggled", G_CALLBACK (handle_reboot), self);
g_signal_connect (self, "delete-event", G_CALLBACK (handle_delete), NULL);
gtk_widget_show (vbox);
}
static void description_create(DescriptionWindow * dwindow)
{
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *hbbox;
GtkWidget *close_btn;
GtkWidget *scrolledwin;
int i;
int sz;
int line;
int j;
int *max_width = g_new0(int, dwindow->columns), width=0;
GtkRequisition req;
dwindow->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "description_window");
gtk_window_set_title(GTK_WINDOW(dwindow->window),
gettext(dwindow->title));
gtk_container_set_border_width(GTK_CONTAINER(dwindow->window), 8);
gtk_window_set_resizable(GTK_WINDOW(dwindow->window), TRUE);
/* Check number of lines to be show */
sz = 0;
for (i = 0; dwindow->symbol_table[i] != NULL; i = i + dwindow->columns) {
sz++;
}
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(sz, dwindow->columns, FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolledwin), table);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
line = 0;
for(i = 0; dwindow->symbol_table[i] != NULL; i = i + dwindow->columns) {
if(dwindow->symbol_table[i][0] != '\0') {
GtkWidget *label;
for (j = 0; j < dwindow->columns; j++) {
gint col = j;
gint colend = j+1;
/* Expand using next NULL columns */
while ((colend < dwindow->columns) &&
(dwindow->symbol_table[i+colend] == NULL)) {
colend++;
j++;
}
label = gtk_label_new(gettext(dwindow->symbol_table[i+col]));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC(label), 0, 0);
gtk_table_attach(GTK_TABLE(table), label,
col, colend, line, line+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 2);
gtk_widget_size_request(label, &req);
if(req.width > max_width[j])
max_width[j] = req.width;
}
} else {
GtkWidget *separator;
separator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table), separator,
0, dwindow->columns, line, line+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 4);
}
line++;
}
for(j=0; j<dwindow->columns; j++)
width += max_width[j];
g_free(max_width);
width += 100;
gtkut_stock_button_set_create(&hbbox, &close_btn, GTK_STOCK_CLOSE,
NULL, NULL, NULL, NULL);
vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
gtk_container_add(GTK_CONTAINER(dwindow->window), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(gettext(dwindow->description));
gtk_widget_set_size_request(GTK_WIDGET(label), width-2, -1);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scrolledwin),
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbbox),
FALSE, FALSE, 3);
gtk_widget_grab_default(close_btn);
g_signal_connect(G_OBJECT(close_btn), "clicked",
G_CALLBACK(description_window_destroy), dwindow);
g_signal_connect(G_OBJECT(dwindow->window), "key_press_event",
G_CALLBACK(description_window_key_pressed), dwindow);
g_signal_connect(G_OBJECT(dwindow->window), "focus_in_event",
G_CALLBACK(description_window_focus_in_event), NULL);
g_signal_connect(G_OBJECT(dwindow->window), "focus_out_event",
G_CALLBACK(description_window_focus_out_event), NULL);
g_signal_connect(G_OBJECT(dwindow->window), "delete_event",
G_CALLBACK(description_window_destroy), dwindow);
if(dwindow->parent)
g_signal_connect(G_OBJECT(dwindow->parent), "hide",
G_CALLBACK(description_window_destroy), dwindow);
gtk_widget_show_all(vbox);
gtk_widget_set_size_request(dwindow->window,
(width < 400) ? 400 : width, 450);
}
