void
pevent_dialog_show ()
{
GtkWidget *vbox, *hbox, *tbox, *wid, *bh, *th;
GtkListStore *store, *hstore;
GtkTreeSelection *sel;
if (pevent_dialog)
{
mg_bring_tofront (pevent_dialog);
return;
}
pevent_dialog =
mg_create_generic_tab ("edit events", _("Edit Events"),
TRUE, FALSE, pevent_dialog_close, NULL,
600, 455, &vbox, 0);
wid = gtk_vpaned_new ();
th = gtk_vbox_new (0, 2);
bh = gtk_vbox_new (0, 2);
gtk_widget_show (th);
gtk_widget_show (bh);
gtk_paned_pack1 (GTK_PANED (wid), th, 1, 1);
gtk_paned_pack2 (GTK_PANED (wid), bh, 0, 1);
gtk_box_pack_start (GTK_BOX (vbox), wid, 1, 1, 0);
gtk_widget_show (wid);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_INT);
pevent_dialog_list = gtkutil_treeview_new (th, GTK_TREE_MODEL (store), NULL,
COL_EVENT_NAME, _("Event"),
COL_EVENT_TEXT, _("Text"), -1);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (pevent_dialog_list));
g_signal_connect (G_OBJECT (sel), "changed",
G_CALLBACK (pevent_dialog_select), store);
pevent_dialog_twid = gtk_xtext_new (colors, 0);
gtk_xtext_set_tint (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_tint_red, prefs.hex_text_tint_green, prefs.hex_text_tint_blue);
gtk_xtext_set_background (GTK_XTEXT (pevent_dialog_twid),
channelwin_pix, prefs.hex_text_transparent);
pevent_dialog_entry = gtk_entry_new_with_max_length (255);
g_signal_connect (G_OBJECT (pevent_dialog_entry), "activate",
G_CALLBACK (pevent_dialog_update), pevent_dialog_twid);
gtk_box_pack_start (GTK_BOX (bh), pevent_dialog_entry, 0, 0, 0);
gtk_widget_show (pevent_dialog_entry);
tbox = gtk_hbox_new (0, 0);
gtk_container_add (GTK_CONTAINER (bh), tbox);
gtk_widget_show (tbox);
gtk_widget_set_usize (pevent_dialog_twid, 150, 20);
gtk_container_add (GTK_CONTAINER (tbox), pevent_dialog_twid);
gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font);
wid = gtk_vscrollbar_new (GTK_XTEXT (pevent_dialog_twid)->adj);
gtk_box_pack_start (GTK_BOX (tbox), wid, FALSE, FALSE, 0);
show_and_unfocus (wid);
gtk_widget_show (pevent_dialog_twid);
hstore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
pevent_dialog_hlist = gtkutil_treeview_new (bh, GTK_TREE_MODEL (hstore),
NULL,
0, _("$ Number"),
1, _("Description"), -1);
gtk_widget_show (pevent_dialog_hlist);
pevent_dialog_fill (pevent_dialog_list);
gtk_widget_show (pevent_dialog_list);
hbox = gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 2);
/*wid = gtk_button_new_with_label (_("Save"));
gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_signal_connect (GTK_OBJECT (wid), "clicked",
GTK_SIGNAL_FUNC (pevent_save_cb), NULL);
gtk_widget_show (wid);*/
gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, pevent_save_cb,
(void *) 1, _("Save As..."));
gtkutil_button (hbox, GTK_STOCK_OPEN, NULL, pevent_load_cb,
(void *) 0, _("Load From..."));
wid = gtk_button_new_with_label (_("Test All"));
gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0);
g_signal_connect (G_OBJECT (wid), "clicked",
G_CALLBACK (pevent_test_cb), pevent_dialog_twid);
gtk_widget_show (wid);
wid = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
g_signal_connect (G_OBJECT (wid), "clicked",
G_CALLBACK (pevent_ok_cb), NULL);
gtk_widget_show (wid);
gtk_widget_show (hbox);
gtk_widget_show (pevent_dialog);
}
int main(int argc,char**argv)
{
gtk_init(&argc,&argv);
GtkWidget*win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(win,TRUE);
gtk_widget_set_size_request(win,400,400);
GtkWidget*vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
GtkWidget*hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
widget0=gtk_button_new_with_label("BuTToN0");
widget1=gtk_button_new_with_label("BuTToN11");
widget2=gtk_entry_new();
widget3=gtk_text_view_new();
gtk_widget_set_size_request(widget3,100,100);
GtkWidget*button1=gtk_button_new_with_label("Resize");
GtkWidget*button2=gtk_button_new_with_label("Frozen?");
GtkWidget*button3=gtk_button_new_with_label("Active?");
GtkWidget*button4=gtk_button_new_with_label("Remove");
GtkWidget*button5=gtk_button_new_with_label("HWNDS");
GtkWidget*button6=gtk_button_new_with_label("REOrder");
GtkWidget* fb=float_border_new(FALSE,TRUE);
g_message("FloatBorder::%x::",fb);
gtk_box_pack_start(GTK_BOX(hbox),button1,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),button2,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),button3,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),button4,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),button5,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),button6,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(vbox),fb,TRUE,TRUE,5);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
gtk_container_add(GTK_CONTAINER(win),vbox);
float_border_put(FLOAT_BORDER(fb),widget0,100,100);
float_border_put_with_size(FLOAT_BORDER(fb),widget1,150,300,200,200);
float_border_put(FLOAT_BORDER(fb),widget2,300,100);
float_border_put(FLOAT_BORDER(fb),widget3,200,80);
GdkRGBA trans={0,0,0,0};
gtk_widget_override_background_color(widget3,0,&trans);
g_signal_connect(G_OBJECT(win),"draw",G_CALLBACK(win_draw),NULL);
g_signal_connect(G_OBJECT(button1),"clicked",G_CALLBACK(resize_cb),fb);
g_signal_connect(G_OBJECT(button2),"clicked",G_CALLBACK(print_cb),fb);
g_signal_connect(G_OBJECT(button3),"clicked",G_CALLBACK(setact_cb),fb);
g_signal_connect(G_OBJECT(button4),"clicked",G_CALLBACK(remove_cb),fb);
g_signal_connect(G_OBJECT(button5),"clicked",G_CALLBACK(sethwnds_cb),fb);
g_signal_connect(G_OBJECT(button6),"clicked",G_CALLBACK(setorder_cb),fb);
// float_border_set_hwnds(fb,entry,HWND_MOVE,HWND_BR_RESIZE,NULL);
gtk_widget_show_all(win);
gtk_main();
return 0;
}
static void create_main_win()
{
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (hime_setup_window_type_utility)
gtk_window_set_type_hint(GTK_WINDOW(main_window), GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
g_signal_connect (G_OBJECT (main_window), "delete_event",
G_CALLBACK (close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (main_window), _("hime 設定/工具"));
set_window_hime_icon(main_window);
gtk_window_set_resizable (GTK_WINDOW (main_window), FALSE);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
#ifdef USE_WIDE
GtkWidget *box = gtk_hbox_new (TRUE, 0);
gtk_container_add (GTK_CONTAINER (main_window), box);
gtk_box_pack_start (GTK_BOX (box), vbox, TRUE, TRUE, 0);
GtkWidget *button_default_input_method1 = gtk_button_new_with_label(_("開啟/關閉/預設輸入法"));
gtk_box_pack_start (GTK_BOX (vbox), button_default_input_method1, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_default_input_method1), "clicked",
G_CALLBACK (create_gtablist_window), GINT_TO_POINTER(1));
GtkWidget *button_default_input_method2 = gtk_button_new_with_label(_("輸入法伺服器"));
gtk_box_pack_start (GTK_BOX (vbox), button_default_input_method2, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_default_input_method2), "clicked",
G_CALLBACK (create_gtablist_window), GINT_TO_POINTER(2));
#else
gtk_container_add (GTK_CONTAINER (main_window), vbox);
GtkWidget *button_default_input_method = gtk_button_new_with_label(_("開啟/關閉/預設輸入法"));
gtk_box_pack_start (GTK_BOX (vbox), button_default_input_method, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_default_input_method), "clicked",
G_CALLBACK (create_gtablist_window), GINT_TO_POINTER(0));
#endif
GtkWidget *button_appearance_conf = gtk_button_new_with_label(_("外觀設定"));
gtk_box_pack_start (GTK_BOX (vbox), button_appearance_conf, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_appearance_conf), "clicked",
G_CALLBACK (cb_appearance_conf), NULL);
GtkWidget *button_kbm = gtk_button_new_with_label(_("注音/詞音/拼音設定"));
gtk_box_pack_start (GTK_BOX (vbox), button_kbm, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_kbm), "clicked",
G_CALLBACK (cb_kbm), NULL);
#ifdef USE_WIDE
GtkWidget *button_gtab_conf = gtk_button_new_with_label(_("倉頡/行列/大易 外觀設定"));
gtk_box_pack_start (GTK_BOX (vbox), button_gtab_conf, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_gtab_conf), "clicked",
G_CALLBACK (create_gtab_conf_window), GINT_TO_POINTER(1));
button_gtab_conf = gtk_button_new_with_label(_("倉頡/行列/大易 行為設定"));
gtk_box_pack_start (GTK_BOX (vbox), button_gtab_conf, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_gtab_conf), "clicked",
G_CALLBACK (create_gtab_conf_window), GINT_TO_POINTER(2));
#else
GtkWidget *button_gtab_conf = gtk_button_new_with_label(_("倉頡/行列/大易設定"));
gtk_box_pack_start (GTK_BOX (vbox), button_gtab_conf, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_gtab_conf), "clicked",
G_CALLBACK (create_gtab_conf_window), GINT_TO_POINTER(0));
#endif
#ifdef USE_WIDE
vbox = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (box), vbox, TRUE, TRUE, 0);
#endif
GtkWidget *button_alt_shift = gtk_button_new_with_label(_("alt-shift 片語編輯"));
gtk_box_pack_start (GTK_BOX (vbox), button_alt_shift, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_alt_shift), "clicked",
G_CALLBACK (cb_alt_shift), NULL);
GtkWidget *button_symbol_table = gtk_button_new_with_label(_("符號表編輯"));
gtk_box_pack_start (GTK_BOX (vbox), button_symbol_table, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_symbol_table), "clicked",
G_CALLBACK (cb_symbol_table), NULL);
#if !USE_WIDE
if (!hime_status_tray)
{
#endif
GtkWidget *button_gb_output_toggle = gtk_button_new_with_label(_("啟用/關閉簡體字輸出"));
gtk_box_pack_start (GTK_BOX (vbox), button_gb_output_toggle, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_gb_output_toggle), "clicked",
G_CALLBACK (cb_gb_output_toggle), NULL);
void kbm_open_close(GtkButton *checkmenuitem, gboolean b_show);
GtkWidget *button_win_kbm_toggle = gtk_button_new_with_label(_("顯示/隱藏輸入法鍵盤"));
gtk_box_pack_start (GTK_BOX (vbox), button_win_kbm_toggle, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_win_kbm_toggle), "clicked",
G_CALLBACK (cb_win_kbm_toggle), NULL);
#if !USE_WIDE
}
#endif
GtkWidget *button_gb_translate_toggle = gtk_button_new_with_label(_("剪貼區 簡體字->正體字"));
gtk_box_pack_start (GTK_BOX (vbox), button_gb_translate_toggle, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_gb_translate_toggle), "clicked",
G_CALLBACK (cb_gb_translate_toggle), NULL);
GtkWidget *button_juying_learn_toggle = gtk_button_new_with_label(_("剪貼區 注音查詢"));
gtk_box_pack_start (GTK_BOX (vbox), button_juying_learn_toggle, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_juying_learn_toggle), "clicked",
G_CALLBACK (cb_juying_learn), NULL);
#ifdef USE_WIDE
vbox = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (box), vbox, TRUE, TRUE, 0);
#endif
GtkWidget *expander_ts;
GtkWidget *vbox_ts;
#ifdef USE_WIDE
vbox_ts = vbox;
#else
expander_ts = gtk_expander_new (_("詞庫選項"));
gtk_box_pack_start (GTK_BOX (vbox), expander_ts, FALSE, FALSE, 0);
vbox_ts = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_ts), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (expander_ts), vbox_ts);
#endif
GtkWidget *button_ts_export = gtk_button_new_with_label(_("詞庫匯出"));
gtk_widget_set_hexpand (button_ts_export, TRUE);
gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_export, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_ts_export), "clicked",
G_CALLBACK (cb_ts_export), NULL);
GtkWidget *button_ts_import = gtk_button_new_with_label(_("詞庫匯入"));
gtk_widget_set_hexpand (button_ts_import, TRUE);
gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_import, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_ts_import), "clicked",
G_CALLBACK (cb_ts_import), NULL);
GtkWidget *button_ts_edit = gtk_button_new_with_label(_("詞庫編輯"));
gtk_widget_set_hexpand (button_ts_edit, TRUE);
gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_ts_edit), "clicked",
G_CALLBACK (cb_ts_edit), NULL);
GtkWidget *button_hime_tslearn = gtk_button_new_with_label(_("從文章學習詞"));
gtk_box_pack_start (GTK_BOX (vbox_ts), button_hime_tslearn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_hime_tslearn), "clicked",
G_CALLBACK (cb_tslearn), NULL);
GtkWidget *button_ts_import_sys = gtk_button_new_with_label(_("匯入系統的詞庫"));
gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_import_sys, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_ts_import_sys), "clicked",
G_CALLBACK (cb_ts_import_sys), NULL);
gboolean show_about=TRUE;
int i;
for (i=0; i < inmdN; i++) {
INMD *pinmd = &inmd[i];
if (pinmd->method_type != method_type_MODULE || pinmd->disabled)
continue;
HIME_module_callback_functions *f = init_HIME_module_callback_functions(pinmd->filename);
if (!f)
continue;
if (!f->module_setup_window_create) {
free(f);
continue;
}
char tt[128];
strcpy(tt, pinmd->cname);
strcat(tt, _("設定"));
GtkWidget *button_module_input_method = gtk_button_new_with_label(tt);
gtk_box_pack_start (GTK_BOX (vbox), button_module_input_method, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_module_input_method), "clicked",
G_CALLBACK (f->module_setup_window_create), GINT_TO_POINTER(hime_setup_window_type_utility));
#ifdef USE_WIDE
show_about=FALSE;
#endif
}
if (show_about)
{
GtkWidget *button_about = gtk_button_new_from_stock (GTK_STOCK_ABOUT);
gtk_box_pack_start (GTK_BOX (vbox), button_about, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_about), "clicked",
G_CALLBACK (create_about_window), NULL);
}
#if !USE_WIDE
GtkWidget *button_quit = gtk_button_new_from_stock (GTK_STOCK_QUIT);
gtk_box_pack_start (GTK_BOX (vbox), button_quit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_quit), "clicked",
G_CALLBACK (close_application), NULL);
#endif
gtk_widget_show_all(main_window);
}
// Creation de l'application FiguRE
void FIGUREGUI_create_app()
{
guchar * txt = NULL;
gint i;
ptr_window = (Window*) g_malloc(sizeof(Window));
/* Création de la fenêtre */
ptr_window->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(ptr_window->win), WTITLE);
gtk_window_set_icon_from_file(GTK_WINDOW(ptr_window->win),WICON,NULL);
gtk_window_set_default_size(GTK_WINDOW(ptr_window->win), WWIDTH, WHEIGHT);
gtk_window_set_resizable(GTK_WINDOW(ptr_window->win),FALSE);
gtk_window_set_position(GTK_WINDOW(ptr_window->win),GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(ptr_window->win),"delete-event", G_CALLBACK(window_quitte),NULL);
/* vbox qui contiendra notre interface */
ptr_window->vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(ptr_window->win), ptr_window->vbox);
/* barre menu */
window_barre_menu();
gtk_box_pack_start(GTK_BOX(ptr_window->vbox), ptr_window->menu_bar, FALSE, TRUE, 0);
/* barre d'outils */
window_barre_outils();
gtk_box_pack_start(GTK_BOX(ptr_window->vbox), ptr_window->toolbar, FALSE, TRUE, 0);
/* Création de la barre de progression */
ptr_window->progress_bar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(ptr_window->vbox), ptr_window->progress_bar);
// HBOX : contiendra les 2 cadres apprentissage et reconnaissance
ptr_window->hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(ptr_window->vbox), ptr_window->hbox, TRUE, TRUE, 0);
ptr_window->draw = gtk_frame_new("Zone d'ecriture");
gtk_frame_set_shadow_type(GTK_FRAME(ptr_window->draw), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox), ptr_window->draw, TRUE, TRUE, 0);
ptr_window->result = gtk_frame_new("Informations");
gtk_frame_set_shadow_type(GTK_FRAME(ptr_window->result), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox), ptr_window->result, FALSE, TRUE, 0);
//
ptr_window->infos_txt = gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(ptr_window->result),ptr_window->infos_txt);
maj_infos();
/* On crée la zone de dessin 256x256 */
creation_zone_dessin();
/* Creation buffer pre-traitement */
creation_buffer_pretraitement();
/* Creation de la zone de saisie */
ptr_window->hbox_saisie = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(ptr_window->vbox), ptr_window->hbox_saisie, TRUE, TRUE, 0);
ptr_window->lbl_saisie_chiffre = gtk_label_new("Chiffre : ");
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->lbl_saisie_chiffre, FALSE, TRUE, 0);
ptr_window->saisie_chiffre = gtk_spin_button_new_with_range(0,9,1);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->saisie_chiffre, FALSE, TRUE, 0);
ptr_window->lbl_saisie_pas = gtk_label_new(" Pas d'apprentissage : ");
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->lbl_saisie_pas, FALSE, TRUE, 0);
ptr_window->saisie_pas = gtk_spin_button_new_with_range(0,1,0.1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(ptr_window->saisie_pas),0.7);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->saisie_pas, FALSE, TRUE, 0);
ptr_window->lbl_saisie_period = gtk_label_new(" Periodes : ");
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->lbl_saisie_period, FALSE, TRUE, 0);
ptr_window->saisie_period = gtk_spin_button_new_with_range(100,100000,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(ptr_window->saisie_period),10000.0);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_saisie), ptr_window->saisie_period, FALSE, TRUE, 0);
/* Création des boutons */
ptr_window->hbox_btn = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(ptr_window->vbox), ptr_window->hbox_btn, TRUE, TRUE, 0);
ptr_window->btn_aj = gtk_button_new_with_label("Ajouter l'exemple");
g_signal_connect(G_OBJECT(ptr_window->btn_aj), "clicked", G_CALLBACK(ajouter_un_exemple), NULL);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_btn), ptr_window->btn_aj, FALSE, TRUE, 0);
ptr_window->btn_del = gtk_button_new_with_label("Effacer le dessin");
g_signal_connect(G_OBJECT(ptr_window->btn_del), "clicked", G_CALLBACK(zone_dessin_effacer), NULL);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_btn), ptr_window->btn_del, FALSE, TRUE, 0);
ptr_window->btn_app = gtk_button_new_with_label("Lancer l'apprentissage");
g_signal_connect(G_OBJECT(ptr_window->btn_app), "clicked", G_CALLBACK(lancer_apprentissage), NULL);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_btn), ptr_window->btn_app, FALSE, TRUE, 0);
ptr_window->btn_ana = gtk_button_new_with_label("Reconnaitre le chiffre");
g_signal_connect(G_OBJECT(ptr_window->btn_ana), "clicked", G_CALLBACK(reconnaitre_chiffre), NULL);
gtk_box_pack_start(GTK_BOX(ptr_window->hbox_btn), ptr_window->btn_ana, FALSE, TRUE, 0);
/* Affiche tout */
gtk_widget_show_all(ptr_window->win);
/* Creation du perceptron de 16x16 = 256 entrées avec 10 neurones*/
pm = PERCEPTRONMONO_new(10,256);
}
static void prefs_show_scores_real (int index)
{
int i, j;
gchar tempstr [128], tempstr1[128];
time_t temps;
GtkWidget *dialog, *okay_button, *label, *hbox, *vboxes[5];
snprintf (tempstr, 128, "%s highscores - gtkboard", gamename);
#if GTK_MAJOR_VERSION == 1
dialog = gtk_dialog_new();
gtk_window_set_title (GTK_WINDOW (dialog), tempstr);
okay_button = gtk_button_new_with_label("OK");
gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
okay_button);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 5);
snprintf (tempstr, 128, "%s highscores", gamename);
label = gtk_label_new (tempstr);
#else
dialog = gtk_dialog_new_with_buttons (tempstr, GTK_WINDOW (main_window),
GTK_DIALOG_MODAL, NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 100);
okay_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK, GTK_RESPONSE_NONE);
g_signal_connect_swapped (GTK_OBJECT (dialog),
"response", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT (dialog));
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 5);
snprintf (tempstr, 128, "<big>%s highscores</big>", gamename);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), tempstr);
#endif
gtk_widget_grab_focus (okay_button);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
hbox = gtk_hbox_new (FALSE, 20);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), hbox);
for (i=0; i<=num_highscores; i++)
{
int num_score_fields;
gchar *strings[10];
gboolean found = FALSE;
for (j=0; !found && j < 10; j++)
{
switch (game_score_fields[j])
{
case SCORE_FIELD_NONE: found = TRUE; break;
case SCORE_FIELD_RANK:
snprintf (tempstr, 128, "%d", i);
strings[j] = i ? tempstr : game_score_field_names[j];
break;
case SCORE_FIELD_USER:
strings[j] = i ? scores[i-1].name : game_score_field_names[j];
break;
case SCORE_FIELD_SCORE:
strings[j] = i ? scores[i-1].score : game_score_field_names[j];
break;
case SCORE_FIELD_TIME:
strings[j] = i ? sb_ftime (scores[i-1].time) : game_score_field_names[j];
break;
case SCORE_FIELD_DATE:
temps = scores[i-1].date;
strncpy (tempstr1, ctime (&temps), 127);
tempstr1 [strlen (tempstr1) - 1] = '\0';
strings[j] = i ? tempstr1 : game_score_field_names[j];
break;
default:
break;
}
}
num_score_fields = j-1;
for (j=0; j<num_score_fields; j++)
{
if (i == 0)
{
vboxes[j] = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vboxes[j], TRUE, TRUE, 0);
}
label = gtk_label_new ("");
#if GTK_MAJOR_VERSION > 1
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
if (i > 0 && i-1 == index)
{
gchar *tempstr = g_strdup_printf
("<span foreground=\"blue\">%s</span>", strings[j]);
gtk_label_set_markup (GTK_LABEL (label), tempstr);
g_free (tempstr);
}
else
#endif
gtk_label_set_text (GTK_LABEL (label), strings[j]);
gtk_box_pack_start (GTK_BOX (vboxes[j]), label, FALSE, FALSE,
i ? 0 : 5);
}
}
gtk_widget_show_all (dialog);
}
gint layer_node_selected (gpointer host, GeglEditor* editor, gint node_id)
{
GeglEditorLayer* self = (GeglEditorLayer*)host;
GeglNode* node = NULL;
GSList* pair = self->pairs;
for(;pair != NULL; pair = pair->next)
{
node_id_pair* data = pair->data;
if(data->id == node_id)
{
node = data->node;
break;
}
}
g_assert(node != NULL);
GeglNode** nodes;
const gchar** pads;
gint num = gegl_node_get_consumers(node, "output", &nodes, &pads);
int i;
g_print("%s: %d consumer(s)\n", gegl_node_get_operation(node), num);
for(i = 0; i < num; i++)
{
g_print("Connection: (%s to %s)\n", gegl_node_get_operation(node), gegl_node_get_operation(nodes[0]), pads[0]);
}
g_print("Input from: %s\n", gegl_node_get_operation(gegl_node_get_producer(node, "input", NULL)));
// g_print("selected: %s\n", gegl_node_get_operation(node));
guint n_props;
GParamSpec** properties = gegl_operation_list_properties(gegl_node_get_operation(node), &n_props);
//TODO: only create enough columns for the properties which will actually be included (i.e. ignoring GeglBuffer props)
GtkTable *prop_table = GTK_TABLE(gtk_table_new(2, n_props, FALSE));
int d;
for(d = 0, i = 0; i < n_props; i++, d++)
{
GParamSpec* prop = properties[i];
GType type = prop->value_type;
const gchar* name = prop->name;
GtkWidget* name_label = gtk_label_new(name);
gtk_misc_set_alignment(GTK_MISC(name_label), 0, 0.5);
GtkWidget* value_entry = gtk_entry_new();
gchar buf[256] = "*"; //can probably be smaller; In fact, can probably do this without sprintf and a buffer. TODO: look at g_string
gint i_value;
gdouble d_value;
gchar* str_value;
gboolean skip = FALSE;
switch(type)
{
case G_TYPE_INT:
gegl_node_get(node, name, &i_value, NULL);
sprintf(buf, "%d", i_value);
break;
case G_TYPE_DOUBLE:
gegl_node_get(node, name, &d_value, NULL);
sprintf(buf, "%.3f", d_value);
break;
case G_TYPE_STRING:
gegl_node_get(node, name, &str_value, NULL);
sprintf(buf, "%s", str_value);
break;
}
if(type == GEGL_TYPE_BUFFER) {
skip = TRUE;
d--;
} else if( type == GEGL_TYPE_COLOR) {
skip = TRUE;
GtkWidget *color_button = gtk_button_new_with_label("Select");
select_color_info* info = malloc(sizeof(select_color_info));
info->node = node;
info->property = name;
info->layer = self;
g_signal_connect(color_button, "clicked", (GCallback)select_color, info);
gtk_table_attach(prop_table, name_label, 0, 1, d, d+1, GTK_FILL, GTK_FILL, 1, 1);
gtk_table_attach(prop_table, color_button, 1, 2, d, d+1, GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 1, 1);
}
if(!skip)
{
gtk_entry_set_text(GTK_ENTRY(value_entry), buf);
gtk_entry_set_width_chars(GTK_ENTRY(value_entry), 2);
struct text_prop_data *data = malloc(sizeof(struct text_prop_data)); //TODO store this in a list and free it when the node is deselected
data->node = node;
data->property = name;
data->prop_type = type;
data->layer = self;
g_signal_connect(value_entry, "activate", G_CALLBACK(text_property_changed), data);
gtk_table_attach(prop_table, name_label, 0, 1, d, d+1, GTK_FILL, GTK_FILL, 1, 1);
gtk_table_attach(prop_table, value_entry, 1, 2, d, d+1, GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 1, 1);
}
}
// gegl_node_process(node);
GeglGtkView *gtk_view = gegl_gtk_view_new_for_node(node);
GeglRectangle rect = gegl_node_get_bounding_box(node);
if(gegl_rectangle_is_infinite_plane(&rect))
{
gegl_gtk_view_set_autoscale_policy(gtk_view, GEGL_GTK_VIEW_AUTOSCALE_DISABLED);
gegl_gtk_view_set_scale(gtk_view, 1.0);
g_print("Disable autoscale: scale=%f, x=%f, y=%f\n", gegl_gtk_view_get_scale(gtk_view),
gegl_gtk_view_get_x(gtk_view), gegl_gtk_view_get_y(gtk_view));
}
gtk_widget_show(GTK_WIDGET(gtk_view));
//TODO: draw checkerboard under preview to indicate transparency
gtk_box_pack_start(GTK_BOX(self->prop_box), GTK_WIDGET(prop_table), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->prop_box), GTK_WIDGET(gtk_view), TRUE, TRUE, 10);
GtkWidget* label = gtk_label_new("Click the image\nto open in a\nnew window");
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(self->prop_box), label, FALSE, TRUE, 10);
gtk_widget_show_all(self->prop_box);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *table, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
table = gtk_table_new (4, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
toolbar = gtk_toolbar_new ();
gtk_table_attach (GTK_TABLE (table), toolbar,
0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
hbox1 = gtk_hbox_new (FALSE, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_table_attach (GTK_TABLE (table), hbox1,
1,2, 1,2, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_table_attach (GTK_TABLE (table), hbox2,
1,2, 2,3, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_option_menu_new();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
menu = gtk_menu_new();
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
{
GtkWidget *menuitem;
menuitem = gtk_menu_item_new_with_label (toolbar_styles[i]);
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu),
GTK_TOOLBAR (toolbar)->style);
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_option_menu_new();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
menu = gtk_menu_new();
menuitem = gtk_menu_item_new_with_label ("small toolbar");
g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("large toolbar");
g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_table_attach (GTK_TABLE (table), scrolled_window,
1,2, 3,4, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), NULL);
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN);
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH);
add_item_to_list (store, item, "Refresh");
g_signal_connect (item, "clicked", G_CALLBACK (reload_clicked), NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD);
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_BOLD);
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new_from_stock (NULL, GTK_STOCK_JUSTIFY_LEFT);
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_CENTER);
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_RIGHT);
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utility-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_table_attach (GTK_TABLE (table), hbox,
1,2, 4,5, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *ok;
GtkWidget *quit;
GtkWidget *menu_bar;
GtkWidget *menu;
GtkWidget *label;
TIME data;
guint loop_t;
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(win),"TimeSetter");
g_signal_connect(G_OBJECT(win),"delete_event",G_CALLBACK(really_quit),NULL);
vbox=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(win),vbox);
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
label=gtk_label_new("当前时间为:");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,5);
label=gtk_label_new("00:00:00");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,5);
loop_t=g_timeout_add(1000,(GSourceFunc)display_time,label);
gtk_box_pack_start(GTK_BOX(vbox),gtk_hseparator_new(),FALSE,FALSE,5);
char *text[]={"年: ","月: ","日: ","时: ","分: ","秒: "};
int i;
for(i=0;i<6;++i)
{
hbox=gtk_hbox_new(FALSE,0);
label=gtk_label_new(text[i]);
data.data[i]=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox),data.data[i],FALSE,FALSE,0);
}
gtk_box_pack_start(GTK_BOX(vbox),gtk_hseparator_new(),FALSE,FALSE,5);
ok=gtk_button_new_with_label("OK");
quit=gtk_button_new_with_label("Quit");
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),ok,FALSE,FALSE,5);
gtk_box_pack_end(GTK_BOX(hbox),quit,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(ok),"clicked",G_CALLBACK(set_time),&data);
g_signal_connect(G_OBJECT(quit),"clicked",G_CALLBACK(really_quit),NULL);
gtk_widget_show_all(win);
gtk_main();
g_source_remove(loop_t);
return 0;
}
//
// Constructor
//
CoLoginGtk::CoLoginGtk( void *wl_parent_ctx,
GtkWidget *wl_parent_wid,
const char *wl_name,
const char *wl_groupname,
void (* wl_bc_success)( void *),
void (* wl_bc_cancel)( void *),
pwr_tStatus *status) :
CoLogin(wl_parent_ctx,wl_name,wl_groupname,wl_bc_success,wl_bc_cancel,status),
parent_wid(wl_parent_wid)
{
const int window_width = 500;
const int window_height = 200;
// Create an input dialog
widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", "Proview Login",
NULL);
g_signal_connect( widgets.toplevel, "delete_event", G_CALLBACK(login_delete_event), this);
g_signal_connect( widgets.toplevel, "focus-in-event", G_CALLBACK(login_action_inputfocus), this);
widgets.usernamevalue = gtk_entry_new();
gtk_widget_set_size_request( widgets.usernamevalue, -1, 20);
g_signal_connect( widgets.usernamevalue, "activate",
G_CALLBACK(valchanged_usernamevalue), this);
GtkWidget *usernamelabel = gtk_label_new("Username");
gtk_widget_set_size_request( usernamelabel, -1, 20);
widgets.passwordvalue = gtk_entry_new();
gtk_widget_set_size_request( widgets.passwordvalue, -1, 20);
g_signal_connect( widgets.passwordvalue, "activate",
G_CALLBACK(valchanged_passwordvalue), this);
GtkWidget *passwordlabel = gtk_label_new("Password");
gtk_widget_set_size_request( passwordlabel, -1, 20);
gtk_entry_set_visibility( GTK_ENTRY(widgets.passwordvalue), FALSE);
pwr_tFileName fname;
dcli_translate_filename( fname, "$pwr_exe/proview_icon2.png");
GtkWidget *india_image = gtk_image_new_from_file( fname);
widgets.okbutton = gtk_button_new_with_label( "Ok");
gtk_widget_set_size_request( widgets.okbutton, 70, 25);
g_signal_connect( widgets.okbutton, "clicked",
G_CALLBACK(activate_ok), this);
GtkWidget *india_cancel = gtk_button_new_with_label( "Cancel");
gtk_widget_set_size_request( india_cancel, 70, 25);
g_signal_connect( india_cancel, "clicked",
G_CALLBACK(activate_cancel), this);
widgets.label = gtk_label_new("");
GtkWidget *vbox1 = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox1), usernamelabel, FALSE, FALSE, 15);
gtk_box_pack_start( GTK_BOX(vbox1), passwordlabel, FALSE, FALSE, 15);
GtkWidget *vbox2 = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox2), widgets.usernamevalue, FALSE, FALSE, 15);
gtk_box_pack_start( GTK_BOX(vbox2), widgets.passwordvalue, FALSE, FALSE, 15);
GtkWidget *hbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(hbox), india_image, FALSE, FALSE, 25);
gtk_box_pack_start( GTK_BOX(hbox), vbox1, FALSE, FALSE, 15);
gtk_box_pack_end( GTK_BOX(hbox), vbox2, TRUE, TRUE, 15);
GtkWidget *india_hboxbuttons = gtk_hbox_new( TRUE, 40);
gtk_box_pack_start( GTK_BOX(india_hboxbuttons), widgets.okbutton, FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(india_hboxbuttons), india_cancel, FALSE, FALSE, 0);
GtkWidget *india_vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(india_vbox), hbox, TRUE, TRUE, 30);
gtk_box_pack_start( GTK_BOX(india_vbox), widgets.label, FALSE, FALSE, 5);
gtk_box_pack_start( GTK_BOX(india_vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(india_vbox), india_hboxbuttons, FALSE, FALSE, 15);
gtk_container_add( GTK_CONTAINER(widgets.toplevel), india_vbox);
gtk_widget_show_all( widgets.toplevel);
gtk_widget_grab_focus( widgets.usernamevalue);
*status = 1;
}
int main(int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* vbox;
GtkWidget* hbox;
GtkWidget* button;
GtkWidget* frame;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(KeyPress), NULL); //按键信号
gtk_window_set_title(GTK_WINDOW(window), "Snake Game");
gtk_window_set_resizable(GTK_WINDOW(window), FALSE); //禁止调整窗口大小
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 5); //设置窗口边框厚度
//垂直排放
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
//水平排放
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
//“单词”标签
frame = gtk_frame_new("单词");
word_label = gtk_label_new(" Eureka ");
gtk_container_add(GTK_CONTAINER(frame), word_label);
gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5);
//“单词序列”标签
frame = gtk_frame_new("单词序列");
seq_label = gtk_label_new(" E u r e k a ");
gtk_container_add(GTK_CONTAINER(frame), seq_label);
gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 3);
/*
//游戏LOGO
GtkWidget *logo;
pix = gdk_pixbuf_new_from_file("logo.png", NULL);
logo = gtk_image_new_from_pixbuf(pix);
gtk_box_pack_start(GTK_BOX(hbox), logo, FALSE, FALSE, 0);
*/
//水平排放
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
//30*20表格容器
table = gtk_table_new(30, 20, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 5);
//垂直排放
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 3);
//“开始”按钮
button = gtk_button_new_with_label("开始");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_begin_clicked), NULL); //on_begin_clicked
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 3);
//“退出”按钮
button = gtk_button_new_with_label("退出");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_exit_clicked), NULL); //on_exit_clicked
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 3);
//“等级”标签
frame = gtk_frame_new("等级");
level_label = gtk_label_new("\n1-1\n\n");
gtk_container_add(GTK_CONTAINER(frame), level_label);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 3);
//“时间”标签
frame = gtk_frame_new("时间");
time_label = gtk_label_new("\n19:31:51\n");
gtk_container_add(GTK_CONTAINER(frame), time_label);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 3);
Start();
gtk_widget_show_all(window);
gtk_main();
return FALSE;
}
int main(int argc,char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *button;
guint i,j,num;
gchar *values[20]={"7","8","9",
"4","5","6",
"1","2","3",
"0",".","=",
"/","*","-","+",
"Bksp","CE","Clear","+/-"
};
gtk_init(&argc,&argv);
//窗体设置
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"计算器");
gtk_window_set_default_size(GTK_WINDOW(window),400,300);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_window_set_icon(GTK_WINDOW(window),create_pixbuf("calc.png"));
gtk_container_set_border_width(GTK_CONTAINER(window),10);
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
vbox=gtk_vbox_new(FALSE,5);
gtk_container_add(GTK_CONTAINER(window),vbox);
table=gtk_table_new(6,4,TRUE);
gtk_table_set_row_spacings(GTK_TABLE(table),10);
gtk_table_set_col_spacings(GTK_TABLE(table),10);
gtk_box_pack_start(GTK_BOX(vbox),table,TRUE,TRUE,0);
entry=gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(entry),1);
gtk_table_attach_defaults(GTK_TABLE(table),entry,0,4,0,1);
//数字0－9和小数点按钮
num=0;
for(j=2;j<6;j++)
{
for(i=0;i<3;i++)
{
button=gtk_button_new_with_label(values[num]);
gtk_table_attach_defaults(GTK_TABLE(table),button,i,i+1,j,j+1);
num++;
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(num_click),NULL);
if(j==5 && i==1)
i=3;
}
}
//加、减、乘、除按钮
num=12;
for(j=2,i=3;j<6;j++,i--)
{
button=gtk_button_new_with_label(values[num]);
gtk_table_attach_defaults(GTK_TABLE(table),button,3,4,j,j+1);
num++;
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(suan_click),NULL);
}
//等号按钮
button=gtk_button_new_with_label(values[11]);
gtk_table_attach_defaults(GTK_TABLE(table),button,2,3,5,6);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(deng_click),NULL);
//Backspace按钮
button=gtk_button_new_with_label(values[16]);
gtk_table_attach_defaults(GTK_TABLE(table),button,0,1,1,2);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(backspace_click),NULL);
//CE按钮
button=gtk_button_new_with_label(values[17]);
gtk_table_attach_defaults(GTK_TABLE(table),button,1,2,1,2);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(ce_click),NULL);
//Clear按钮
button=gtk_button_new_with_label(values[18]);
gtk_table_attach_defaults(GTK_TABLE(table),button,2,3,1,2);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(clear_click),NULL);
//+/-按钮
button=gtk_button_new_with_label(values[19]);
gtk_table_attach_defaults(GTK_TABLE(table),button,3,4,1,2);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(flag_click),NULL);
frame=gtk_frame_new("");
gtk_box_pack_start(GTK_BOX(vbox),frame,TRUE,TRUE,0);
label=gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(label),title);
gtk_container_add(GTK_CONTAINER(frame),label);
gtk_widget_show_all(window);
gtk_main();
}
static void prefs_display_header_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *btn_hbox;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *hdr_label;
GtkWidget *hdr_combo;
GtkWidget *btn_vbox;
GtkWidget *reg_btn;
GtkWidget *del_btn;
GtkWidget *up_btn;
GtkWidget *down_btn;
GtkWidget *clist_hbox;
GtkWidget *clist_hbox1;
GtkWidget *clist_hbox2;
GtkWidget *clist_scrolledwin;
GtkWidget *headers_clist;
GtkWidget *hidden_headers_clist;
GtkWidget *checkbtn_other_headers;
gchar *title[1];
debug_print(_("Creating display header setting window...\n"));
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (window), TRUE);
gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
vbox = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
btn_hbox = gtk_hbox_new (FALSE, 8);
gtk_widget_show (btn_hbox);
gtk_box_pack_end (GTK_BOX (vbox), btn_hbox, FALSE, FALSE, 0);
gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK,
&cancel_btn, GTK_STOCK_CANCEL,
NULL, NULL);
gtk_widget_show (confirm_area);
gtk_box_pack_end (GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default (ok_btn);
gtk_window_set_title (GTK_WINDOW(window),
_("Display header setting"));
MANAGE_WINDOW_SIGNALS_CONNECT(window);
g_signal_connect (G_OBJECT(window), "delete_event",
G_CALLBACK(prefs_display_header_deleted), NULL);
g_signal_connect (G_OBJECT(window), "key_press_event",
G_CALLBACK(prefs_display_header_key_pressed), NULL);
g_signal_connect (G_OBJECT(ok_btn), "clicked",
G_CALLBACK(prefs_display_header_ok), NULL);
g_signal_connect (G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(prefs_display_header_cancel), NULL);
vbox1 = gtk_vbox_new (FALSE, VSPACING);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
hbox1 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 0);
hdr_label = gtk_label_new (_("Header name"));
gtk_widget_show (hdr_label);
gtk_box_pack_start (GTK_BOX (hbox1), hdr_label, FALSE, FALSE, 0);
hdr_combo = gtk_combo_new ();
gtk_widget_show (hdr_combo);
gtk_box_pack_start (GTK_BOX (hbox1), hdr_combo, TRUE, TRUE, 0);
gtk_widget_set_size_request (hdr_combo, 150, -1);
gtkut_combo_set_items (GTK_COMBO (hdr_combo),
"From", "To", "Cc", "Subject", "Date",
"Reply-To", "Sender", "User-Agent", "X-Mailer",
NULL);
clist_hbox = gtk_hbox_new (FALSE, 10);
gtk_widget_show (clist_hbox);
gtk_box_pack_start (GTK_BOX (vbox1), clist_hbox, TRUE, TRUE, 0);
/* display headers list */
clist_hbox1 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (clist_hbox1);
gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox1, TRUE, TRUE, 0);
clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (clist_scrolledwin, 200, 210);
gtk_widget_show (clist_scrolledwin);
gtk_box_pack_start (GTK_BOX (clist_hbox1), clist_scrolledwin,
TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Displayed Headers");
headers_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show (headers_clist);
gtk_container_add (GTK_CONTAINER (clist_scrolledwin), headers_clist);
gtk_clist_set_selection_mode (GTK_CLIST (headers_clist),
GTK_SELECTION_BROWSE);
gtk_clist_set_reorderable (GTK_CLIST (headers_clist), TRUE);
gtk_clist_set_use_drag_icons (GTK_CLIST (headers_clist), FALSE);
gtkut_clist_set_redraw (GTK_CLIST (headers_clist));
GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (headers_clist)->column[0].button,
GTK_CAN_FOCUS);
g_signal_connect_after
(G_OBJECT (headers_clist), "row_move",
G_CALLBACK (prefs_display_header_row_moved), NULL);
btn_vbox = gtk_vbox_new (FALSE, 8);
gtk_widget_show (btn_vbox);
gtk_box_pack_start (GTK_BOX (clist_hbox1), btn_vbox, FALSE, FALSE, 0);
reg_btn = gtk_button_new_with_label (_("Add"));
gtk_widget_show (reg_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (reg_btn), "clicked",
G_CALLBACK (prefs_display_header_register_cb),
GINT_TO_POINTER(FALSE));
del_btn = gtk_button_new_with_label (_("Delete"));
gtk_widget_show (del_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (del_btn), "clicked",
G_CALLBACK (prefs_display_header_delete_cb),
headers_clist);
up_btn = gtk_button_new_with_label (_("Up"));
gtk_widget_show (up_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (up_btn), "clicked",
G_CALLBACK (prefs_display_header_up), NULL);
down_btn = gtk_button_new_with_label (_("Down"));
gtk_widget_show (down_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (down_btn), "clicked",
G_CALLBACK (prefs_display_header_down), NULL);
/* hidden headers list */
clist_hbox2 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (clist_hbox2);
gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox2, TRUE, TRUE, 0);
clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (clist_scrolledwin, 200, 210);
gtk_widget_show (clist_scrolledwin);
gtk_box_pack_start (GTK_BOX (clist_hbox2), clist_scrolledwin,
TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Hidden headers");
hidden_headers_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show (hidden_headers_clist);
gtk_container_add (GTK_CONTAINER (clist_scrolledwin),
hidden_headers_clist);
gtk_clist_set_selection_mode (GTK_CLIST (hidden_headers_clist),
GTK_SELECTION_BROWSE);
gtk_clist_set_auto_sort(GTK_CLIST (hidden_headers_clist), TRUE);
gtkut_clist_set_redraw (GTK_CLIST (hidden_headers_clist));
GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (hidden_headers_clist)->
column[0].button, GTK_CAN_FOCUS);
btn_vbox = gtk_vbox_new (FALSE, 8);
gtk_widget_show (btn_vbox);
gtk_box_pack_start (GTK_BOX (clist_hbox2), btn_vbox, FALSE, FALSE, 0);
reg_btn = gtk_button_new_with_label (_("Add"));
gtk_widget_show (reg_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (reg_btn), "clicked",
G_CALLBACK (prefs_display_header_register_cb),
GINT_TO_POINTER (TRUE));
del_btn = gtk_button_new_with_label (_("Delete"));
gtk_widget_show (del_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (del_btn), "clicked",
G_CALLBACK (prefs_display_header_delete_cb),
hidden_headers_clist);
PACK_CHECK_BUTTON (btn_hbox, checkbtn_other_headers,
_("Show all unspecified headers"));
SET_TOGGLE_SENSITIVITY (checkbtn_other_headers, clist_hbox2);
gtk_widget_show_all(window);
dispheader.window = window;
dispheader.confirm_area = confirm_area;
dispheader.ok_btn = ok_btn;
dispheader.cancel_btn = cancel_btn;
dispheader.hdr_combo = hdr_combo;
dispheader.hdr_entry = GTK_COMBO (hdr_combo)->entry;
dispheader.headers_clist = headers_clist;
dispheader.hidden_headers_clist = hidden_headers_clist;
dispheader.other_headers = checkbtn_other_headers;
}
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");
gtk_window_set_default_size (GTK_WINDOW (window2),0,300);
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();
gtk_widget_set_sensitive(GTK_WIDGET(search->entry_city), FALSE);
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();
gtk_widget_set_sensitive(GTK_WIDGET(search->entry_street), FALSE);
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
gtk_widget_set_sensitive(GTK_WIDGET(search->entry_number), FALSE);
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;
}
void whiteb_show(struct Question *data)
{
/* Reset question picture stored in whiteb_image */
whiteb_image = NULL;
/* Layout */
GtkWidget *window;
GtkWidget *table, *tool_table, *viewport;
/* UI */
GtkWidget *clear_board = NULL,
*freeh_tool = NULL,
*line_tool = NULL,
*rect_tool = NULL,
*circ_tool = NULL,
*erase_tool = NULL,
*exit_but = NULL;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"Powermaths Whiteboard");
gtk_window_fullscreen(GTK_WINDOW(window));
viewport = gtk_viewport_new(NULL,NULL);
table = gtk_table_new(3,8,0);
white_board = gtk_drawing_area_new();
gtk_widget_set_size_request(white_board,768,576);
draw_init_canvas(white_board);
gtk_widget_modify_bg(white_board,GTK_STATE_NORMAL,misc_create_color(65535,65535,65535));
gtk_widget_add_events(white_board,GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK);
gtk_container_add(GTK_CONTAINER(viewport),white_board);
tool_table = gtk_table_new(1,8,1);
clear_board = gtk_button_new();
gtk_container_add(GTK_CONTAINER(clear_board),gtk_image_new_from_file("pixmaps/clear.png"));
freeh_tool = gtk_button_new();
gtk_container_add(GTK_CONTAINER(freeh_tool),gtk_image_new_from_file("pixmaps/freeh.png"));
line_tool = gtk_button_new();
gtk_container_add(GTK_CONTAINER(line_tool),gtk_image_new_from_file("pixmaps/line.png"));
rect_tool = gtk_button_new();
gtk_container_add(GTK_CONTAINER(rect_tool),gtk_image_new_from_file("pixmaps/square.png"));
circ_tool = gtk_button_new();
gtk_container_add(GTK_CONTAINER(circ_tool),gtk_image_new_from_file("pixmaps/circle.png"));
erase_tool = gtk_button_new();
gtk_container_add(GTK_CONTAINER(erase_tool),gtk_image_new_from_file("pixmaps/eraser.png"));
exit_but = gtk_button_new_with_label("Exit");
/* Pack */
gtk_container_add(GTK_CONTAINER(window),table);
gtk_table_attach(GTK_TABLE(table),misc_create_banner(data->caption,16000),0,3,0,1,GTK_FILL|GTK_EXPAND,0,0,0);
gtk_table_attach(GTK_TABLE(table),viewport,0,1,1,8,0,0,0,0);
gtk_table_attach(GTK_TABLE(table),tool_table,1,2,1,8,0,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(tool_table),clear_board,0,1,1,2,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),freeh_tool,0,1,2,3,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),line_tool,0,1,3,4,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),rect_tool,0,1,4,5,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),circ_tool,0,1,5,6,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),erase_tool,0,1,6,7,GTK_FILL,0,0,0);
gtk_table_attach(GTK_TABLE(tool_table),exit_but,0,1,7,8,GTK_FILL,0,0,0);
/* Hook up callbacks */
g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(whiteb_window_delete),NULL);
g_signal_connect(G_OBJECT(white_board),"button-press-event",G_CALLBACK(whiteb_board_press),NULL);
g_signal_connect(G_OBJECT(white_board),"motion-notify-event",G_CALLBACK(whiteb_board_motion),NULL);
g_signal_connect(G_OBJECT(white_board),"button-release-event",G_CALLBACK(whiteb_board_release),NULL);
g_signal_connect(G_OBJECT(white_board),"expose-event",G_CALLBACK(whiteb_expose_event),data);
g_signal_connect(G_OBJECT(clear_board),"clicked",G_CALLBACK(whiteb_clear),NULL);
g_signal_connect(G_OBJECT(freeh_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_FREEHAND);
g_signal_connect(G_OBJECT(line_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_LINE);
g_signal_connect(G_OBJECT(rect_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_RECT);
g_signal_connect(G_OBJECT(circ_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_CIRCLE);
g_signal_connect(G_OBJECT(erase_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_ERASER);
g_signal_connect_swapped(G_OBJECT(exit_but),"clicked",G_CALLBACK(whiteb_window_delete),window);
gtk_widget_show_all(window);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *main_box, *container, *child;
GtkWidget *box, *toolbar;
GtkStyleProvider *provider;
GtkTextBuffer *css;
gtk_init (&argc, &argv);
css = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (css,
"warning",
"background", "rgba(255,255,0,0.3)",
NULL);
gtk_text_buffer_create_tag (css,
"error",
"background", "rgba(255,0,0,0.3)",
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
provider,
GTK_STYLE_PROVIDER_PRIORITY_FORCE);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), main_box);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_TEXT);
gtk_box_pack_start (GTK_BOX (main_box), toolbar, FALSE, TRUE, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_box), box, FALSE, TRUE, 0);
container = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (container), 200);
gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (container), 200);
gtk_box_pack_start (GTK_BOX (main_box), container, TRUE, TRUE, 0);
child = gtk_text_view_new_with_buffer (css);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (css,
"changed",
G_CALLBACK (css_text_changed),
provider);
gtk_text_buffer_set_text (css,
DEFAULT_CSS,
-1);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_box), container, FALSE, TRUE, 0);
child = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (child), gtk_widget_get_default_direction () == GTK_TEXT_DIR_LTR);
g_signal_connect (child,
"notify::active",
G_CALLBACK (set_orientation),
NULL);
gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0);
child = gtk_label_new ("left-to-right");
gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0);
child = gtk_button_new_with_label ("Add button");
g_signal_connect_swapped (child,
"clicked",
G_CALLBACK (add_button),
box);
gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0);
child = gtk_button_new_with_label ("Add toolbutton");
g_signal_connect_swapped (child,
"clicked",
G_CALLBACK (add_toolbutton),
toolbar);
gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0);
add_toolbutton (GTK_TOOLBAR (toolbar));
add_toolbutton (GTK_TOOLBAR (toolbar));
add_toolbutton (GTK_TOOLBAR (toolbar));
add_toolbutton (GTK_TOOLBAR (toolbar));
add_button (GTK_BOX (box));
add_button (GTK_BOX (box));
add_button (GTK_BOX (box));
add_button (GTK_BOX (box));
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void prefs_themes_create_widget(PrefsPage *page, GtkWindow *window, gpointer data)
{
ThemesPage *prefs_themes = (ThemesPage *)page;
ThemesData *tdata = prefs_themes_data;
GtkWidget *vbox1;
GtkWidget *frame1;
GtkWidget *vbox2;
GtkWidget *hbox3;
GtkWidget *menu_themes;
GtkWidget *btn_install;
GtkWidget *btn_more;
GtkWidget *label_global_status;
GtkWidget *frame_info;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label_name;
GtkWidget *label_author;
GtkWidget *label_url;
GtkWidget *label4;
GtkWidget *label_status;
GtkWidget *frame_preview;
GtkWidget *hbox1;
GtkWidget *icon_1;
GtkWidget *icon_2;
GtkWidget *icon_3;
GtkWidget *icon_4;
GtkWidget *icon_5;
GtkWidget *icon_6;
GtkWidget *icon_7;
GtkWidget *frame_buttons;
GtkWidget *hbuttonbox1;
GtkWidget *btn_remove;
GtkCellRenderer *renderer;
vbox1 = gtk_vbox_new (FALSE, VSPACING);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
gtk_widget_show (vbox1);
vbox2 = gtkut_get_options_frame(vbox1, &frame1, _("Selector"));
hbox3 = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox2), hbox3, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5);
menu_themes = gtk_combo_box_new();
gtk_widget_show (menu_themes);
gtk_box_pack_start (GTK_BOX (hbox3), menu_themes, FALSE, FALSE, 0);
btn_install = gtk_button_new_with_label (_("Install new..."));
gtk_widget_show (btn_install);
gtk_box_pack_start (GTK_BOX (hbox3), btn_install, FALSE, FALSE, 0);
gtkut_widget_set_can_default (btn_install, TRUE);
btn_more = gtkut_get_link_btn((GtkWidget *)window, THEMES_URI, _("Get more..."));
gtk_widget_show (btn_more);
gtk_box_pack_start (GTK_BOX (hbox3), btn_more, FALSE, FALSE, 0);
label_global_status = gtk_label_new ("");
gtk_widget_show (label_global_status);
gtk_box_pack_start (GTK_BOX (vbox2), label_global_status, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label_global_status), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label_global_status), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_global_status), 6, 0);
PACK_FRAME(vbox1, frame_info, _("Information"));
table1 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (frame_info), table1);
label1 = gtk_label_new (_("Name: "));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 8, 2);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (_("Author: "));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 8, 2);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
label3 = gtk_label_new (_("URL:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 8, 2);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label_name = gtk_label_new ("");
gtk_widget_show (label_name);
gtk_table_attach (GTK_TABLE (table1), label_name, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_name), 0, 0.5);
label_author = gtk_label_new ("");
gtk_widget_show (label_author);
gtk_table_attach (GTK_TABLE (table1), label_author, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_author), 0, 0.5);
label_url = gtk_label_new ("");
gtk_widget_show (label_url);
gtk_table_attach (GTK_TABLE (table1), label_url, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_url), 0, 0.5);
label4 = gtk_label_new (_("Status:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 8, 2);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label_status = gtk_label_new ("");
gtk_widget_show (label_status);
gtk_table_attach (GTK_TABLE (table1), label_status, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_status), 0, 0.5);
PACK_FRAME(vbox1, frame_preview, _("Preview"));
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (frame_preview), hbox1);
icon_1 = gtk_image_new();
gtk_widget_show (icon_1);
gtk_box_pack_start (GTK_BOX (hbox1), icon_1, TRUE, TRUE, 2);
gtk_misc_set_padding (GTK_MISC (icon_1), 0, 5);
icon_2 = gtk_image_new();
gtk_widget_show (icon_2);
gtk_box_pack_start (GTK_BOX (hbox1), icon_2, TRUE, TRUE, 2);
gtk_misc_set_padding (GTK_MISC (icon_2), 0, 5);
icon_3 = gtk_image_new();
gtk_widget_show (icon_3);
gtk_box_pack_start (GTK_BOX (hbox1), icon_3, TRUE, TRUE, 2);
gtk_misc_set_padding (GTK_MISC (icon_3), 0, 5);
icon_4 = gtk_image_new();
gtk_widget_show (icon_4);
gtk_box_pack_start (GTK_BOX (hbox1), icon_4, TRUE, TRUE, 2);
gtk_misc_set_padding (GTK_MISC (icon_4), 0, 5);
icon_5 = gtk_image_new();
gtk_widget_show (icon_5);
gtk_box_pack_start (GTK_BOX (hbox1), icon_5, TRUE, TRUE, 2);
gtk_misc_set_padding (GTK_MISC (icon_5), 0, 5);
icon_6 = gtk_image_new();
gtk_widget_show (icon_6);
gtk_box_pack_start (GTK_BOX (hbox1), icon_6, TRUE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (icon_6), 0, 5);
icon_7 = gtk_image_new();
gtk_widget_show (icon_7);
gtk_box_pack_start (GTK_BOX (hbox1), icon_7, TRUE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (icon_7), 0, 5);
PACK_FRAME(vbox1, frame_buttons, _("Actions"));
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_container_add (GTK_CONTAINER (frame_buttons), hbuttonbox1);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 5);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_START);
gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 5);
btn_remove = gtk_button_new_with_label (_("Remove"));
gtk_widget_show (btn_remove);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), btn_remove);
gtkut_widget_set_can_default (btn_remove, TRUE);
g_signal_connect(G_OBJECT(btn_remove), "clicked",
G_CALLBACK(prefs_themes_btn_remove_clicked_cb),
NULL);
g_signal_connect(G_OBJECT(btn_install), "clicked",
G_CALLBACK(prefs_themes_btn_install_clicked_cb),
NULL);
prefs_themes->window = GTK_WIDGET(window);
prefs_themes->name = label_name;
prefs_themes->author = label_author;
prefs_themes->url = label_url;
prefs_themes->status = label_status;
prefs_themes->global = label_global_status;
prefs_themes->icons[0] = icon_1;
prefs_themes->icons[1] = icon_2;
prefs_themes->icons[2] = icon_3;
prefs_themes->icons[3] = icon_4;
prefs_themes->icons[4] = icon_5;
prefs_themes->icons[5] = icon_6;
prefs_themes->icons[6] = icon_7;
prefs_themes->btn_remove = btn_remove;
prefs_themes->btn_install = btn_install;
prefs_themes->btn_more = btn_more;
prefs_themes->op_menu = menu_themes;
prefs_themes->page.widget = vbox1;
prefs_themes_set_themes_menu(GTK_COMBO_BOX(menu_themes), tdata);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(menu_themes), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(menu_themes), renderer,
"text", 0, NULL);
prefs_themes_get_theme_info(tdata);
prefs_themes_display_global_stats(tdata);
}
int main(int argc, char **argv)
{
init_TableDir();
set_is_chs();
b_pinyin = is_pinyin_kbm();
gtk_init (&argc, &argv);
load_setttings();
load_gtab_list(TRUE);
#if HIME_i18n_message
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
pinmd = &inmd[default_input_method];
if (pinmd->method_type == method_type_TSIN) {
dbg("is tsin\n");
pho_load();
load_tsin_db();
ph_key_sz = 2;
} else
if (pinmd->filename) {
dbg("gtab filename %s\n", pinmd->filename);
init_gtab(default_input_method);
is_gtab = TRUE;
init_tsin_table_fname(pinmd, gtab_tsin_fname);
load_tsin_db0(gtab_tsin_fname, TRUE);
} else
p_err("Your default input method %s doesn't use phrase database",
pinmd->cname);
dbg("ph_key_sz: %d\n", ph_key_sz);
dpy = GDK_DISPLAY();
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
gtk_window_set_default_size(GTK_WINDOW (mainwin), 640, 520);
set_window_hime_icon(mainwin);
GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER(mainwin), vbox_top);
GtkWidget *view = gtk_text_view_new ();
gtk_widget_set_hexpand (view, TRUE);
gtk_widget_set_vexpand (view, TRUE);
gtk_container_add (GTK_CONTAINER(sw), view);
gtk_box_pack_start (GTK_BOX (vbox_top), sw, TRUE, TRUE, 0);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
char *text = _("按滑鼠中鍵, 貼上你要 hime-tslearn 學習的文章。");
gtk_text_buffer_set_text (buffer, text, -1);
gtk_text_buffer_create_tag (buffer,
"blue_background", "background", "blue", "foreground", "white", NULL);
gtk_text_buffer_create_tag (buffer, "char_wrap",
"wrap_mode", GTK_WRAP_CHAR, NULL);
hbox_buttons = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_buttons, FALSE, FALSE, 0);
GtkWidget *button_parse = gtk_button_new_with_label(_("標示已知詞"));
gtk_box_pack_start (GTK_BOX (hbox_buttons), button_parse, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_parse), "clicked",
G_CALLBACK (cb_button_parse), NULL);
GtkWidget *button_add = gtk_button_new_with_label(_("新增詞"));
gtk_box_pack_start (GTK_BOX (hbox_buttons), button_add, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button_add), "clicked",
G_CALLBACK (cb_button_add), NULL);
GtkWidget *button_quit = gtk_button_new_from_stock (GTK_STOCK_QUIT);
gtk_box_pack_start (GTK_BOX (hbox_buttons), button_quit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_quit), "clicked",
G_CALLBACK (do_exit), NULL);
g_signal_connect (G_OBJECT (mainwin), "delete_event",
G_CALLBACK (do_exit), NULL);
all_wrap();
gtk_widget_show_all(mainwin);
gtk_main();
return 0;
}
static gchar*
passphrase_mbox (const gchar *desc)
{
gchar *the_passphrase = NULL;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *pass_label;
GtkWidget *confirm_box;
GtkWidget *window;
GtkWidget *pass_entry;
GtkWidget *ok_button;
GtkWidget *cancel_button;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
gtk_widget_set_usize(window, 450, -1);
gtk_container_set_border_width(GTK_CONTAINER(window), 4);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(passphrase_deleted), NULL);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(passphrase_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
manage_window_set_transient(GTK_WINDOW(window));
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
if (desc) {
GtkWidget *label;
label = create_description (desc);
gtk_box_pack_start (GTK_BOX(vbox), label, TRUE, TRUE, 0);
}
table = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 8);
gtk_table_set_row_spacings(GTK_TABLE(table), 12);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
pass_label = gtk_label_new("");
gtk_table_attach (GTK_TABLE(table), pass_label, 0, 1, 0, 1,
GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (pass_label), 1, 0.5);
pass_entry = gtk_entry_new();
gtk_table_attach (GTK_TABLE(table), pass_entry, 1, 2, 0, 1,
GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
gtk_entry_set_visibility (GTK_ENTRY(pass_entry), FALSE);
gtk_widget_grab_focus (pass_entry);
confirm_box = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX(confirm_box), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX(confirm_box), 5);
ok_button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (ok_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX(confirm_box), ok_button, TRUE, TRUE, 0);
cancel_button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_box), cancel_button, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
gtk_widget_grab_default (ok_button);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
GTK_SIGNAL_FUNC(passphrase_ok_cb), NULL);
gtk_signal_connect(GTK_OBJECT(pass_entry), "activate",
GTK_SIGNAL_FUNC(passphrase_ok_cb), NULL);
gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked",
GTK_SIGNAL_FUNC(passphrase_cancel_cb), NULL);
if (grab_all)
gtk_object_set (GTK_OBJECT(window), "type", GTK_WINDOW_POPUP, NULL);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
if (grab_all)
gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_widget_show_all(window);
/* don't use XIM on entering passphrase */
gtkut_editable_disable_im(GTK_EDITABLE(pass_entry));
if (grab_all) {
XGrabServer(GDK_DISPLAY());
if ( gdk_pointer_grab ( window->window, TRUE, 0,
NULL, NULL, GDK_CURRENT_TIME)) {
XUngrabServer ( GDK_DISPLAY() );
g_warning ("OOPS: Could not grab mouse\n");
gtk_widget_destroy (window);
return NULL;
}
if ( gdk_keyboard_grab( window->window, FALSE, GDK_CURRENT_TIME )) {
gdk_pointer_ungrab (GDK_CURRENT_TIME);
XUngrabServer ( GDK_DISPLAY() );
g_warning ("OOPS: Could not grab keyboard\n");
gtk_widget_destroy (window);
return NULL;
}
}
gtk_main();
if (grab_all) {
XUngrabServer (GDK_DISPLAY());
gdk_pointer_ungrab (GDK_CURRENT_TIME);
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
gdk_flush();
}
manage_window_focus_out(window, NULL, NULL);
if (pass_ack) {
the_passphrase = gtk_entry_get_text(GTK_ENTRY(pass_entry));
if (the_passphrase) /* Hmmm: Do we really need this? */
the_passphrase = g_strdup (the_passphrase);
}
gtk_widget_destroy (window);
return the_passphrase;
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;
/* This is called in all GTK applications. Arguments are parsed
* from the command line and are returned to the application. */
gtk_init (&argc, &argv);
/* create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* When the window is given the "delete-event" signal (this is given
* by the window manager, usually by the "close" option, or on the
* titlebar), we ask it to call the delete_event () function
* as defined above. The data passed to the callback
* function is NULL and is ignored in the callback function. */
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event), NULL);
/* Here we connect the "destroy" event to a signal handler.
* This event occurs when we call gtk_widget_destroy() on the window,
* or if we return FALSE in the "delete-event" callback. */
g_signal_connect (window, "destroy",
G_CALLBACK (destroy), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Creates a new button with the label "Hello World". */
button = gtk_button_new_with_label ("Hello World");
/* When the button receives the "clicked" signal, it will call the
* function hello() passing it NULL as its argument. The hello()
* function is defined above. */
g_signal_connect (button, "clicked",
G_CALLBACK (hello), NULL);
/* This will cause the window to be destroyed by calling
* gtk_widget_destroy(window) when "clicked". Again, the destroy
* signal could come from here, or the window manager. */
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
/* This packs the button into the window (a gtk container). */
gtk_container_add (GTK_CONTAINER (window), button);
/* The final step is to display this newly created widget. */
gtk_widget_show (button);
/* and the window */
gtk_widget_show (window);
/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or
* mouse event). */
gtk_main ();
return 0;
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t));
self->data = (void *)d;
d->imgsel = -1;
self->widget = gtk_vbox_new(TRUE, 5);
gtk_widget_set_size_request(self->widget,100,-1);
GtkBox *box, *hbox;
GtkWidget *button;
GtkWidget *w;
GtkListStore *liststore;
// left side, current
box = GTK_BOX(gtk_vbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
w = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
d->current = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->current, FALSE);
liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(d->current, col);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL);
g_signal_connect(G_OBJECT (d->current), "row-activated", G_CALLBACK (detach_activated), (gpointer)self);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current));
// attach/detach buttons
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("attach"));
d->attach_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (attach_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(_("detach"));
d->detach_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (detach_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
// right side, related
box = GTK_BOX(gtk_vbox_new(FALSE, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5);
// text entry and new button
w = gtk_entry_new();
g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK);
// g_signal_connect(G_OBJECT(w), "key-release-event",
g_signal_connect(G_OBJECT(w), "changed",
G_CALLBACK(tag_name_changed), (gpointer)self);
g_signal_connect(G_OBJECT (w), "activate",
G_CALLBACK (entry_activated), (gpointer)self);
d->entry = GTK_ENTRY(w);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
// related tree view
w = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(w,-1,100);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
d->related = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->related, FALSE);
liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
col = gtk_tree_view_column_new();
gtk_tree_view_append_column(d->related, col);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL);
g_signal_connect(G_OBJECT (d->related), "row-activated", G_CALLBACK (attach_activated), (gpointer)self);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related));
// attach and delete buttons
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("new"));
d->new_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (new_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(_("delete"));
d->delete_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (delete_button_clicked), (gpointer)self);
gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
// add entry completion
GtkEntryCompletion *completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(d->entry, completion);
/* connect to mouse over id */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self);
set_keyword(self, d);
}
int main(int argc, char** argv)
{
GtkWidget *window_label;
GtkWidget *window;
GtkWidget *window_frame;
GtkWidget *increase_vol;
GtkWidget *decrease_vol;
GtkWidget *max_vol;
GtkWidget *zero_vol;
/* Initialize the GTK+ Library */
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
/* Set Title for GTK Window */
gtk_window_set_title(GTK_WINDOW(window), "ALSA Volume Controller");
/* Set Default Size of the GTK Window */
gtk_window_set_default_size(GTK_WINDOW(window), 560, 150);
window_frame = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), window_frame);
increase_vol = gtk_button_new_with_label("+");
gtk_widget_set_size_request(increase_vol, 80, 35);
gtk_fixed_put(GTK_FIXED(window_frame), increase_vol, 50, 20);
decrease_vol = gtk_button_new_with_label("-");
gtk_widget_set_size_request(decrease_vol, 80, 35);
gtk_fixed_put(GTK_FIXED(window_frame), decrease_vol, 50, 80);
max_vol = gtk_button_new_with_label("MAX");
gtk_widget_set_size_request(max_vol, 80, 35);
gtk_fixed_put(GTK_FIXED(window_frame), max_vol, 165, 20);
zero_vol = gtk_button_new_with_label("MUTE");
gtk_widget_set_size_request(zero_vol, 80, 35);
gtk_fixed_put(GTK_FIXED(window_frame), zero_vol, 165, 80);
window_label = gtk_label_new("copyright@SandeepSingh");
gtk_fixed_put(GTK_FIXED(window_frame), window_label, 280, 58);
gtk_widget_show_all(window);
g_signal_connect(window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect(increase_vol, "clicked",
G_CALLBACK(increase), window_label);
g_signal_connect(decrease_vol, "clicked",
G_CALLBACK(decrease), window_label);
g_signal_connect(max_vol, "clicked",
G_CALLBACK(maxvolume), window_label);
g_signal_connect(zero_vol, "clicked",
G_CALLBACK(novolume), window_label);
gtk_main();
return 0;
}
int main(int argc, char **argv)
{
#if WIN32
init_TableDir();
#endif
gtk_init (&argc, &argv);
#if GCIN_i18n_message
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
b_pinyin = is_pinyin_kbm();
pho_load();
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
gtk_window_set_default_size(GTK_WINDOW (mainwin), 640, 220);
set_window_gcin_icon(mainwin);
GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER(mainwin), vbox_top);
GtkWidget *view = gtk_text_view_new ();
gtk_widget_set_hexpand (view, TRUE);
gtk_widget_set_vexpand (view, TRUE);
gtk_container_add (GTK_CONTAINER(sw), view);
gtk_box_pack_start (GTK_BOX (vbox_top), sw, TRUE, TRUE, 0);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_create_tag (buffer,
"blue_background", "background", "blue", "foreground", "white", NULL);
gtk_text_buffer_create_tag (buffer, "char_wrap",
"wrap_mode", GTK_WRAP_CHAR, NULL);
hbox_buttons = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_buttons, FALSE, FALSE, 0);
GtkWidget *button_fetch = gtk_button_new_with_label(_(_L("自剪貼區更新")));
gtk_box_pack_start (GTK_BOX (hbox_buttons), button_fetch, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_fetch), "clicked",
G_CALLBACK (cb_button_fetch), NULL);
GtkWidget *button_exit = gtk_button_new_from_stock(GTK_STOCK_QUIT);
gtk_box_pack_start (GTK_BOX (hbox_buttons), button_exit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button_exit), "clicked",
G_CALLBACK (do_exit), NULL);
g_signal_connect (G_OBJECT (mainwin), "delete_event",
G_CALLBACK (do_exit), NULL);
gtk_widget_show_all(mainwin);
#if UNIX
pclipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
#else
pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
#endif
req_clipboard();
gtk_main();
return 0;
}
/*
* FindStringDialog
*
* Function to display a search dialog
*/
void FindStringDialog (char *szMessage, void (*YesFunc)(), void (*NoFunc)())
{
GtkWidget *label;
GtkWidget *button;
GtkWidget *hbox;
/* --- If window is already open, just return --- */
if (dialog_window) return;
/* --- Create the dialog --- */
dialog_window = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
GTK_SIGNAL_FUNC (CloseFindDialog),
dialog_window);
/* --- Set the title --- */
gtk_window_set_title (GTK_WINDOW (dialog_window), "Find");
/* --- Add a small border --- */
gtk_container_border_width (GTK_CONTAINER (dialog_window), 5);
/*
* --- Create the message
*/
hbox = gtk_hbox_new (TRUE, TRUE);
/* --- Create a label with the message --- */
label = gtk_label_new ("Find What:");
gtk_widget_show (label);
/* --- Create the entry field --- */
entry = gtk_entry_new ();
gtk_widget_show (entry);
/* --- If they've searched before --- */
if (szNeedle) {
/* --- Prefill with the value they looked for last time --- */
gtk_entry_set_text (GTK_ENTRY (entry), szNeedle);
}
gtk_box_pack_start (GTK_BOX (hbox),
label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
entry, TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* --- Add label to the dialog --- */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
hbox, TRUE, TRUE, 0);
/* --- Create the "yes" button --- */
button = gtk_button_new_with_label ("Find Next");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (YesFunc),
dialog_window);
/* --- Add the button to the dialog --- */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
/* --- Make the button visible --- */
gtk_widget_show (button);
/*
* --- Cancel button
*/
/* --- Create the "Cancel" button --- */
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (NoFunc),
dialog_window);
/* --- Allow "Cancel" to be a default --- */
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
/* --- Add the "Cancel" button to the dialog --- */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
/* --- Make the "Cancel" the default --- */
gtk_widget_grab_default (button);
/* --- Make the button visible. --- */
gtk_widget_show (button);
/* --- Show the dialog --- */
gtk_widget_show (dialog_window);
}
static void
create_markerss (void)
{
GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *close_button;
GtkWidget *box;
GtkWidget *table;
GtkWidget *label;
GtkWidget *separator;
gfloat *X;
gfloat *Y;
gint i;
GtkDataboxGraph *graph;
GdkColor color;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 600, 600);
g_signal_connect (GTK_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Markers");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
label =
gtk_label_new
("Some markerss (green) are shown below.\nThe text corresponds to the position of the text, relative to the markers.\n\nThere are also some texts (yellow).\n\nData points are red\n");
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);
gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table,
TRUE, TRUE, TRUE, TRUE);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
color.red = 16383;
color.green = 16383;
color.blue = 16383;
gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color);
X = g_new0 (gfloat, 20 + 4 + 5);
Y = g_new0 (gfloat, 20 + 4 + 5);
for (i = 0; i < 20 + 4 + 5; ++i)
{
X[i] = i % 4;
Y[i] = i / 4;
}
X[20] = -0.5;
Y[20] = -0.5;
X[21] = -0.5;
Y[21] = 4.5;
X[22] = 3.5;
Y[22] = -0.5;
X[23] = 3.5;
Y[23] = 4.5;
X[24] = -1.;
Y[24] = -1.;
X[25] = -1.;
Y[25] = +5.;
X[26] = +4.;
Y[26] = -1.;
X[27] = +4.;
Y[27] = +5.;
X[28] = +1.5;
Y[28] = +2.;
color.red = 65535;
color.green = 0;
color.blue = 0;
graph = gtk_databox_points_new (20 + 4 + 5, X, Y, &color, 3);
gtk_databox_graph_add (GTK_DATABOX (box), graph);
color.red = 0;
color.green = 65535;
color.blue = 0;
graph = gtk_databox_markers_new (20, X, Y, &color, 15,
GTK_DATABOX_MARKERS_TRIANGLE);
gtk_databox_graph_add (GTK_DATABOX (box), graph);
setM (graph, 0, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE);
setM (graph, 1, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE);
setM (graph, 2, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE);
setM (graph, 3, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE);
setM (graph, 4, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
setM (graph, 5, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
setM (graph, 6, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
setM (graph, 7, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);
setM (graph, 8, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
setM (graph, 9, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
setM (graph, 10, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
setM (graph, 11, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);
setM (graph, 12, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
setM (graph, 13, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
setM (graph, 14, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);
setM (graph, 15, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
setM (graph, 16, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_SW, "SW", TRUE);
setM (graph, 17, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_NW, "NW", TRUE);
setM (graph, 18, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_SE, "SE", TRUE);
setM (graph, 19, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_NE, "NE", TRUE);
graph = gtk_databox_markers_new (4, X + 20, Y + 20, &color, 1,
GTK_DATABOX_MARKERS_DASHED_LINE);
gtk_databox_graph_add (GTK_DATABOX (box), graph);
setL (graph, 0, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
setL (graph, 1, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
setL (graph, 2, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
setL (graph, 3, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);
color.red = 65535;
color.green = 65535;
color.blue = 0;
graph = gtk_databox_markers_new (5, X + 20 + 4, Y + 20 + 4, &color, 1,
GTK_DATABOX_MARKERS_NONE);
gtk_databox_graph_add (GTK_DATABOX (box), graph);
setT (graph, 0, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE);
setT (graph, 1, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE);
setT (graph, 2, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE);
setT (graph, 3, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE);
setT (graph, 4, GTK_DATABOX_MARKERS_TEXT_CENTER, "Centered", TRUE);
gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);
close_button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked",
G_CALLBACK (gtk_main_quit), GTK_OBJECT (box));
gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);
gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (close_button);
gtk_widget_show_all (window);
}
bool create_firing_rate_view_gui(TimeStamp bin_size, int num_of_patterns, TimeStamp pattern_length)
{
int i, j;
GtkWidget *frame;
GtkWidget *frame_label;
GtkWidget *table, *hbox, *vbox, *lbl;
frame = gtk_frame_new ("Firing Rate");
frame_label = gtk_label_new ("Firing Rate");
gtk_notebook_append_page (GTK_NOTEBOOK (tabs), frame, frame_label);
hbox = gtk_hbox_new(TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), hbox);
table = gtk_table_new(6,8,TRUE);
gtk_box_pack_start(GTK_BOX(hbox),table, TRUE,TRUE,0);
///////////////////////////////////////////// FIRST COLUMN ///////////////////////////////////////////////////////////////
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 0,1, 0, 6);
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Layer #:");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
entry_layer_num = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox),entry_layer_num, FALSE,FALSE,0);
gtk_entry_set_text(GTK_ENTRY(entry_layer_num), "0");
gtk_widget_set_size_request(entry_layer_num, 50, 25) ;
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Group #:");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
entry_neuron_group_num = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox),entry_neuron_group_num, FALSE,FALSE,0);
gtk_entry_set_text(GTK_ENTRY(entry_neuron_group_num), "0");
gtk_widget_set_size_request(entry_neuron_group_num, 50, 25) ;
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Neuron #:");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
entry_neuron_num = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox),entry_neuron_num, FALSE,FALSE,0);
gtk_entry_set_text(GTK_ENTRY(entry_neuron_num), "0");
gtk_widget_set_size_request(entry_neuron_num, 50, 25) ;
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Pattern #:");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
entry_pattern_num = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox),entry_pattern_num, FALSE,FALSE,0);
gtk_entry_set_text(GTK_ENTRY(entry_pattern_num), "0");
gtk_widget_set_size_request(entry_pattern_num, 50, 25) ;
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
btn_display_firing_rates = gtk_button_new_with_label("Display Firing Rates");
gtk_box_pack_start (GTK_BOX (hbox), btn_display_firing_rates, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),gtk_hseparator_new(), FALSE,FALSE,10);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
btn_calculate_firing_rates = gtk_button_new_with_label("Calculate Firing Rates");
gtk_box_pack_start (GTK_BOX (hbox), btn_calculate_firing_rates, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),gtk_hseparator_new(), FALSE,FALSE,10);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Num of Spikes in Patt : ");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
lbl_num_of_spikes_in_pattern = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(hbox),lbl_num_of_spikes_in_pattern, FALSE,FALSE,0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Mean of Neuron Spikes : ");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
lbl_mean_num_of_spikes_per_neuron = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(hbox),lbl_mean_num_of_spikes_per_neuron, FALSE,FALSE,0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),hbox, FALSE,FALSE,0);
lbl = gtk_label_new("Var of Neuron Spikes : ");
gtk_box_pack_start(GTK_BOX(hbox),lbl, FALSE,FALSE,0);
lbl_variance_of_num_of_spikes_per_neuron = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(hbox),lbl_variance_of_num_of_spikes_per_neuron, FALSE,FALSE,0);
///////////////////////////// GRAPHS /////////////////////////////////////////
Layer *ptr_layer;
NeuronGroup *ptr_neuron_group;
firing_rate_submit_number_of_mwas(spike_pattern_generator_get_network()->layer_count);
for (i=0; i<spike_pattern_generator_get_network()->layer_count; i++)
{
ptr_layer = spike_pattern_generator_get_network()->layers[i];
firing_rate_submit_number_of_channels_in_mwa(i, ptr_layer->neuron_group_count);
for (j=0; j<ptr_layer->neuron_group_count; j++)
{
ptr_neuron_group = ptr_layer->neuron_groups[j];
firing_rate_submit_number_of_units_in_mwa_channel(i, j, ptr_neuron_group->neuron_count);
}
}
firing_rate_submit_number_of_patterns (num_of_patterns);
firing_rate_allocate_bins(pattern_length, bin_size);
hbox = gtk_hbox_new(TRUE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 1,6, 0, 3);
create_firing_rate_bin_means_boxes_and_graphs(hbox, pattern_length, bin_size);
hbox = gtk_hbox_new(TRUE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 1,6, 3, 6);
create_firing_rate_bin_variances_boxes_and_graphs(hbox, pattern_length, bin_size);
gtk_widget_show_all(window);
g_signal_connect(G_OBJECT(btn_display_firing_rates), "clicked", G_CALLBACK(display_firing_rates_button_func), NULL);
g_signal_connect(G_OBJECT(btn_calculate_firing_rates), "clicked", G_CALLBACK(calculate_firing_rates_button_func), NULL);
return TRUE;
}
void
ags_desk_init(AgsDesk *desk)
{
GtkHBox *hbox;
GtkAlignment *alignment;
GtkHBox *balance_hbox;
desk->name = NULL;
desk->xml_type = "ags-desk";
/* create widgets */
desk->vbox = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) desk),
(GtkWidget *) desk->vbox);
hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) hbox,
FALSE, FALSE,
0);
/* left pad */
desk->left_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->left_pad,
FALSE, FALSE,
0);
/* console */
alignment = gtk_alignment_new(0.0,
0.0,
0.0,
0.0);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) alignment,
FALSE, FALSE,
0);
desk->console = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer *) alignment,
(GtkWidget *) desk->console);
balance_hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->console,
(GtkWidget *) balance_hbox,
FALSE, FALSE,
0);
desk->move_left = (GtkButton *) gtk_button_new_with_label(i18n("left"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_left,
FALSE, FALSE,
0);
desk->balance = (GtkScale *) gtk_hscale_new_with_range(-1.0, 1.0, 0.1);
gtk_widget_set_size_request((GtkWidget *) desk->balance,
200, -1);
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->balance,
FALSE, FALSE,
0);
desk->move_right = (GtkButton *) gtk_button_new_with_label(i18n("right"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_right,
FALSE, FALSE,
0);
/* left pad */
desk->right_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->right_pad,
FALSE, FALSE,
0);
/* file chooser */
desk->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_set_size_request((GtkWidget *) desk->file_chooser,
-1, 400);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) desk->file_chooser,
FALSE, FALSE,
0);
}
int
main (int argc, char **argv)
{
GtkWidget *w1;
gchar *path;
g_type_init ();
gtk_init (&argc, &argv);
toplevel = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (toplevel), 12);
grid = gtk_grid_new ();
w1 = gtk_label_new ("File:");
gtk_widget_set_halign (w1, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid),
w1, 0, 0, 1, 1);
file_l = gtk_button_new ();
path = g_build_filename (g_get_current_dir (), "apple-red.png", NULL);
file = g_file_new_for_path (path);
gtk_button_set_label (GTK_BUTTON (file_l), path);
g_free (path);
gtk_widget_set_halign (file_l, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (grid), file_l,
w1, GTK_POS_RIGHT, 3, 1);
g_signal_connect (file_l, "clicked",
G_CALLBACK (button_clicked), NULL);
radio_file = gtk_radio_button_new_with_label (NULL, "Use GFile");
radio_content = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_file),
"Use content type");
gtk_grid_attach (GTK_GRID (grid), radio_file,
0, 1, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (grid), radio_content,
radio_file, GTK_POS_BOTTOM, 1, 1);
open = gtk_button_new_with_label ("Trigger App Chooser dialog");
gtk_grid_attach_next_to (GTK_GRID (grid), open,
radio_content, GTK_POS_BOTTOM, 1, 1);
recommended = gtk_check_button_new_with_label ("Show recommended");
gtk_grid_attach_next_to (GTK_GRID (grid), recommended,
open, GTK_POS_BOTTOM, 1, 1);
g_object_set (recommended, "active", TRUE, NULL);
fallback = gtk_check_button_new_with_label ("Show fallback");
gtk_grid_attach_next_to (GTK_GRID (grid), fallback,
recommended, GTK_POS_RIGHT, 1, 1);
other = gtk_check_button_new_with_label ("Show other");
gtk_grid_attach_next_to (GTK_GRID (grid), other,
fallback, GTK_POS_RIGHT, 1, 1);
all = gtk_check_button_new_with_label ("Show all");
gtk_grid_attach_next_to (GTK_GRID (grid), all,
other, GTK_POS_RIGHT, 1, 1);
def = gtk_check_button_new_with_label ("Show default");
gtk_grid_attach_next_to (GTK_GRID (grid), def,
all, GTK_POS_RIGHT, 1, 1);
g_object_set (recommended, "active", TRUE, NULL);
prepare_dialog ();
g_signal_connect (open, "clicked",
G_CALLBACK (display_dialog), NULL);
gtk_container_add (GTK_CONTAINER (toplevel), grid);
gtk_widget_show_all (toplevel);
g_signal_connect (toplevel, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *canvas;
GtkWidget *font_button;
GtkWidget *g_button;
GtkWidget *d_button;
GtkWidget *str;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label1, *label2;
GtkWidget *spin;
PangoFontDescription *desc;
if (argc == 2) {
if (get_conf (argv[1]))
printf ("Error reading configuration. Use defaults\n");
}
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Font converter");
hbox = gtk_hbox_new (FALSE, 10);
label1 = gtk_label_new ("Text: ");
font_button = gtk_font_button_new_with_font (get_fontname());
d_button = gtk_button_new_with_label ("Draw");
g_button = gtk_button_new_with_label ("G Code");
str = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (str), 15);
gtk_entry_set_text (GTK_ENTRY (str), get_string());
label2 = gtk_label_new ("Width (inch): ");
spin = gtk_spin_button_new_with_range (3, 120, 1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spin), 2);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), (double)10);
gtk_box_pack_start (GTK_BOX (hbox), label1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), str, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), font_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), d_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), g_button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 0);
canvas = gtk_drawing_area_new();
gtk_widget_set_size_request (canvas, 1200, 600);
vbox = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), canvas, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (g_button), "spin", spin);
gtk_container_add (GTK_CONTAINER (window), vbox);
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT (canvas), "expose_event",
G_CALLBACK(expose_event), str);
g_signal_connect(G_OBJECT (font_button), "font_set",
G_CALLBACK(font_button_clicked), NULL);
g_signal_connect(G_OBJECT (g_button), "clicked",
G_CALLBACK(g_button_clicked), str);
g_signal_connect(G_OBJECT (d_button), "clicked",
G_CALLBACK(d_button_clicked), canvas);
gtk_widget_show_all(window);
map = pango_ft2_font_map_new ();
ctx = pango_font_map_create_context (map);
desc = pango_font_description_from_string (get_fontname());
set_font (desc);
gtk_main();
g_object_unref (map);
g_object_unref (ctx);
return 0;
}
void uade_gui_seek_subsong(int to)
{
GtkWidget *seek_button_box;
GtkWidget *prev_next_button_box;
GtkWidget *seek_button_vbox;
GtkWidget *seek_slider_box;
GtkWidget *hscale;
GtkWidget *prev_button;
GtkWidget *prev_button_frame;
GtkWidget *frame;
GtkWidget *maxsong_label;
GtkWidget *next_button,*ffwd_button;
GtkWidget *ffwd_button_frame;
if (!uade_thread_running) {
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "uade: BUG! Seek not possible.\n");
return;
}
if (seekpopup == NULL) {
/* uade's subsong popup */
seekpopup = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(seekpopup), "UADE seek subsong");
gtk_window_set_position(GTK_WINDOW(seekpopup), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(seekpopup), 0);
gtk_window_set_policy(GTK_WINDOW(seekpopup), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(seekpopup), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&seekpopup);
gtk_signal_connect(GTK_OBJECT(seekpopup), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
gtk_widget_realize(seekpopup);
gdk_window_set_decorations(seekpopup->window, 0);
/* define Slider code, will be used by all styles of the popup */
if (uade_get_max_subsong(-1) >= 0) {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
uade_get_max_subsong(0), 1, 0, 0); /*our scale for the subsong slider */
maxsong_label =
gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0))); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
} else {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
(uade_get_max_subsong(0)) + 10, 1, 0, 0); /*our scale for the subsong slider */
/*currently: min - min+10 */
maxsong_label = gtk_label_new("..."); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
}
hscale = gtk_hscale_new(GTK_ADJUSTMENT(subsong_adj));
gtk_widget_set_usize(hscale, 160, -1);
gtk_scale_set_digits(GTK_SCALE(hscale), 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_LEFT);
gtk_scale_set_draw_value(GTK_SCALE(hscale), TRUE);
gtk_range_set_update_policy(GTK_RANGE(hscale),
GTK_UPDATE_DISCONTINUOUS);
gtk_signal_connect_object(GTK_OBJECT(subsong_adj), "value_changed",
GTK_SIGNAL_FUNC(uade_seek_directly),
NULL);
/* previous subsong button, will be used by all styles of the seek popup*/
prev_button = gtk_button_new_with_label("<");
gtk_widget_set_usize(prev_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(prev_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_previous),
NULL);
prev_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(prev_button_frame),
GTK_SHADOW_IN);
/* next subsong button, will be used by all styles of the seek popup*/
next_button = gtk_button_new_with_label(">");
gtk_widget_set_usize(next_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(next_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_next), NULL);
ffwd_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(ffwd_button_frame),
GTK_SHADOW_IN);
ffwd_button = gtk_button_new_with_label("10s fwd");
gtk_widget_set_usize(ffwd_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(ffwd_button), "clicked",
GTK_SIGNAL_FUNC(uade_ffwd), NULL);
/* with the alternative styles of the subsongseeker,
* following suggestions made by David Le Corfec*/
seek_button_box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(seekpopup), seek_button_box);
frame = gtk_frame_new(NULL);
gtk_box_pack_start_defaults(GTK_BOX(seek_button_box), frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
seek_button_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), seek_button_vbox);
gtk_signal_connect(GTK_OBJECT(seek_button_vbox), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
prev_next_button_box = gtk_hbox_new(FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
prev_button_frame);
gtk_container_add(GTK_CONTAINER(prev_button_frame),
prev_next_button_box);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
prev_button);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
next_button);
seek_slider_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(seek_button_vbox), seek_slider_box,
FALSE, FALSE, 0);
/* use the previous defined slider and label here */
gtk_box_pack_start(GTK_BOX(seek_slider_box), hscale, FALSE, FALSE,
0);
gtk_box_pack_start(GTK_BOX(seek_slider_box), maxsong_label, FALSE,
FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
ffwd_button_frame);
gtk_container_add(GTK_CONTAINER(ffwd_button_frame),
ffwd_button);
gtk_widget_show_all(seekpopup);
seekpopup_open = 1;
} else {
gdk_window_raise(seekpopup->window);
}
}
void show_about_window(void)
{
static GtkWidget *about_window = NULL;
static GdkPixmap *xmms_logo_pmap = NULL, *xmms_logo_mask = NULL;
GtkWidget *about_vbox, *about_notebook;
GtkWidget *about_credits_logo_box, *about_credits_logo_frame;
GtkWidget *about_credits_logo;
GtkWidget *bbox, *close_btn;
GtkWidget *label, *list;
gchar *text;
if (about_window)
return;
about_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(about_window), _("About XMMS"));
gtk_window_set_policy(GTK_WINDOW(about_window), FALSE, TRUE, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(about_window), 10);
gtk_signal_connect(GTK_OBJECT(about_window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), &about_window);
gtk_signal_connect(GTK_OBJECT(about_window), "key_press_event",
util_dialog_keypress_cb, NULL);
gtk_widget_realize(about_window);
about_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(about_window), about_vbox);
if (!xmms_logo_pmap)
xmms_logo_pmap =
gdk_pixmap_create_from_xpm_d(about_window->window,
&xmms_logo_mask, NULL,
xmms_logo);
about_credits_logo_box = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(about_vbox), about_credits_logo_box,
FALSE, FALSE, 0);
about_credits_logo_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(about_credits_logo_frame),
GTK_SHADOW_OUT);
gtk_box_pack_start(GTK_BOX(about_credits_logo_box),
about_credits_logo_frame, FALSE, FALSE, 0);
about_credits_logo = gtk_pixmap_new(xmms_logo_pmap, xmms_logo_mask);
gtk_container_add(GTK_CONTAINER(about_credits_logo_frame),
about_credits_logo);
text = g_strdup_printf(_("XMMS %s - Cross platform multimedia player"),
VERSION);
label = gtk_label_new(text);
g_free(text);
gtk_box_pack_start(GTK_BOX(about_vbox), label, FALSE, FALSE, 0);
label = gtk_label_new(_("Copyright (C) 1997-2004 4Front Technologies "
"and The XMMS Team"));
gtk_box_pack_start(GTK_BOX(about_vbox), label, FALSE, FALSE, 0);
about_notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(about_vbox), about_notebook, TRUE, TRUE, 0);
list = generate_credit_list(credit_text, TRUE);
gtk_notebook_append_page(GTK_NOTEBOOK(about_notebook), list,
gtk_label_new(_("Credits")));
list = generate_credit_list(translators, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(about_notebook), list,
gtk_label_new(_("Translators")));
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(about_vbox), bbox, FALSE, FALSE, 0);
close_btn = gtk_button_new_with_label(_("Close"));
gtk_signal_connect_object(GTK_OBJECT(close_btn), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(about_window));
GTK_WIDGET_SET_FLAGS(close_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), close_btn, TRUE, TRUE, 0);
gtk_widget_grab_default(close_btn);
gtk_widget_show_all(about_window);
}
