LPSTR
create_keyval (HWND hwnd, LPCSTR attrs, BOOL *verify_conn)
{
GtkWidget *gensetup, *dialog_vbox1, *fixed1;
GtkWidget *l_comment, *scrolledwindow1, *clist1;
GtkWidget *l_key, *l_value, *t_keyword, *t_value, *l_copyright;
GtkWidget *vbuttonbox1, *b_add, *b_update, *l_keyword, *l_valeur;
GtkWidget *dialog_action_area1, *hbuttonbox1, *b_ok, *b_cancel;
GtkWidget *cb_verify;
guint button_key;
GtkAccelGroup *accel_group;
TGENSETUP gensetup_t;
char buff[1024];
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return (LPSTR) attrs;
accel_group = gtk_accel_group_new ();
gensetup = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (gensetup), "gensetup", gensetup);
gtk_window_set_title (GTK_WINDOW (gensetup), "Advanced File DSN Creation Settings");
gtk_window_set_position (GTK_WINDOW (gensetup), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (gensetup), TRUE);
gtk_window_set_policy (GTK_WINDOW (gensetup), FALSE, FALSE, FALSE);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (gensetup);
#endif
dialog_vbox1 = GTK_DIALOG (gensetup)->vbox;
gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
fixed1 = gtk_fixed_new ();
gtk_widget_ref (fixed1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "fixed1", fixed1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (fixed1), 6);
l_comment = gtk_label_new ("If you know the driver-specific keywords for this data source, you can type them and their values here. For more information on driver-specific keywords, please consult your ODBC driver documentation.");
gtk_widget_ref (l_comment);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_comment", l_comment,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_comment);
gtk_fixed_put (GTK_FIXED (fixed1), l_comment, 8, 7);
gtk_widget_set_uposition (l_comment, 8, 7);
gtk_widget_set_usize (l_comment, 330, 70);
gtk_label_set_justify (GTK_LABEL (l_comment), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_comment), TRUE);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "scrolledwindow1",
scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_fixed_put (GTK_FIXED (fixed1), scrolledwindow1, 8, 88);
gtk_widget_set_uposition (scrolledwindow1, 8, 88);
gtk_widget_set_usize (scrolledwindow1, 320, 184);
clist1 = gtk_clist_new (2);
gtk_widget_ref (clist1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "clist1", clist1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 137);
gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist1));
l_key = gtk_label_new (szKeysColumnNames[0]);
gtk_widget_ref (l_key);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_key", l_key,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_key);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, l_key);
l_value = gtk_label_new (szKeysColumnNames[1]);
gtk_widget_ref (l_value);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_value", l_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_value);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, l_value);
t_keyword = gtk_entry_new ();
gtk_widget_ref (t_keyword);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_keyword", t_keyword,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (t_keyword);
gtk_fixed_put (GTK_FIXED (fixed1), t_keyword, 80, 288);
gtk_widget_set_uposition (t_keyword, 80, 288);
gtk_widget_set_usize (t_keyword, 158, 22);
t_value = gtk_entry_new ();
gtk_widget_ref (t_value);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_value", t_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (t_value);
gtk_fixed_put (GTK_FIXED (fixed1), t_value, 80, 320);
gtk_widget_set_uposition (t_value, 80, 320);
gtk_widget_set_usize (t_value, 158, 22);
vbuttonbox1 = gtk_vbutton_box_new ();
gtk_widget_ref (vbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "vbuttonbox1", vbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbuttonbox1);
gtk_fixed_put (GTK_FIXED (fixed1), vbuttonbox1, 248, 280);
gtk_widget_set_uposition (vbuttonbox1, 248, 280);
gtk_widget_set_usize (vbuttonbox1, 85, 69);
b_add = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_add)->child),
szKeysButtons[0]);
gtk_widget_add_accelerator (b_add, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_add);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_add", b_add,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_add);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_add);
GTK_WIDGET_SET_FLAGS (b_add, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_add, "clicked", accel_group,
'A', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
b_update = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_update)->child),
szKeysButtons[1]);
gtk_widget_add_accelerator (b_update, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_update);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_update", b_update,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_update);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_update);
GTK_WIDGET_SET_FLAGS (b_update, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_update, "clicked", accel_group,
'U', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive (b_update, FALSE);
l_keyword = gtk_label_new ("Keyword : ");
gtk_widget_ref (l_keyword);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_keyword", l_keyword,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_keyword);
gtk_fixed_put (GTK_FIXED (fixed1), l_keyword, 8, 290);
gtk_widget_set_uposition (l_keyword, 8, 290);
gtk_widget_set_usize (l_keyword, 69, 16);
gtk_label_set_justify (GTK_LABEL (l_keyword), GTK_JUSTIFY_LEFT);
l_valeur = gtk_label_new ("Value : ");
gtk_widget_ref (l_valeur);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_valeur", l_valeur,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_valeur);
gtk_fixed_put (GTK_FIXED (fixed1), l_valeur, 8, 323);
gtk_widget_set_uposition (l_valeur, 8, 323);
gtk_widget_set_usize (l_valeur, 51, 16);
gtk_label_set_justify (GTK_LABEL (l_valeur), GTK_JUSTIFY_LEFT);
cb_verify = gtk_check_button_new_with_label ("Verify this connection(recommended)");
gtk_widget_ref (cb_verify);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "cb_verify",
cb_verify, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (cb_verify);
gtk_fixed_put (GTK_FIXED (fixed1), cb_verify, 8, 350);
gtk_widget_set_uposition (cb_verify, 8, 350);
gtk_widget_set_usize (cb_verify, 230, 24);
dialog_action_area1 = GTK_DIALOG (gensetup)->action_area;
gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_action_area1",
dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
b_ok = gtk_button_new_with_label ("");
button_key =
gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_ok)->child), "_Ok");
gtk_widget_add_accelerator (b_ok, "clicked", accel_group, button_key,
GDK_MOD1_MASK, 0);
gtk_widget_ref (b_ok);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_ok", b_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_ok);
GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_ok, "clicked", accel_group,
'O', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
b_cancel = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_cancel)->child),
"_Cancel");
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_cancel);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_cancel", b_cancel,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_cancel);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
'C', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_ok), "clicked",
GTK_SIGNAL_FUNC (gensetup_ok_clicked), &gensetup_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (gensetup_cancel_clicked), &gensetup_t);
/* Add button events */
gtk_signal_connect (GTK_OBJECT (b_add), "clicked",
GTK_SIGNAL_FUNC (gensetup_add_clicked), &gensetup_t);
/* Update button events */
gtk_signal_connect (GTK_OBJECT (b_update), "clicked",
GTK_SIGNAL_FUNC (gensetup_update_clicked), &gensetup_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (gensetup), "delete_event",
GTK_SIGNAL_FUNC (delete_event), &gensetup_t);
gtk_signal_connect (GTK_OBJECT (gensetup), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* List events */
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (gensetup_list_select), &gensetup_t);
gtk_signal_connect (GTK_OBJECT (clist1), "unselect_row",
GTK_SIGNAL_FUNC (gensetup_list_unselect), &gensetup_t);
gtk_window_add_accel_group (GTK_WINDOW (gensetup), accel_group);
gensetup_t.dsn_entry = NULL;
gensetup_t.key_list = clist1;
gensetup_t.bupdate = b_update;
gensetup_t.key_entry = t_keyword;
gensetup_t.value_entry = t_value;
gensetup_t.mainwnd = gensetup;
gensetup_t.verify_conn_cb = cb_verify;
gensetup_t.verify_conn = *verify_conn;
gtk_toggle_button_set_active(cb_verify, *verify_conn);
/* Parse the attributes line */
parse_attribute_line (&gensetup_t, NULL, attrs, TRUE);
gtk_widget_show_all (gensetup);
gtk_main ();
*verify_conn = gensetup_t.verify_conn;
return gensetup_t.connstr;
}
int zar_spisr_m(class zar_spisr_rek *rek,GtkWidget *wpredok)
{
class zar_spisr_m_data data;
char strsql[512];
iceb_u_str kikz;
data.rk=rek;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
GtkWidget *label=NULL;
sprintf(strsql,"%s\n%s",gettext("Распечатать список работников"),
gettext("Если код подразделения не ввести, то получите список по всем подразделениям"));
label=gtk_label_new(iceb_u_toutf(strsql));
sprintf(strsql,"%s %s",name_system,gettext("Распечатать список работников"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(zar_spisr_m_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
GtkWidget *separator1=gtk_hseparator_new();
GtkWidget *separator3=gtk_hseparator_new();
gtk_container_add (GTK_CONTAINER (vbox), separator1);
//Вставляем радиокнопки
GSList *group;
data.radiobutton2[0]=gtk_radio_button_new_with_label(NULL,gettext("Список всех работающих"));
gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[0], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.radiobutton2[0]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_0),&data);
//gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0");
group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton2[0]));
data.radiobutton2[1]=gtk_radio_button_new_with_label(group,gettext("Список всех уволенных"));
gtk_signal_connect(GTK_OBJECT(data.radiobutton2[1]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_1),&data);
gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[1], TRUE, TRUE, 0);
group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton2[1]));
data.radiobutton2[2]=gtk_radio_button_new_with_label(group,gettext("Список всех совместителей"));
gtk_signal_connect(GTK_OBJECT(data.radiobutton2[2]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_2),&data);
gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[2], TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk->metka_ras]),TRUE); //Устанавливем активной кнопку
gtk_container_add (GTK_CONTAINER (vbox), separator3);
GtkWidget *separator4=gtk_hseparator_new();
GtkWidget *separator5=gtk_hseparator_new();
gtk_container_add (GTK_CONTAINER (vbox), separator4);
GSList *group2;
data.radiobutton1[0]=gtk_radio_button_new_with_label(NULL,gettext("Сортировка по табельным номерам"));
gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton1[0], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.radiobutton1[0]), "clicked",GTK_SIGNAL_FUNC(spisr_radio1_0),&data);
//gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0");
group2=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton1[0]));
data.radiobutton1[1]=gtk_radio_button_new_with_label(group2,gettext("Сортировка по фамилиям"));
gtk_signal_connect(GTK_OBJECT(data.radiobutton1[1]), "clicked",GTK_SIGNAL_FUNC(spisr_radio1_1),&data);
gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton1[1], TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton1[data.rk->metka_sort]),TRUE); //Устанавливем активной кнопку
gtk_container_add (GTK_CONTAINER (vbox), separator5);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);
GtkTooltips *tooltips_enter[KOLENTER];
sprintf(strsql,"%s (,,)",gettext("Код подразделения"));
data.knopka_enter[E_PODR]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.knopka_enter[E_PODR], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_PODR]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_PODR]),(gpointer)E_PODR);
tooltips_enter[E_PODR]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_PODR],data.knopka_enter[E_PODR],gettext("Выбор подразделения"),NULL);
data.entry[E_PODR] = gtk_entry_new();
gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.entry[E_PODR], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_PODR]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_PODR]),data.rk->podr.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_PODR]),(gpointer)E_PODR);
sprintf(strsql,"%s (,,)",gettext("Табельный номер"));
data.knopka_enter[E_TABNOM]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.knopka_enter[E_TABNOM], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_TABNOM]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_TABNOM]),(gpointer)E_TABNOM);
tooltips_enter[E_TABNOM]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_TABNOM],data.knopka_enter[E_TABNOM],gettext("Выбор табельного номера"),NULL);
data.entry[E_TABNOM] = gtk_entry_new();
gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.entry[E_TABNOM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_TABNOM]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_TABNOM]),data.rk->podr.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_TABNOM]),(gpointer)E_TABNOM);
sprintf(strsql,"%s (,,)",gettext("Код звания"));
data.knopka_enter[E_KOD_ZVAN]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZVAN]), data.knopka_enter[E_KOD_ZVAN], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_ZVAN]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_ZVAN]),(gpointer)E_KOD_ZVAN);
tooltips_enter[E_KOD_ZVAN]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_KOD_ZVAN],data.knopka_enter[E_KOD_ZVAN],gettext("Выбор звания"),NULL);
data.entry[E_KOD_ZVAN] = gtk_entry_new();
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZVAN]), data.entry[E_KOD_ZVAN], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_ZVAN]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_ZVAN]),data.rk->kod_zvan.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_ZVAN]),(gpointer)E_KOD_ZVAN);
sprintf(strsql,"%s (,,)",gettext("Код категории"));
data.knopka_enter[E_KOD_KATEG]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_KATEG]), data.knopka_enter[E_KOD_KATEG], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_KATEG]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_KATEG]),(gpointer)E_KOD_KATEG);
tooltips_enter[E_KOD_KATEG]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_KOD_KATEG],data.knopka_enter[E_KOD_KATEG],gettext("Выбор категории"),NULL);
data.entry[E_KOD_KATEG] = gtk_entry_new();
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_KATEG]), data.entry[E_KOD_KATEG], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_KATEG]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_KATEG]),data.rk->kod_kateg.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_KATEG]),(gpointer)E_KOD_KATEG);
sprintf(strsql,"%s (,,)",gettext("Счёт"));
data.knopka_enter[E_SHETU]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_SHETU]), data.knopka_enter[E_SHETU], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHETU]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHETU]),(gpointer)E_SHETU);
tooltips_enter[E_SHETU]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_SHETU],data.knopka_enter[E_SHETU],gettext("Выбор счёта в плане счетов"),NULL);
data.entry[E_SHETU] = gtk_entry_new();
gtk_box_pack_start (GTK_BOX (hbox[E_SHETU]), data.entry[E_SHETU], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_SHETU]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHETU]),data.rk->shetu.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHETU]),(gpointer)E_SHETU);
GtkTooltips *tooltips[KOL_FK];
sprintf(strsql,"F2 %s",gettext("Расчёт"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчёт"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);
sprintf(strsql,"F4 %s",gettext("Очистить"));
data.knopka[FK4]=gtk_button_new_with_label(strsql);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введеноой информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);
gtk_widget_grab_focus(data.entry[0]);
gtk_widget_show_all (data.window);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
struct master *add_master_dialog (struct master *m) {
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *table;
GtkWidget *option_menu;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *hseparator;
char *typestr;
enum master_query_type i;
struct master *master_to_edit;
char *windowtitle;
master_name_result = NULL;
master_addr_result = NULL;
current_master_query_type = MASTER_NATIVE;
master_to_edit = NULL;
master_to_add = NULL;
for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++)
master_query_type_radios[i]=NULL;
master_to_edit = m;
if (master_to_edit) {
current_master_query_type = master_to_edit->master_type;
master_type = master_to_edit->type;
}
else {
// Get last game type added (stored in master_okbutton_callback)
typestr = config_get_string ("/" CONFIG_FILE "/Add Master/game");
if (typestr) {
master_type = id2type (typestr);
g_free (typestr);
}
else {
master_type = QW_SERVER;
}
}
if (master_to_edit) {
windowtitle=_("Rename Master");
}
else {
windowtitle=_("Add Master");
}
window = dialog_create_modal_transient_window(windowtitle, TRUE, FALSE, NULL);
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 16);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
/* Master Name (Description) */
label = gtk_label_new (_("Master Name"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 4);
gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 0, 1);
master_name_combo = gtk_combo_new ();
gtk_widget_set_usize (master_name_combo, 200, -1);
gtk_box_pack_start (GTK_BOX (hbox), master_name_combo, TRUE, TRUE, 0);
gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), 256);
gtk_combo_set_case_sensitive (GTK_COMBO (master_name_combo), TRUE);
gtk_combo_set_use_arrows_always (GTK_COMBO (master_name_combo), TRUE);
gtk_combo_disable_activate (GTK_COMBO (master_name_combo));
gtk_signal_connect(
GTK_OBJECT (GTK_COMBO (master_name_combo)->entry), "activate",
GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));
GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_name_combo)->entry, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_name_combo)->button, GTK_CAN_FOCUS);
gtk_widget_grab_focus (GTK_COMBO (master_name_combo)->entry);
gtk_widget_show (master_name_combo);
if (master_history_name->items)
combo_set_vals (master_name_combo, master_history_name->items, "");
if (master_to_edit) {
gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), master_to_edit->name);
}
/* Master Type Option Menu */
option_menu = create_server_type_menu (master_type, create_server_type_menu_filter_configured, GTK_SIGNAL_FUNC(select_master_type_callback));
gtk_box_pack_start (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
if (master_to_edit) {
gtk_widget_set_state (option_menu, GTK_STATE_NORMAL);
gtk_widget_set_sensitive (GTK_WIDGET(option_menu),FALSE);
}
gtk_widget_show (option_menu);
gtk_widget_show (hbox);
/* Master Address */
label = gtk_label_new (_("Master Address"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
master_addr_combo = gtk_combo_new ();
gtk_table_attach_defaults (GTK_TABLE (table), master_addr_combo, 1, 2, 1, 2);
gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), 4096);
gtk_combo_set_case_sensitive (GTK_COMBO (master_addr_combo), TRUE);
gtk_combo_set_use_arrows_always (GTK_COMBO (master_addr_combo), TRUE);
gtk_combo_disable_activate (GTK_COMBO (master_addr_combo));
gtk_signal_connect (
GTK_OBJECT (GTK_COMBO (master_addr_combo)->entry), "activate",
GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));
gtk_signal_connect (
GTK_OBJECT (GTK_COMBO (master_addr_combo)->list),
"selection-changed",
GTK_SIGNAL_FUNC
(master_address_from_history_selected_callback),NULL);
GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_addr_combo)->entry, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_addr_combo)->button, GTK_CAN_FOCUS);
// gtk_widget_grab_focus (GTK_COMBO (master_addr_combo)->entry);
gtk_widget_show (master_addr_combo);
if (master_history_addr->items)
combo_set_vals (master_addr_combo, master_history_addr->items, "");
if (master_to_edit) {
char* url = master_to_url(master_to_edit);
gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), url);
gtk_widget_set_state (master_addr_combo, GTK_STATE_NORMAL);
gtk_widget_set_sensitive (GTK_WIDGET(master_addr_combo),FALSE);
g_free(url);
}
gtk_widget_show (table);
/* query type */
hbox = gtk_hbox_new (TRUE, 8);
for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++) {
master_query_type_radios[i] =
gtk_radio_button_new_with_label_from_widget(
i==MASTER_NATIVE?NULL:GTK_RADIO_BUTTON(master_query_type_radios[MASTER_NATIVE]),
_(master_designation[i]));
if (master_to_edit) {
gtk_widget_set_sensitive (GTK_WIDGET(master_query_type_radios[i]),FALSE);
}
gtk_signal_connect(GTK_OBJECT (master_query_type_radios[i]), "toggled",
GTK_SIGNAL_FUNC (master_type_radio_callback), (gpointer)i);
gtk_widget_show (master_query_type_radios[i]);
gtk_box_pack_start (GTK_BOX (hbox),master_query_type_radios[i], FALSE, FALSE, 0);
}
if (master_to_edit) {
master_activate_radio_for_type(current_master_query_type);
}
else if (!games[master_type].default_master_port &&
current_master_query_type == MASTER_NATIVE) {
gtk_widget_set_state (master_query_type_radios[MASTER_NATIVE], GTK_STATE_NORMAL);
gtk_widget_set_sensitive
(GTK_WIDGET(master_query_type_radios[MASTER_NATIVE]),FALSE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(master_query_type_radios[MASTER_GAMESPY]),TRUE);
}
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
/* Separator */
hseparator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), hseparator, FALSE, FALSE, 0);
gtk_widget_show (hseparator);
/* Buttons */
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
/* Cancel Button */
button = gtk_button_new_with_label (_("Cancel"));
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_set_usize (button, 80, -1);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
/* OK Button */
button = gtk_button_new_with_label ("OK");
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_set_usize (button, 80, -1);
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(master_okbutton_callback), window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (hbox);
gtk_widget_show (main_vbox);
gtk_widget_show (window);
gtk_main ();
unregister_window (window);
return master_to_add;
}
void gtkgui_toggle_lineout(bool i)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speakout), i);
}
static GtkWidget *p_create_frame_missing(struct LibravatarPrefsPage *page)
{
GtkWidget *vbox, *radio[NUM_DEF_BUTTONS], *hbox, *entry;
gboolean enable = FALSE;
int i, e = 0;
gchar *radio_label[] = {
_("None"),
_("Mystery man"),
_("Identicon"),
_("MonsterID"),
_("Wavatar"),
_("Retro"),
_("Custom URL")
};
gchar *radio_hint[] = {
_("A blank image"),
_("The unobtrusive low-contrast greyish silhouette"),
_("A generated geometric pattern"),
_("A generated full-body monster"),
_("A generated almost unique face"),
_("A generated 8-bit arcade-style pixelated image"),
_("Redirect to a user provided URL")
};
vbox = gtk_vbox_new(FALSE, 6);
for (i = 0; i < NUM_DEF_BUTTONS; ++i) {
enable = (libravatarprefs.default_mode == radio_value[i])? TRUE: FALSE;
e += enable? 1: 0;
radio[i] = gtk_radio_button_new_with_label_from_widget(
(i > 0)? GTK_RADIO_BUTTON(radio[i - 1]): NULL, radio_label[i]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio[i]), enable);
if (i == CUSTOM_URL_BUTTON_INDEX) {
/* set related entry next to radio button */
entry = gtk_entry_new_with_max_length(MAX_URL_LENGTH);
CLAWS_SET_TIP(entry, _("Enter the URL you want to be "
"redirected when no user icon is available. "
"Leave an empty URL to use the default "
"libravatar orange icon."));
gtk_widget_show(entry);
gtk_entry_set_text(GTK_ENTRY(entry),
libravatarprefs.default_mode_url);
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(hbox), radio[i], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
gtk_widget_set_sensitive(entry,
(libravatarprefs.default_mode == DEF_MODE_URL)
? TRUE: FALSE);
page->defm_url_text = entry;
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
} else {
gtk_box_pack_start(GTK_BOX(vbox), radio[i], FALSE, FALSE, 0);
}
g_signal_connect(radio[i], "toggled",
G_CALLBACK(default_mode_radio_button_cb),
(gpointer) &(radio_value[i]));
CLAWS_SET_TIP(radio[i], radio_hint[i]);
gtk_widget_show(radio[i]);
page->defm_radio[i] = radio[i];
}
if (e == 0) { /* unknown value, go default */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio[0]), TRUE);
libravatarprefs.default_mode = DEF_MODE_NONE;
}
/* don't waste time with headers that won't be displayed */
prefs_common_get_prefs()->enable_avatars =
(libravatarprefs.default_mode == DEF_MODE_NONE)
? AVATARS_ENABLE_BOTH: AVATARS_DISABLE;
return vbox;
}
int main (int argc, char *argv[])
{
GtkWidget *load_button;
GtkWidget *table;
GtkWidget *pixmapwid;
GtkStyle *style;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkWidget *label_core;
GList *glist_gfx = NULL;
GtkWidget *label_gfx;
GtkWidget *config_gfx_button;
GtkWidget *test_gfx_button;
GtkWidget *about_gfx_button;
GList *glist_audio = NULL;
GtkWidget *label_audio;
GtkWidget *config_audio_button;
GtkWidget *test_audio_button;
GtkWidget *about_audio_button;
GList *glist_input = NULL;
GtkWidget *label_input;
GtkWidget *config_input_button;
GtkWidget *test_input_button;
GtkWidget *about_input_button;
GList *glist_RSP = NULL;
GtkWidget *label_RSP;
GtkWidget *config_RSP_button;
GtkWidget *test_RSP_button;
GtkWidget *about_RSP_button;
#ifdef DBG
if (!g_thread_supported())
g_thread_init(NULL);
else
{
fprintf(stderr, "mupen64 will certainly have problems with GTK threads.\n");
fprintf(stderr, "Check your GLIB/GDK/GTK installation for thread support.\n");
}
#endif
gtk_init(&argc, &argv);
if (argv[0][0] != '/')
{
getcwd(cwd, 1024);
strcat(cwd, "/");
strcat(cwd, argv[0]);
}
else
strcpy(cwd, argv[0]);
while(cwd[strlen(cwd)-1] != '/') cwd[strlen(cwd)-1] = '\0';
// création de la fenêtre
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_widget_show(window);
// création du bouton Load rom
load_button = gtk_button_new_with_label("Load rom...");
gtk_widget_show(load_button);
// création du logo
style = gtk_widget_get_style(window);
pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **)logo_xpm);
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmapwid);
// création de la selection du mode d'émulation
label_core = gtk_frame_new("cpu core : ");
gtk_widget_show(label_core);
interp = gtk_radio_button_new_with_label(NULL, "interpreter");
gtk_widget_show(interp);
dynam = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)),
"dynamic compiler");
gtk_widget_show(dynam);
pure_interp = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)),
"pure interpreter");
gtk_widget_show(pure_interp);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dynam), TRUE);
// création de l'option 'debugger'
#ifdef DBG
button_debug = gtk_check_button_new_with_label("debugger mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_debug), FALSE);
gtk_widget_show(button_debug);
#endif
// recherche des plugins
plugin_scan_directory(cwd);
while(plugin_type() != -1)
switch (plugin_type())
{
case PLUGIN_TYPE_GFX:
glist_gfx = g_list_append(glist_gfx, plugin_next());
break;
case PLUGIN_TYPE_AUDIO:
glist_audio = g_list_append(glist_audio, plugin_next());
break;
case PLUGIN_TYPE_CONTROLLER:
glist_input = g_list_append(glist_input, plugin_next());
break;
case PLUGIN_TYPE_RSP:
glist_RSP = g_list_append(glist_RSP, plugin_next());
break;
}
label_gfx = gtk_frame_new("gfx plugin : ");
gtk_widget_show(label_gfx);
combo_gfx = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_gfx), glist_gfx);
gtk_combo_set_value_in_list(GTK_COMBO(combo_gfx), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_gfx)->entry), FALSE);
gtk_widget_show(combo_gfx);
config_gfx_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_gfx_button);
test_gfx_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_gfx_button);
about_gfx_button = gtk_button_new_with_label("About");
gtk_widget_show(about_gfx_button);
label_audio = gtk_frame_new("audio plugin : ");
gtk_widget_show(label_audio);
combo_audio = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_audio), glist_audio);
gtk_combo_set_value_in_list(GTK_COMBO(combo_audio), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_audio)->entry), FALSE);
gtk_widget_show(combo_audio);
config_audio_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_audio_button);
test_audio_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_audio_button);
about_audio_button = gtk_button_new_with_label("About");
gtk_widget_show(about_audio_button);
label_input = gtk_frame_new("input plugin : ");
gtk_widget_show(label_input);
combo_input = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_input), glist_input);
gtk_combo_set_value_in_list(GTK_COMBO(combo_input), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_input)->entry), FALSE);
gtk_widget_show(combo_input);
config_input_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_input_button);
test_input_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_input_button);
about_input_button = gtk_button_new_with_label("About");
gtk_widget_show(about_input_button);
label_RSP = gtk_frame_new("RSP plugin : ");
gtk_widget_show(label_RSP);
combo_RSP = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_RSP), glist_RSP);
gtk_combo_set_value_in_list(GTK_COMBO(combo_RSP), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_RSP)->entry), FALSE);
gtk_widget_show(combo_RSP);
config_RSP_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_RSP_button);
test_RSP_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_RSP_button);
about_RSP_button = gtk_button_new_with_label("About");
gtk_widget_show(about_RSP_button);
// mise en place des évenements
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(destroy), NULL);
gtk_signal_connect(GTK_OBJECT(load_button), "clicked",
GTK_SIGNAL_FUNC(load), NULL);
gtk_signal_connect(GTK_OBJECT(config_gfx_button), "clicked",
GTK_SIGNAL_FUNC(config_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(test_gfx_button), "clicked",
GTK_SIGNAL_FUNC(test_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(about_gfx_button), "clicked",
GTK_SIGNAL_FUNC(about_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(config_audio_button), "clicked",
GTK_SIGNAL_FUNC(config_audio), NULL);
gtk_signal_connect(GTK_OBJECT(test_audio_button), "clicked",
GTK_SIGNAL_FUNC(test_audio), NULL);
gtk_signal_connect(GTK_OBJECT(about_audio_button), "clicked",
GTK_SIGNAL_FUNC(about_audio), NULL);
gtk_signal_connect(GTK_OBJECT(config_input_button), "clicked",
GTK_SIGNAL_FUNC(config_input), NULL);
gtk_signal_connect(GTK_OBJECT(test_input_button), "clicked",
GTK_SIGNAL_FUNC(test_input), NULL);
gtk_signal_connect(GTK_OBJECT(about_input_button), "clicked",
GTK_SIGNAL_FUNC(about_input), NULL);
gtk_signal_connect(GTK_OBJECT(config_RSP_button), "clicked",
GTK_SIGNAL_FUNC(config_RSP), NULL);
gtk_signal_connect(GTK_OBJECT(test_RSP_button), "clicked",
GTK_SIGNAL_FUNC(test_RSP), NULL);
gtk_signal_connect(GTK_OBJECT(about_RSP_button), "clicked",
GTK_SIGNAL_FUNC(about_RSP), NULL);
// mise en page
table = gtk_table_new(55, 30, TRUE);
gtk_widget_show(table);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_table_attach_defaults(GTK_TABLE(table), load_button, 0, 10, 0, 3);
gtk_table_attach_defaults(GTK_TABLE(table), label_core, 0, 10, 5, 15);
gtk_table_attach_defaults(GTK_TABLE(table), pixmapwid, 10, 30, 0, 10);
gtk_table_attach_defaults(GTK_TABLE(table), interp, 1, 10, 6, 9);
gtk_table_attach_defaults(GTK_TABLE(table), dynam, 1, 10, 9, 12);
gtk_table_attach_defaults(GTK_TABLE(table), pure_interp, 1, 10, 12, 15);
#ifdef DBG
gtk_table_attach_defaults(GTK_TABLE(table), button_debug, 15, 25, 12, 15);
#endif
gtk_table_attach_defaults(GTK_TABLE(table), label_gfx, 0, 30, 15, 25);
gtk_table_attach_defaults(GTK_TABLE(table), combo_gfx, 1, 29, 17, 22);
gtk_table_attach_defaults(GTK_TABLE(table), config_gfx_button, 1, 10, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), test_gfx_button, 10, 20, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), about_gfx_button, 20, 29, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), label_audio, 0, 30, 25, 35);
gtk_table_attach_defaults(GTK_TABLE(table), combo_audio, 1, 29, 27, 32);
gtk_table_attach_defaults(GTK_TABLE(table), config_audio_button, 1, 10, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), test_audio_button, 10, 20, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), about_audio_button, 20, 29, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), label_input, 0, 30, 35, 45);
gtk_table_attach_defaults(GTK_TABLE(table), combo_input, 1, 29, 37, 42);
gtk_table_attach_defaults(GTK_TABLE(table), config_input_button, 1, 10, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), test_input_button, 10, 20, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), about_input_button, 20, 29, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), label_RSP, 0, 30, 45, 55);
gtk_table_attach_defaults(GTK_TABLE(table), combo_RSP, 1, 29, 47, 52);
gtk_table_attach_defaults(GTK_TABLE(table), config_RSP_button, 1, 10, 52, 54);
gtk_table_attach_defaults(GTK_TABLE(table), test_RSP_button, 10, 20, 52, 54);
gtk_table_attach_defaults(GTK_TABLE(table), about_RSP_button, 20, 29, 52, 54);
gtk_main();
return 0;
}
void gtkgui_toggle_mic(bool i)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mic), i);
}
void gui_reset(struct dt_iop_module_t *self)
{
dt_iop_monochrome_gui_data_t *g = (dt_iop_monochrome_gui_data_t *)self->gui_data;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->colorpicker), 0);
}
static gboolean dt_iop_monochrome_draw(GtkWidget *widget, cairo_t *crf, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_monochrome_gui_data_t *g = (dt_iop_monochrome_gui_data_t *)self->gui_data;
dt_iop_monochrome_params_t *p = (dt_iop_monochrome_params_t *)self->params;
if(self->request_color_pick == DT_REQUEST_COLORPICK_MODULE)
{
p->a = self->picked_color[1];
p->b = self->picked_color[2];
float da = self->picked_color_max[1] - self->picked_color_min[1];
float db = self->picked_color_max[2] - self->picked_color_min[2];
p->size = CLAMP((da + db)/128.0, .5, 3.0);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->colorpicker),
(self->request_color_pick == DT_REQUEST_COLORPICK_MODULE ? 1 : 0));
const int inset = DT_COLORCORRECTION_INSET;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int width = allocation.width, height = allocation.height;
cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cr = cairo_create(cst);
// clear bg
cairo_set_source_rgb(cr, .2, .2, .2);
cairo_paint(cr);
cairo_translate(cr, inset, inset);
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
width -= 2 * inset;
height -= 2 * inset;
// clip region to inside:
cairo_rectangle(cr, 0, 0, width, height);
cairo_clip(cr);
// flip y:
cairo_translate(cr, 0, height);
cairo_scale(cr, 1., -1.);
const int cells = 8;
for(int j = 0; j < cells; j++)
for(int i = 0; i < cells; i++)
{
double rgb[3] = { 0.5, 0.5, 0.5 };
cmsCIELab Lab;
Lab.L = 53.390011;
Lab.a = Lab.b = 0; // grey
// dt_iop_sRGB_to_Lab(rgb, Lab, 0, 0, 1.0, 1, 1); // get grey in Lab
Lab.a = PANEL_WIDTH * (i / (cells - 1.0) - .5);
Lab.b = PANEL_WIDTH * (j / (cells - 1.0) - .5);
const float f = color_filter(Lab.a, Lab.b, p->a, p->b, 40 * 40 * p->size * p->size);
Lab.L *= f * f; // exaggerate filter a little
cmsDoTransform(g->xform, &Lab, rgb, 1);
cairo_set_source_rgb(cr, rgb[0], rgb[1], rgb[2]);
cairo_rectangle(cr, width * i / (float)cells, height * j / (float)cells,
width / (float)cells - DT_PIXEL_APPLY_DPI(1),
height / (float)cells - DT_PIXEL_APPLY_DPI(1));
cairo_fill(cr);
}
cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
cairo_set_source_rgb(cr, .7, .7, .7);
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.0));
const float x = p->a * width / PANEL_WIDTH + width * .5f, y = p->b * height / PANEL_WIDTH + height * .5f;
cairo_arc(cr, x, y, width * .22f * p->size, 0, 2.0 * M_PI);
cairo_stroke(cr);
cairo_destroy(cr);
cairo_set_source_surface(crf, cst, 0, 0);
cairo_paint(crf);
cairo_surface_destroy(cst);
return TRUE;
}
LayerOptionsDialog *
layer_options_dialog_new (GimpImage *image,
GimpLayer *layer,
GimpContext *context,
GtkWidget *parent,
const gchar *layer_name,
GimpFillType layer_fill_type,
const gchar *title,
const gchar *role,
const gchar *icon_name,
const gchar *desc,
const gchar *help_id)
{
LayerOptionsDialog *options;
GimpViewable *viewable;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *spinbutton;
GtkWidget *frame;
GtkWidget *button;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
options = g_slice_new0 (LayerOptionsDialog);
options->image = image;
options->context = context;
options->layer = layer;
options->fill_type = layer_fill_type;
if (layer)
viewable = GIMP_VIEWABLE (layer);
else
viewable = GIMP_VIEWABLE (image);
options->dialog =
gimp_viewable_dialog_new (viewable, context,
title, role, icon_name, desc,
parent,
gimp_standard_help_func, help_id,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_object_weak_ref (G_OBJECT (options->dialog),
(GWeakNotify) layer_options_dialog_free, options);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_set_spacing (GTK_BOX (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (layer ? 1 : 3, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/* The name label and entry */
options->name_entry = gtk_entry_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Layer _name:"), 0.0, 0.5,
options->name_entry, 1, FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE);
gtk_entry_set_text (GTK_ENTRY (options->name_entry), layer_name);
if (! layer)
{
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
/* The size labels */
label = gtk_label_new (_("Width:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
/* The size sizeentry */
spinbutton = gimp_spin_button_new (&adjustment,
1, 1, 1, 1, 10, 0,
1, 2);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
options->size_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, TRUE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gtk_table_set_col_spacing (GTK_TABLE (options->size_se), 1, 4);
gtk_table_set_row_spacing (GTK_TABLE (options->size_se), 0, 2);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se),
GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton,
1, 2, 0, 1);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (options->size_se);
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se),
GIMP_UNIT_PIXEL);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0,
xres, FALSE);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1,
yres, FALSE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0,
0, gimp_image_get_width (image));
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1,
0, gimp_image_get_height (image));
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0,
gimp_image_get_width (image));
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1,
gimp_image_get_height (image));
/* The radio frame */
frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_FILL_TYPE,
GIMP_FOREGROUND_FILL,
GIMP_TRANSPARENT_FILL,
gtk_label_new (_("Layer Fill Type")),
G_CALLBACK (gimp_radio_button_update),
&options->fill_type,
&button);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button),
options->fill_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
else
{
GimpContainer *filters;
GtkWidget *frame;
GtkWidget *view;
/* For text layers add a toggle to control "auto-rename" */
if (gimp_item_is_text_layer (GIMP_ITEM (layer)))
{
options->rename_toggle =
gtk_check_button_new_with_mnemonic (_("Set name from _text"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->rename_toggle),
GIMP_TEXT_LAYER (layer)->auto_rename);
gtk_table_attach (GTK_TABLE (table), options->rename_toggle, 1, 2, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (options->rename_toggle);
g_signal_connect (options->rename_toggle, "toggled",
G_CALLBACK (layer_options_dialog_toggle_rename),
options);
}
frame = gimp_frame_new ("Active Filters");
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer));
view = gimp_container_tree_view_new (filters, context,
GIMP_VIEW_SIZE_SMALL, 0);
gtk_container_add (GTK_CONTAINER (frame), view);
gtk_widget_show (view);
}
return options;
}
gint dbgdata_display_dbox(gint *mode, gint *type, uint32_t *start, uint32_t *stop)
{
GtkWidget *dbox;
GtkWidget *data;
gint result;
G_CONST_RETURN gchar *sc_start, *sc_stop;
gchar *s_start, *s_stop;
xml = glade_xml_new
(tilp_paths_build_glade("dbg_data-2.glade"), "dbgdata_dbox",
PACKAGE);
if (!xml)
g_error(_("%s: GUI loading failed!\n"), __FILE__);
glade_xml_signal_autoconnect(xml);
dbox = glade_xml_get_widget(xml, "dbgdata_dbox");
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,-1);
data = glade_xml_get_widget(xml, "radiobutton20");
g_signal_emit_by_name(G_OBJECT(data), "toggled");
// set type
if(*type == -1)
{
// skip box preset step
}
else
{
data = glade_xml_get_widget(xml, "radiobutton10");
if(*mode & BK_READ)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);
data = glade_xml_get_widget(xml, "radiobutton11");
if(*mode & BK_WRITE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);
data = glade_xml_get_widget(xml, "radiobutton12");
if((*mode & BK_READ) && (*mode & BK_WRITE))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);
if(*type == BK_TYPE_ACCESS)
{
data = glade_xml_get_widget(xml, "radiobutton20");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);
data = glade_xml_get_widget(xml, "comboboxentry1");
if(*mode & BK_BYTE)
gtk_combo_box_set_active(GTK_COMBO_BOX(data), 0);
else if(*mode & BK_WORD)
gtk_combo_box_set_active(GTK_COMBO_BOX(data), 1);
else if(*mode & BK_LONG)
gtk_combo_box_set_active(GTK_COMBO_BOX(data), 2);
data = glade_xml_get_widget(xml, "entry3");
s_start = g_strdup_printf("0x%06x", *start);
gtk_entry_set_text(GTK_ENTRY(data), s_start);
g_free(s_start);
}
else if(*type == BK_TYPE_RANGE)
{
data = glade_xml_get_widget(xml, "radiobutton21");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE);
data = glade_xml_get_widget(xml, "entry1");
s_start = g_strdup_printf("0x%06x", *start);
gtk_entry_set_text(GTK_ENTRY(data), s_start);
g_free(s_start);
data = glade_xml_get_widget(xml, "entry2");
s_stop = g_strdup_printf("0x%06x", *stop);
gtk_entry_set_text(GTK_ENTRY(data), s_stop);
g_free(s_stop);
}
}
loop:
result = gtk_dialog_run(GTK_DIALOG(dbox));
switch (result) {
case GTK_RESPONSE_OK:
sc_start = sc_stop = "";
// Retrieve settings from fields
data = glade_xml_get_widget(xml, "radiobutton10");
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
*mode = BK_READ;
data = glade_xml_get_widget(xml, "radiobutton11");
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
*mode = BK_WRITE;
data = glade_xml_get_widget(xml, "radiobutton12");
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
*mode = BK_READ | BK_WRITE;
data = glade_xml_get_widget(xml, "radiobutton20");
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
*type = BK_TYPE_ACCESS;
data = glade_xml_get_widget(xml, "radiobutton21");
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
*type = BK_TYPE_RANGE;
if(*type == BK_TYPE_ACCESS)
{
data = glade_xml_get_widget(xml, "comboboxentry1");
switch(gtk_combo_box_get_active(GTK_COMBO_BOX(data)))
{
case 0: *mode |= BK_BYTE; break;
case 1: *mode |= BK_WORD; break;
case 2: *mode |= BK_LONG; break;
}
data = glade_xml_get_widget(xml, "entry3");
sc_start = sc_stop = gtk_entry_get_text(GTK_ENTRY(data));
}
else if(*type == BK_TYPE_RANGE)
{
data = glade_xml_get_widget(xml, "entry1");
sc_start = gtk_entry_get_text(GTK_ENTRY(data));
data = glade_xml_get_widget(xml, "entry2");
sc_stop = gtk_entry_get_text(GTK_ENTRY(data));
}
// Convert values and check
result = sscanf(sc_start, "%x", start);
if(result < 1)
goto loop;
result = sscanf(sc_stop, "%x", stop);
if((result < 1) && (*type == 2))
goto loop;
if((*start > *stop) && (*type == 2))
goto loop;
gtk_widget_destroy(dbox);
return 0;
default:
gtk_widget_destroy(dbox);
return -1;
}
return 0;
}
static void
thunar_location_entry_button_clicked (GtkWidget *button,
ThunarLocationEntry *location_entry)
{
ThunarShortcutsModel *model;
ThunarIconFactory *icon_factory;
ThunarVfsVolume *volume;
GtkIconTheme *icon_theme;
const gchar *icon_name;
GtkTreeIter iter;
ThunarFile *file;
GtkWidget *image;
GtkWidget *item;
GtkWidget *menu;
GdkPixbuf *icon;
gint icon_size;
gint width;
_thunar_return_if_fail (THUNAR_IS_LOCATION_ENTRY (location_entry));
_thunar_return_if_fail (GTK_IS_TOGGLE_BUTTON (button));
/* allocate a new menu */
menu = gtk_menu_new ();
/* determine the icon theme and factory */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (button));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
/* determine the icon size for menus */
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size);
/* load the menu items from the shortcuts model */
model = thunar_shortcuts_model_get_default ();
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter))
{
do
{
/* determine the file and volume for the item */
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
THUNAR_SHORTCUTS_MODEL_COLUMN_FILE, &file,
THUNAR_SHORTCUTS_MODEL_COLUMN_VOLUME, &volume,
-1);
/* check if we have a separator here */
if (G_UNLIKELY (file == NULL && volume == NULL))
{
/* generate a separator the menu */
item = gtk_separator_menu_item_new ();
}
else if (G_UNLIKELY (volume != NULL))
{
/* generate an image menu item for the volume */
item = gtk_image_menu_item_new_with_label (thunar_vfs_volume_get_name (volume));
/* load the icon for the volume */
icon_name = thunar_vfs_volume_lookup_icon_name (volume, icon_theme);
icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE);
if (G_LIKELY (icon != NULL))
{
/* generate an image for the menu item */
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
}
}
else
{
/* generate an image menu item for the file */
item = gtk_image_menu_item_new_with_label (thunar_file_get_display_name (file));
/* load the icon for the file and generate the image for the menu item */
icon = thunar_icon_factory_load_file_icon (icon_factory, file, THUNAR_FILE_ICON_STATE_DEFAULT, icon_size);
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
}
/* connect the file and volume to the item */
g_object_set_data_full (G_OBJECT (item), I_("thunar-vfs-volume"), volume, g_object_unref);
g_object_set_data_full (G_OBJECT (item), I_("thunar-file"), file, g_object_unref);
/* append the new item to the menu */
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (thunar_location_entry_item_activated), location_entry);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
}
/* make sure the menu has atleast the same width as the location entry */
width = GTK_WIDGET (location_entry)->allocation.width - 2 * gtk_container_get_border_width (GTK_CONTAINER (location_entry));
if (G_LIKELY (menu->allocation.width < width))
gtk_widget_set_size_request (menu, width, -1);
/* select the first visible or selectable item in the menu */
gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), TRUE);
/* enable the button, making sure that we do not recurse on the "clicked" signal by temporarily blocking the handler */
g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
/* run the menu, taking ownership over the menu object */
thunar_gtk_menu_run (GTK_MENU (menu), button, menu_position, location_entry, 1, gtk_get_current_event_time ());
/* disable the button, making sure that we do not recurse on the "clicked" signal by temporarily blocking the handler */
g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
/* clean up */
g_object_unref (G_OBJECT (icon_factory));
g_object_unref (G_OBJECT (model));
}
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data)
{ /* copied from interface.c */
GtkWidget *page;
GtkWidget *frame33;
GtkWidget *alignment36;
GtkWidget *vbox30;
GtkWidget *hbox10;
GtkWidget *label203;
PrintWidgets *w = user_data;
gtk_print_operation_set_custom_tab_label(operation, _("Document Setup"));
page = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(page), 5);
w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers);
w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers);
w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header);
g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w);
frame33 = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0);
gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0);
gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE);
alignment36 = gtk_alignment_new(0, 0.5, 1, 1);
gtk_container_add(GTK_CONTAINER(frame33), alignment36);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0);
vbox30 = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(alignment36), vbox30);
w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file"));
gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename);
hbox10 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0);
label203 = gtk_label_new(_("Date format:"));
gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0);
w->entry_print_dateformat = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat));
gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function."));
gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt);
on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w);
gtk_widget_show_all(page);
return page;
}
void gui_init(dt_lib_module_t *self)
{
dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t));
self->data = (void *)d;
d->edit_button = NULL;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkWidget *w;
GtkWidget *scrolled;
/* list */
d->list = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->list, FALSE);
GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), 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_STYLES_COL_NAME);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
gtk_widget_set_tooltip_text(GTK_WIDGET(d->list), _("available styles,\ndoubleclick to apply"));
g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d);
/* filter entry */
w = gtk_entry_new();
d->entry = GTK_ENTRY(w);
gtk_widget_set_tooltip_text(w, _("enter style name"));
g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d);
g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list));
d->duplicate = gtk_check_button_new_with_label(_("create duplicate"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0);
g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate),
dt_conf_get_bool("ui_last/styles_create_duplicate"));
gtk_widget_set_tooltip_text(d->duplicate, _("creates a duplicate of the image before applying style"));
GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0);
// create
GtkWidget *cbutton = gtk_button_new_with_label(_("create"));
g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d);
gtk_widget_set_tooltip_text(cbutton, _("create styles from history stack of selected images"));
gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0);
// edit
GtkWidget *widget = gtk_button_new_with_label(_("edit"));
d->edit_button = widget;
g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d);
gtk_widget_set_tooltip_text(widget, _("edit the selected style in list above"));
gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0);
// delete
widget = gtk_button_new_with_label(_("delete"));
d->delete_button = widget;
g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d);
gtk_widget_set_tooltip_text(widget, _("deletes the selected style in list above"));
gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0);
// import button
GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import"));
d->import_button = importButton;
gtk_widget_set_tooltip_text(importButton, _("import style from a style file"));
g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d);
gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0);
// export button
GtkWidget *exportButton = gtk_button_new_with_label(_("export"));
d->export_button = exportButton;
gtk_widget_set_tooltip_text(exportButton, _("export the selected style into a style file"));
g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d);
gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, 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->list)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(d->entry, completion);
/* update filtered list */
_gui_styles_update_view(d);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_STYLE_CHANGED, G_CALLBACK(_styles_changed_callback), d);
}
inline void
set_active (GtkWidget* toggle, gboolean sense)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), sense);
}
static gint
despeckle_dialog (void)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *button;
GtkAdjustment *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, TRUE);
dialog = gimp_dialog_new (_("Despeckle"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new_from_drawable_id (drawable->drawable_id);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect (preview, "invalidated",
G_CALLBACK (preview_update),
NULL);
frame = gimp_frame_new (_("Median"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
button = gtk_check_button_new_with_mnemonic (_("_Adaptive"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
filter_type & FILTER_ADAPTIVE);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (dialog_adaptive_callback),
NULL);
button = gtk_check_button_new_with_mnemonic (_("R_ecursive"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
filter_type & FILTER_RECURSIVE);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (dialog_recursive_callback),
NULL);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
/*
* Box size (diameter) control...
*/
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("_Radius:"), SCALE_WIDTH, ENTRY_WIDTH,
despeckle_radius, 1, MAX_RADIUS, 1, 5, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&despeckle_radius);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/*
* Black level control...
*/
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
_("_Black level:"), SCALE_WIDTH, ENTRY_WIDTH,
black_level, -1, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&black_level);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/*
* White level control...
*/
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 2,
_("_White level:"), SCALE_WIDTH, ENTRY_WIDTH,
white_level, 0, 256, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&white_level);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/*
* Show it and wait for the user to do something...
*/
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
/*
* Return ok/cancel...
*/
return run;
}
GtkWidget *
mate_volume_applet_dock_new (GtkOrientation orientation,
MateVolumeApplet *parent)
{
/* FIXME: Remove the orientation argument, or fix it for vertical
boxes (a "horizontal" orientation - the meaning is reversed for
historical reasons. */
GtkWidget *button, *scale, *mute, *more, *label;
GtkWidget *container, *outerline, *innerline, *frame;
MateVolumeAppletDock *dock;
gint i;
static struct {
GtkWidget * (* sfunc) (GtkAdjustment *adj);
GtkWidget * (* container) (gboolean, gint);
GtkWidget * (* subcontainer) (gboolean, gint);
gint sw, sh;
gboolean inverted;
} magic[2] = {
{ gtk_vscale_new, gtk_hbox_new, gtk_vbox_new, -1, 200, TRUE},
{ gtk_hscale_new, gtk_vbox_new, gtk_hbox_new, 200, -1, FALSE}
};
dock = g_object_new (MATE_VOLUME_APPLET_TYPE_DOCK,
NULL);
gtk_window_set_screen (GTK_WINDOW (dock),
gtk_widget_get_screen(GTK_WIDGET (parent)));
dock->orientation = orientation;
dock->model = parent;
g_signal_connect (dock, "key_press_event", G_CALLBACK (cb_key_press),
NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (dock), frame);
container = magic[orientation].container (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (container), 6);
gtk_container_add (GTK_CONTAINER (frame), container);
outerline = magic[orientation].subcontainer (FALSE, 0);
innerline = magic[orientation].subcontainer (FALSE, 0);
gtk_box_pack_start (GTK_BOX (container), outerline, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (container), innerline, FALSE, FALSE, 0);
dock->minus = GTK_BUTTON (gtk_button_new ());
gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->minus),
FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (dock->minus),
gtk_image_new_from_stock (GTK_STOCK_REMOVE,
GTK_ICON_SIZE_BUTTON));
dock->plus = GTK_BUTTON (gtk_button_new ());
gtk_box_pack_end (GTK_BOX (outerline), GTK_WIDGET (dock->plus),
FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (dock->plus),
gtk_image_new_from_stock (GTK_STOCK_ADD,
GTK_ICON_SIZE_BUTTON));
button = GTK_WIDGET (dock->plus);
for (i = 0; i<2; i++) { /* For button in (dock->plus, dock->minus): */
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
g_signal_connect (button, "button-press-event",
G_CALLBACK (cb_button_press), dock);
g_signal_connect (button, "button-release-event",
G_CALLBACK (cb_button_release), dock);
button = GTK_WIDGET (dock->minus);
}
scale = magic[orientation].sfunc (NULL);
g_signal_connect (scale, "key-press-event", G_CALLBACK (proxy_key_event),
parent);
g_signal_connect (scale, "scroll-event", G_CALLBACK (proxy_scroll_event),
parent);
dock->scale = GTK_RANGE (scale);
gtk_widget_set_size_request (scale,
magic[orientation].sw,
magic[orientation].sh);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_range_set_inverted (dock->scale, magic[orientation].inverted);
gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->scale),
TRUE, TRUE, 0);
dock->mute = gtk_check_button_new_with_label (_("Mute"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->mute),
mixer_is_muted (dock->model));
g_signal_connect (dock->mute, "toggled", G_CALLBACK (mute_cb), dock);
gtk_box_pack_start (GTK_BOX (innerline), dock->mute, TRUE, TRUE, 0);
more = gtk_button_new_with_label (_("Volume Control..."));
g_signal_connect (more, "clicked", G_CALLBACK (launch_mixer_cb), dock);
gtk_box_pack_end (GTK_BOX (innerline), more, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (dock), frame);
return GTK_WIDGET (dock);
}
static void
gtk_color_combo_update (GtkWidget * widget, GtkColorCombo * color_combo)
{
gint i,j;
gint focus_row = -1, focus_col = -1;
gint new_row = -1, new_col = -1;
gint new_selection=FALSE;
gint row,column;
row=color_combo->row;
column=color_combo->column;
for(i=0 ; i<color_combo->nrows; i++)
for(j=0; j<color_combo->ncols; j++){
if(GTK_WIDGET_HAS_FOCUS(color_combo->button[i][j])){
focus_row=i;
focus_col=j;
}
if(color_combo->button[i][j]->state==GTK_STATE_ACTIVE){
if(i != row || j != column){
new_selection=TRUE;
new_row=i;
new_col=j;
}
}
}
if(!new_selection && focus_row >= 0 && focus_col >= 0){
if(focus_row != row && focus_col != column){
new_selection = TRUE;
new_row=focus_row;
new_col=focus_col;
}
}
if(new_selection){
if(row >= 0 && column >= 0){
GTK_BUTTON(color_combo->button[row][column])->button_down=FALSE;
GTK_TOGGLE_BUTTON(color_combo->button[row][column])->active=FALSE;
gtk_widget_set_state(color_combo->button[row][column], GTK_STATE_NORMAL);
gtk_widget_queue_draw(color_combo->button[row][column]);
}
color_combo->row=new_row;
color_combo->column=new_col;
gtk_signal_emit (GTK_OBJECT(color_combo), color_combo_signals[CHANGED],
new_row * color_combo->ncols + new_col,
color_combo->color_name[new_row*color_combo->ncols+new_col]);
}
if(!new_selection && row >= 0 && column >= 0){
GTK_BUTTON(color_combo->button[row][column])->button_down=TRUE;
GTK_TOGGLE_BUTTON(color_combo->button[row][column])->active=TRUE;
gtk_widget_set_state(color_combo->button[row][column], GTK_STATE_ACTIVE);
gtk_widget_queue_draw(color_combo->button[row][column]);
gtk_signal_emit (GTK_OBJECT(color_combo),
color_combo_signals[CHANGED],
row * color_combo->ncols + column,
color_combo->color_name[row*color_combo->ncols+column]);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_COMBO_BOX(color_combo)->arrow), FALSE);
gtk_grab_remove(GTK_COMBO_BOX(color_combo)->popwin);
gdk_pointer_ungrab(GDK_CURRENT_TIME);
gtk_widget_hide(GTK_COMBO_BOX(color_combo)->popwin);
return;
}
void cdda_configure(void)
{
GtkWidget *vbox, *notebook;
GtkWidget *dev_vbox, *dev_notebook, *add_drive, *add_bbox;
GtkWidget *cdi_vbox;
GtkWidget *cdi_cddb_frame, *cdi_cddb_vbox, *cdi_cddb_hbox;
GtkWidget *cdi_cddb_server_hbox, *cdi_cddb_server_label;
GtkWidget *cdi_cddb_server_list, *cdi_cddb_debug_win;
#if 0
GtkWidget *cdi_cdin_frame, *cdi_cdin_vbox;
GtkWidget *cdi_cdin_server_hbox, *cdi_cdin_server_label;
#endif
GtkWidget *cdi_name_frame, *cdi_name_vbox, *cdi_name_hbox;
GtkWidget *cdi_name_label, *cdi_desc;
GtkWidget *cdi_name_enable_vbox;
GtkWidget *bbox, *ok, *cancel;
GList *node;
int i = 1;
if (cdda_configure_win)
return;
cdda_configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(cdda_configure_win), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&cdda_configure_win);
gtk_window_set_title(GTK_WINDOW(cdda_configure_win),
_("CD Audio Player Configuration"));
gtk_window_set_policy(GTK_WINDOW(cdda_configure_win), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(cdda_configure_win), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(cdda_configure_win), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(cdda_configure_win), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
/*
* Device config
*/
dev_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5);
dev_notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(dev_notebook), TRUE);
gtk_box_pack_start(GTK_BOX(dev_vbox), dev_notebook, FALSE, FALSE, 0);
for (node = cdda_cfg.drives; node; node = node->next)
{
struct driveinfo *drive = node->data;
char *label = g_strdup_printf(_("Drive %d"), i++);
GtkWidget *w;
w = configurewin_add_drive(drive, dev_notebook);
gtk_notebook_append_page(GTK_NOTEBOOK(dev_notebook), w,
gtk_label_new(label));
g_free(label);
}
add_bbox = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(dev_vbox), add_bbox, FALSE, FALSE, 0);
add_drive = gtk_button_new_with_label(_("Add drive"));
gtk_signal_connect(GTK_OBJECT(add_drive), "clicked",
GTK_SIGNAL_FUNC(configurewin_add_page), dev_notebook);
GTK_WIDGET_SET_FLAGS(add_drive, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(add_bbox), add_drive, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dev_vbox,
gtk_label_new(_("Device")));
/*
* CD Info config
*/
cdi_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(cdi_vbox), 5);
/* CDDB */
cdi_cddb_frame = gtk_frame_new(_("CDDB:"));
gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cddb_frame, FALSE, FALSE, 0);
cdi_cddb_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(cdi_cddb_vbox), 5);
gtk_container_add(GTK_CONTAINER(cdi_cddb_frame), cdi_cddb_vbox);
cdi_cddb_hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(cdi_cddb_hbox), 0);
gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox),
cdi_cddb_hbox, FALSE, FALSE, 0);
cdi_use_cddb = gtk_check_button_new_with_label(_("Use CDDB"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cddb),
cdda_cfg.use_cddb);
gtk_box_pack_start(GTK_BOX(cdi_cddb_hbox), cdi_use_cddb, FALSE, FALSE, 0);
cdi_cddb_server_list = gtk_button_new_with_label(_("Get server list"));
gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_server_list, FALSE, FALSE, 0);
cdi_cddb_debug_win = gtk_button_new_with_label(_("Show network window"));
gtk_signal_connect(GTK_OBJECT(cdi_cddb_debug_win), "clicked",
GTK_SIGNAL_FUNC(cdda_cddb_show_network_window), NULL);
gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox),
cdi_cddb_debug_win, FALSE, FALSE, 0);
cdi_cddb_server_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox),
cdi_cddb_server_hbox, FALSE, FALSE, 0);
cdi_cddb_server_label = gtk_label_new(_("CDDB server:"));
gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox),
cdi_cddb_server_label, FALSE, FALSE, 0);
cdi_cddb_server = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(cdi_cddb_server), cdda_cfg.cddb_server);
gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(cdi_cddb_server_list), "clicked",
GTK_SIGNAL_FUNC(cdda_cddb_show_server_dialog),
cdi_cddb_server);
#if 0
/*
* CDindex
*/
cdi_cdin_frame = gtk_frame_new(_("CD Index:"));
gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cdin_frame, FALSE, FALSE, 0);
cdi_cdin_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(cdi_cdin_vbox), 5);
gtk_container_add(GTK_CONTAINER(cdi_cdin_frame), cdi_cdin_vbox);
cdi_use_cdin = gtk_check_button_new_with_label(_("Use CD Index"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cdin), cdda_cfg.use_cdin);
gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_use_cdin, FALSE, FALSE, 0);
cdi_cdin_server_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_cdin_server_hbox, FALSE, FALSE, 0);
cdi_cdin_server_label = gtk_label_new(_("CD Index server:"));
gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server_label,
FALSE, FALSE, 0);
cdi_cdin_server = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(cdi_cdin_server), cdda_cfg.cdin_server);
gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server, TRUE, TRUE, 0);
#ifndef WITH_CDINDEX
gtk_widget_set_sensitive(cdi_cdin_frame, FALSE);
#endif
#endif
/*
* Track names
*/
cdi_name_frame = gtk_frame_new(_("Track names:"));
gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_name_frame, FALSE, FALSE, 0);
cdi_name_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(cdi_name_frame), cdi_name_vbox);
gtk_container_border_width(GTK_CONTAINER(cdi_name_vbox), 5);
cdi_name_override = gtk_check_button_new_with_label(_("Override generic titles"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_name_override),
cdda_cfg.title_override);
gtk_box_pack_start(GTK_BOX(cdi_name_vbox), cdi_name_override, FALSE, FALSE, 0);
cdi_name_enable_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(cdi_name_vbox), cdi_name_enable_vbox);
gtk_widget_set_sensitive(cdi_name_enable_vbox, cdda_cfg.title_override);
gtk_signal_connect(GTK_OBJECT(cdi_name_override), "toggled",
toggle_set_sensitive_cb, cdi_name_enable_vbox);
cdi_name_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_name_hbox, FALSE, FALSE, 0);
cdi_name_label = gtk_label_new(_("Name format:"));
gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name_label, FALSE, FALSE, 0);
cdi_name = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(cdi_name), cdda_cfg.name_format);
gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name, TRUE, TRUE, 0);
cdi_desc = xmms_titlestring_descriptions("patn", 2);
gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_desc, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), cdi_vbox,
gtk_label_new(_("CD Info")));
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(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked",
GTK_SIGNAL_FUNC(cdda_configurewin_ok_cb), NULL);
gtk_signal_connect(GTK_OBJECT(ok), "clicked",
GTK_SIGNAL_FUNC(configurewin_close), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect(GTK_OBJECT(cancel), "clicked",
GTK_SIGNAL_FUNC(configurewin_close), NULL);
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show_all(cdda_configure_win);
}
gint display_dbgmem_search(uint32_t addr)
{
GladeXML *xml;
GtkWidget *dbox;
GtkWidget *entry, *check1, *check2;
gint result;
gchar *str;
gint ret = -1;
xml = glade_xml_new
(tilp_paths_build_glade("dbg_mem-2.glade"), "dbgmem_search", PACKAGE);
if (!xml)
g_error(_("%s: GUI loading failed!\n"), __FILE__);
glade_xml_signal_autoconnect(xml);
if(old_str == NULL)
old_str = g_strdup("");
entry = glade_xml_get_widget(xml, "entry1");
gtk_entry_set_text(GTK_ENTRY(entry), old_str);
check1 = glade_xml_get_widget(xml, "checkbutton1");
check2 = glade_xml_get_widget(xml, "checkbutton2");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check2), TRUE);
dbox = glade_xml_get_widget(xml, "dbgmem_search");
/* Find, Find Next, Cancel */
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK,
GTK_RESPONSE_APPLY, GTK_RESPONSE_CANCEL,-1);
for(result = 0;;)
{
result = gtk_dialog_run(GTK_DIALOG(dbox));
if((result == GTK_RESPONSE_CANCEL) ||
(result == GTK_RESPONSE_DELETE_EVENT))
break;
if(result == GTK_RESPONSE_OK)
{
blk_adr = addr; //0x000000;
blk_len = 0;
}
//printf("searching at $%x\n", blk_adr);
// find first/next
str = (gchar *)gtk_entry_get_text(GTK_ENTRY(entry));
g_free(old_str);
old_str = g_strdup(str);
ascii = GTK_TOGGLE_BUTTON(check1)->active;
casse = GTK_TOGGLE_BUTTON(check2)->active;
gtk_widget_set_sensitive(entry, FALSE);
while(gtk_events_pending()) gtk_main_iteration();
if(search_engine(old_str, ascii, casse, &blk_adr, &blk_len))
{
search_highlight(blk_adr, blk_adr + blk_len, !0);
while(gtk_events_pending()) gtk_main_iteration();
}
gtk_widget_set_sensitive(entry, TRUE);
while(gtk_events_pending()) gtk_main_iteration();
blk_adr += blk_len;
blk_adr &= 0xffffff;
}
gtk_widget_destroy(dbox);
return ret;
}
void gtkgui_toggle_spk(bool i)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linein), i);
}
void effect_show_dialog(void)
{
gint i;
/* echo widgets */
GtkWidget *frame_echo;
GtkWidget *chk_echo;
GtkWidget *hs_echo_delay, *hs_echo_feedback, *hs_echo_wet;
/* stereo enhance widgets */
GtkWidget *frame_stereo;
GtkWidget *chk_stereo;
GtkWidget *hs_stereo_level;
/* voice removal widgets */
GtkWidget *frame_voice;
GtkWidget *chk_voice;
/* normalizer widgets */
GtkWidget *frame_normal;
GtkWidget *chk_normal;
GtkWidget *sp_normal_buckets;
GtkWidget *hs_normal_target, *hs_normal_gainmax, *hs_normal_gainsmooth;
/* equalizer widgets */
GtkWidget *frame_eq;
GtkWidget *chk_eq;
GtkWidget *chk_auto;
GtkWidget *btn_eq_flat, *btn_eq_rock, *btn_eq_pop, *btn_eq_laptop,
*btn_eq_classic;
GtkWidget *vs_eq[10];
/* stock button widgets */
GtkWidget *cancelbutton;
GtkWidget *applybutton;
GtkWidget *okbutton;
GtkWidget *dialog_vbox1;
GtkWidget *dialog_action_area1;
GtkObject *sp_normal_buckets_adj;
GtkWidget *hseparator1, *hseparator2, *hseparator3, *hseparator4;
GtkWidget *hbox1, *hbox2, *hbox3, *hbox4, *hbox5, *hbox6, *hbox7,
*hbox8, *hbox9, *hbox10;
GtkWidget *hbox11, *hbox12, *hbox13;
GtkWidget *vbox1, *vbox2, *vbox3, *vbox5, *vbox6, *vbox7, *vbox8,
*vbox18, *vbox19;
GtkWidget *label4, *label5, *label6, *label7, *label8, *label9,
*label10, *label11, *label12;
GtkWidget *label13, *label14, *label15, *label16, *label17, *label18,
*label19, *label20;
GtkWidget *label21, *label22, *label23, *label24, *label25, *label26;
GtkWidget *hbox_eq1, *hbox_eq2;
if (effect_dialog != NULL)
return;
effect_dialog = gtk_dialog_new();
gtk_container_set_border_width(GTK_CONTAINER(effect_dialog), 2);
gtk_window_set_title(GTK_WINDOW(effect_dialog), _("Effect"));
gtk_window_set_position(GTK_WINDOW(effect_dialog), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(effect_dialog), 500, -1);
dialog_vbox1 = GTK_DIALOG(effect_dialog)->vbox;
gtk_widget_show(dialog_vbox1);
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox1, TRUE, TRUE, 2);
vbox6 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox6);
gtk_box_pack_start(GTK_BOX(hbox1), vbox6, TRUE, TRUE, 0);
hbox10 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox10);
gtk_box_pack_start(GTK_BOX(vbox6), hbox10, FALSE, TRUE, 0);
frame_echo = gtk_frame_new(NULL);
gtk_widget_show(frame_echo);
gtk_box_pack_start(GTK_BOX(hbox10), frame_echo, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_echo), 2);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(frame_echo), vbox1);
gtk_container_set_border_width(GTK_CONTAINER(vbox1), 4);
chk_echo = gtk_check_button_new_with_mnemonic(_("Enable Echo"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_echo),
effect.echo.on);
gtk_widget_show(chk_echo);
gtk_box_pack_start(GTK_BOX(vbox1), chk_echo, FALSE, FALSE, 0);
hseparator3 = gtk_hseparator_new();
gtk_widget_show(hseparator3);
gtk_box_pack_start(GTK_BOX(vbox1), hseparator3, FALSE, FALSE, 1);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX(vbox1), hbox2, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox2), 1);
label4 = gtk_label_new(_("Deley(ms)"));
gtk_widget_show(label4);
gtk_box_pack_start(GTK_BOX(hbox2), label4, FALSE, FALSE, 2);
gtk_label_set_justify(GTK_LABEL(label4), GTK_JUSTIFY_LEFT);
hs_echo_delay =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.echo.delay, 0, MAX_DELAY, 1, 0, 0)));
gtk_widget_show(hs_echo_delay);
gtk_box_pack_start(GTK_BOX(vbox1), hs_echo_delay, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_echo_delay), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_echo_delay), 0);
hbox3 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox3);
gtk_box_pack_start(GTK_BOX(vbox1), hbox3, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox3), 1);
label5 = gtk_label_new(_("Feedback(%)"));
gtk_widget_show(label5);
gtk_box_pack_start(GTK_BOX(hbox3), label5, FALSE, FALSE, 2);
gtk_label_set_justify(GTK_LABEL(label5), GTK_JUSTIFY_LEFT);
hs_echo_feedback =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.echo.feedback, 0, 100, 1, 0, 0)));
gtk_widget_show(hs_echo_feedback);
gtk_box_pack_start(GTK_BOX(vbox1), hs_echo_feedback, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_echo_feedback), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_echo_feedback), 0);
hbox4 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox4);
gtk_box_pack_start(GTK_BOX(vbox1), hbox4, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox4), 1);
label6 = gtk_label_new(_("Wet(%)"));
gtk_widget_show(label6);
gtk_box_pack_start(GTK_BOX(hbox4), label6, FALSE, TRUE, 2);
gtk_label_set_justify(GTK_LABEL(label6), GTK_JUSTIFY_LEFT);
hs_echo_wet =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.echo.wet, 0, 100, 1, 0, 0)));
gtk_widget_show(hs_echo_wet);
gtk_box_pack_start(GTK_BOX(vbox1), hs_echo_wet, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_echo_wet), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_echo_wet), 0);
label8 = gtk_label_new(_("Echo"));
gtk_widget_show(label8);
gtk_frame_set_label_widget(GTK_FRAME(frame_echo), label8);
gtk_label_set_justify(GTK_LABEL(label8), GTK_JUSTIFY_LEFT);
vbox7 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox7);
gtk_box_pack_start(GTK_BOX(hbox10), vbox7, TRUE, TRUE, 0);
frame_stereo = gtk_frame_new(NULL);
gtk_widget_show(frame_stereo);
gtk_box_pack_start(GTK_BOX(vbox7), frame_stereo, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_stereo), 2);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_container_add(GTK_CONTAINER(frame_stereo), vbox2);
gtk_container_set_border_width(GTK_CONTAINER(vbox2), 4);
chk_stereo =
gtk_check_button_new_with_mnemonic(_("Enable Stereo Enhance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_stereo),
effect.stereo.on);
gtk_widget_show(chk_stereo);
gtk_box_pack_start(GTK_BOX(vbox2), chk_stereo, FALSE, FALSE, 0);
hseparator2 = gtk_hseparator_new();
gtk_widget_show(hseparator2);
gtk_box_pack_start(GTK_BOX(vbox2), hseparator2, FALSE, FALSE, 1);
hbox5 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox5, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox5), 1);
label7 = gtk_label_new(_("Effect Level"));
gtk_widget_show(label7);
gtk_box_pack_start(GTK_BOX(hbox5), label7, FALSE, FALSE, 2);
gtk_label_set_justify(GTK_LABEL(label7), GTK_JUSTIFY_LEFT);
hs_stereo_level =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.stereo.level, 0, 8, 0.1, 0, 0)));
gtk_widget_show(hs_stereo_level);
gtk_box_pack_start(GTK_BOX(vbox2), hs_stereo_level, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_stereo_level), GTK_POS_RIGHT);
label9 = gtk_label_new(_("Stereo Enhance"));
gtk_widget_show(label9);
gtk_frame_set_label_widget(GTK_FRAME(frame_stereo), label9);
gtk_label_set_justify(GTK_LABEL(label9), GTK_JUSTIFY_LEFT);
frame_voice = gtk_frame_new(NULL);
gtk_widget_show(frame_voice);
gtk_box_pack_start(GTK_BOX(vbox7), frame_voice, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_voice), 2);
vbox3 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox3);
gtk_container_add(GTK_CONTAINER(frame_voice), vbox3);
gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
chk_voice =
gtk_check_button_new_with_mnemonic(_("Enable Voice Removal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_voice),
effect.voice.on);
gtk_widget_show(chk_voice);
gtk_box_pack_start(GTK_BOX(vbox3), chk_voice, FALSE, FALSE, 0);
hseparator1 = gtk_hseparator_new();
gtk_widget_show(hseparator1);
gtk_box_pack_start(GTK_BOX(vbox3), hseparator1, FALSE, FALSE, 1);
label10 = gtk_label_new(_("Voice Removal"));
gtk_widget_show(label10);
gtk_frame_set_label_widget(GTK_FRAME(frame_voice), label10);
gtk_label_set_justify(GTK_LABEL(label10), GTK_JUSTIFY_LEFT);
frame_normal = gtk_frame_new(NULL);
gtk_widget_show(frame_normal);
gtk_box_pack_start(GTK_BOX(hbox10), frame_normal, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_normal), 2);
vbox5 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox5);
gtk_container_add(GTK_CONTAINER(frame_normal), vbox5);
gtk_container_set_border_width(GTK_CONTAINER(vbox5), 4);
chk_normal =
gtk_check_button_new_with_mnemonic(_("Enable Normalizer"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_normal),
effect.normal.on);
gtk_widget_show(chk_normal);
gtk_box_pack_start(GTK_BOX(vbox5), chk_normal, FALSE, FALSE, 0);
hseparator4 = gtk_hseparator_new();
gtk_widget_show(hseparator4);
gtk_box_pack_start(GTK_BOX(vbox5), hseparator4, TRUE, TRUE, 1);
hbox9 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox9);
gtk_box_pack_start(GTK_BOX(vbox5), hbox9, TRUE, TRUE, 0);
label15 = gtk_label_new(_("Window Size"));
gtk_widget_show(label15);
gtk_box_pack_start(GTK_BOX(hbox9), label15, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label15), GTK_JUSTIFY_LEFT);
sp_normal_buckets_adj =
gtk_adjustment_new(effect.normal.buckets, 0, 1024, 1, 10, 10);
sp_normal_buckets =
gtk_spin_button_new(GTK_ADJUSTMENT(sp_normal_buckets_adj), 1, 0);
gtk_widget_show(sp_normal_buckets);
gtk_box_pack_start(GTK_BOX(hbox9), sp_normal_buckets, TRUE, TRUE, 0);
hbox6 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox6);
gtk_box_pack_start(GTK_BOX(vbox5), hbox6, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox6), 1);
label12 = gtk_label_new(_("Target Audio Level"));
gtk_widget_show(label12);
gtk_box_pack_start(GTK_BOX(hbox6), label12, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label12), GTK_JUSTIFY_LEFT);
hs_normal_target =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.normal.target, 0, 99999, 1, 0, 0)));
gtk_widget_show(hs_normal_target);
gtk_box_pack_start(GTK_BOX(vbox5), hs_normal_target, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_normal_target), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_normal_target), 0);
hbox7 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox7);
gtk_box_pack_start(GTK_BOX(vbox5), hbox7, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox7), 1);
label13 = gtk_label_new(_("Maximum Gain"));
gtk_widget_show(label13);
gtk_box_pack_start(GTK_BOX(hbox7), label13, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label13), GTK_JUSTIFY_LEFT);
hs_normal_gainmax =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.normal.gainmax, 0, 9999, 1, 0, 0)));
gtk_widget_show(hs_normal_gainmax);
gtk_box_pack_start(GTK_BOX(vbox5), hs_normal_gainmax, FALSE, TRUE, 0);
gtk_scale_set_value_pos(GTK_SCALE(hs_normal_gainmax), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_normal_gainmax), 0);
hbox8 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox8);
gtk_box_pack_start(GTK_BOX(vbox5), hbox8, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox8), 1);
label14 = gtk_label_new(_("Gain Smooth"));
gtk_widget_show(label14);
gtk_box_pack_start(GTK_BOX(hbox8), label14, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label14), GTK_JUSTIFY_LEFT);
hs_normal_gainsmooth =
gtk_hscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.normal.gainsmooth, 0, 10, 1, 0, 0)));
gtk_widget_show(hs_normal_gainsmooth);
gtk_box_pack_start(GTK_BOX(vbox5), hs_normal_gainsmooth, FALSE, TRUE,
0);
gtk_scale_set_value_pos(GTK_SCALE(hs_normal_gainsmooth),
GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hs_normal_gainsmooth), 0);
label11 = gtk_label_new(_("Normalizer"));
gtk_widget_show(label11);
gtk_frame_set_label_widget(GTK_FRAME(frame_normal), label11);
gtk_label_set_justify(GTK_LABEL(label11), GTK_JUSTIFY_LEFT);
frame_eq = gtk_frame_new(NULL);
gtk_widget_show(frame_eq);
gtk_box_pack_start(GTK_BOX(vbox6), frame_eq, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_eq), 2);
hbox11 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox11);
gtk_container_add(GTK_CONTAINER(frame_eq), hbox11);
gtk_container_set_border_width(GTK_CONTAINER(hbox11), 4);
hbox13 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox13);
gtk_box_pack_start(GTK_BOX(hbox11), hbox13, TRUE, TRUE, 0);
vbox19 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox19);
gtk_box_pack_start(GTK_BOX(hbox13), vbox19, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox19), 4);
chk_eq = gtk_check_button_new_with_mnemonic(_("Enable Equalizer"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_eq), effect.eq.on);
gtk_widget_show(chk_eq);
gtk_box_pack_start(GTK_BOX(vbox19), chk_eq, FALSE, FALSE, 0);
chk_auto = gtk_check_button_new_with_mnemonic(_("Auto"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_auto),
effect.eq.on_auto);
gtk_widget_show(chk_auto);
gtk_box_pack_start(GTK_BOX(vbox19), chk_auto, FALSE, FALSE, 0);
vbox18 = gtk_vbox_new(TRUE, 0);
gtk_widget_show(vbox18);
gtk_box_pack_start(GTK_BOX(hbox13), vbox18, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox18), 4);
btn_eq_flat = gtk_button_new_with_mnemonic(_("Flat"));
gtk_widget_show(btn_eq_flat);
gtk_box_pack_start(GTK_BOX(vbox18), btn_eq_flat, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(btn_eq_flat), 2);
btn_eq_rock = gtk_button_new_with_mnemonic(_("Rock"));
gtk_widget_show(btn_eq_rock);
gtk_box_pack_start(GTK_BOX(vbox18), btn_eq_rock, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(btn_eq_rock), 2);
btn_eq_pop = gtk_button_new_with_mnemonic(_("Pop"));
gtk_widget_show(btn_eq_pop);
gtk_box_pack_start(GTK_BOX(vbox18), btn_eq_pop, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(btn_eq_pop), 2);
btn_eq_laptop = gtk_button_new_with_mnemonic(_("Laptop Speaker"));
gtk_widget_show(btn_eq_laptop);
gtk_box_pack_start(GTK_BOX(vbox18), btn_eq_laptop, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(btn_eq_laptop), 2);
btn_eq_classic = gtk_button_new_with_mnemonic(_("Classic"));
gtk_widget_show(btn_eq_classic);
gtk_box_pack_start(GTK_BOX(vbox18), btn_eq_classic, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(btn_eq_classic), 2);
hbox12 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox12);
gtk_box_pack_start(GTK_BOX(hbox11), hbox12, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox12), 4);
vbox8 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox8);
gtk_box_pack_start(GTK_BOX(hbox12), vbox8, TRUE, TRUE, 0);
hbox_eq1 = gtk_hbox_new(TRUE, 0);
gtk_widget_show(hbox_eq1);
gtk_box_pack_start(GTK_BOX(vbox8), hbox_eq1, TRUE, TRUE, 0);
hbox_eq2 = gtk_hbox_new(TRUE, 0);
gtk_widget_show(hbox_eq2);
gtk_box_pack_start(GTK_BOX(vbox8), hbox_eq2, FALSE, TRUE, 0);
for (i = 0; i < 10; i++) {
vs_eq[i] =
gtk_vscale_new(GTK_ADJUSTMENT
(gtk_adjustment_new
(effect.eq.eq[i], -10.0, 10.0, 0.1, 0.5, 0)));
gtk_widget_show(vs_eq[i]);
gtk_box_pack_start(GTK_BOX(hbox_eq1), vs_eq[i], TRUE, TRUE, 0);
gtk_scale_set_draw_value(GTK_SCALE(vs_eq[i]), FALSE);
gtk_scale_set_digits(GTK_SCALE(vs_eq[i]), 2);
gtk_range_set_inverted(GTK_RANGE(vs_eq[i]), TRUE);
gtk_range_set_update_policy(GTK_RANGE(vs_eq[i]),
GTK_UPDATE_DISCONTINUOUS);
}
label17 = gtk_label_new(_("30"));
gtk_widget_show(label17);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label17, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label17), GTK_JUSTIFY_LEFT);
label18 = gtk_label_new(_("62"));
gtk_widget_show(label18);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label18, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label18), GTK_JUSTIFY_LEFT);
label19 = gtk_label_new(_("125"));
gtk_widget_show(label19);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label19, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label19), GTK_JUSTIFY_LEFT);
label20 = gtk_label_new(_("250"));
gtk_widget_show(label20);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label20, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label20), GTK_JUSTIFY_LEFT);
label21 = gtk_label_new(_("500"));
gtk_widget_show(label21);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label21, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label21), GTK_JUSTIFY_LEFT);
label22 = gtk_label_new(_("1K"));
gtk_widget_show(label22);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label22, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label22), GTK_JUSTIFY_LEFT);
label23 = gtk_label_new(_("2K"));
gtk_widget_show(label23);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label23, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label23), GTK_JUSTIFY_LEFT);
label24 = gtk_label_new(_("4K"));
gtk_widget_show(label24);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label24, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label24), GTK_JUSTIFY_LEFT);
label25 = gtk_label_new(_("6K"));
gtk_widget_show(label25);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label25, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label25), GTK_JUSTIFY_LEFT);
label26 = gtk_label_new(_("16K"));
gtk_widget_show(label26);
gtk_box_pack_start(GTK_BOX(hbox_eq2), label26, FALSE, FALSE, 0);
gtk_label_set_justify(GTK_LABEL(label26), GTK_JUSTIFY_LEFT);
label16 = gtk_label_new(_("Equalizer"));
gtk_widget_show(label16);
gtk_frame_set_label_widget(GTK_FRAME(frame_eq), label16);
gtk_label_set_justify(GTK_LABEL(label16), GTK_JUSTIFY_LEFT);
dialog_action_area1 = GTK_DIALOG(effect_dialog)->action_area;
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1),
GTK_BUTTONBOX_END);
cancelbutton = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(effect_dialog), cancelbutton,
GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS(cancelbutton, GTK_CAN_DEFAULT);
applybutton = gtk_button_new_from_stock("gtk-apply");
gtk_widget_show(applybutton);
gtk_dialog_add_action_widget(GTK_DIALOG(effect_dialog), applybutton,
GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS(applybutton, GTK_CAN_DEFAULT);
okbutton = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(effect_dialog), okbutton,
GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS(okbutton, GTK_CAN_DEFAULT);
g_signal_connect((gpointer) effect_dialog, "delete_event",
G_CALLBACK(on_effect_delete_event), NULL);
g_signal_connect((gpointer) btn_eq_flat, "clicked",
G_CALLBACK(on_btn_eq_flat_clicked), NULL);
g_signal_connect((gpointer) btn_eq_rock, "clicked",
G_CALLBACK(on_btn_eq_rock_clicked), NULL);
g_signal_connect((gpointer) btn_eq_pop, "clicked",
G_CALLBACK(on_btn_eq_pop_clicked), NULL);
g_signal_connect((gpointer) btn_eq_laptop, "clicked",
G_CALLBACK(on_btn_eq_laptop_clicked), NULL);
g_signal_connect((gpointer) btn_eq_classic, "clicked",
G_CALLBACK(on_btn_eq_classic_clicked), NULL);
for (i = 0; i < 10; i++) {
g_signal_connect((gpointer) vs_eq[i], "value_changed",
G_CALLBACK(on_vs_eq_value_changed),
GINT_TO_POINTER(i));
g_signal_connect(GTK_WIDGET(vs_eq[i]), "button-press-event",
G_CALLBACK(on_vs_eq_double_clicked),
GINT_TO_POINTER(i));
}
g_signal_connect((gpointer) cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked), NULL);
g_signal_connect((gpointer) applybutton, "clicked",
G_CALLBACK(on_applybutton_clicked), NULL);
g_signal_connect((gpointer) okbutton, "clicked",
G_CALLBACK(on_okbutton_clicked), NULL);
/* echo widgets */
effect.echo.chk = chk_echo;
effect.echo.hs_echo_delay = hs_echo_delay;
effect.echo.hs_echo_feedback = hs_echo_feedback;
effect.echo.hs_echo_wet = hs_echo_wet;
/* stereo enhance widgets */
effect.stereo.chk = chk_stereo;
effect.stereo.hs_stereo_level = hs_stereo_level;
/* voice removal widgets */
effect.voice.chk = chk_voice;
/* normalizer widgets */
effect.normal.chk = chk_normal;
effect.normal.sp_normal_buckets = sp_normal_buckets;
effect.normal.hs_normal_target = hs_normal_target;
effect.normal.hs_normal_gainmax = hs_normal_gainmax;
effect.normal.hs_normal_gainsmooth = hs_normal_gainsmooth;
/* equalizer widgets */
effect.eq.chk = chk_eq;
effect.eq.chk_auto = chk_auto;
for (i = 0; i < 10; i++) {
effect.eq.vs_eq[i] = vs_eq[i];
}
gtk_widget_show(effect_dialog);
}
bool gtkgui_init(int argc, char *argv[], Stream_mixer *mix)
{
GtkWidget *bbox = NULL;
bool isx = false;
/* FIXME: bisogan mettere l'enable_nls*/
/* i18n */
setlocale(LC_ALL, "");
bindtextdomain("muse", LOCALEDIR);
bind_textdomain_codeset("muse", "UTF-8");
textdomain("muse");
/* initialization */
state = true;
mixer = mix;
list_init(&listachan);
list_init(&lamelist);
list_init(&ogglist);
iceprof = lameprof = vorbisprof = NULL;
if(!profile_init())
error(_("profile initialization error"));
profile_ice_load();
/* profile_lame_load and profile_vorbis_load are into encoder.cpp */
pathfile = NULL;
/* signal to glib we're going to use threads */
g_thread_init(NULL);
isx = gtk_init_check(&argc,&argv);
if(!isx)
return false;
isx = mixer->set_lineout(true);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("MuSE-cvs Gtk+2"));
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(gcb_exit), NULL);
/* FIXME: gtk2 remove ? */
gtk_widget_realize(window);
vbox=gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
fix = gtk_fixed_new();
gtk_box_pack_start(GTK_BOX(vbox), fix, FALSE, FALSE, 0);
bbox = createbbox(bbox);
gtk_fixed_put(GTK_FIXED(fix), bbox, 0, 0);
if(isx)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speakout), TRUE);
pack_new();
createch();
putstatusbar();
/*let's show window */
gtk_widget_show_all(window);
gtk_widget_hide(pack1.hscale);
gtk_widget_hide(pack2.hscale);
gtk_widget_hide(pack3.hscale);
return true;
}
static sequence_view_t *new_sequence_view( void *vp, int num )
{
sequence_view_t *seqv = (sequence_view_t*) vj_calloc(sizeof(sequence_view_t));
seqv->num = num;
seqv->backlink = vp;
seqv->event_box = gtk_event_box_new();
gtk_event_box_set_visible_window( GTK_EVENT_BOX(seqv->event_box), TRUE );
GTK_WIDGET_SET_FLAGS( seqv->event_box, GTK_CAN_FOCUS );
g_signal_connect( G_OBJECT( seqv->event_box ),
"button_press_event",
G_CALLBACK( seqv_mouse_press_event ),
(gpointer*) seqv );
gtk_widget_show( GTK_WIDGET( seqv->event_box ) );
gchar *track_title = g_new0( gchar, 20 );
sprintf(track_title, "Track %d", num );
seqv->frame = gtk_frame_new( track_title );
g_free(track_title);
gtk_container_set_border_width( GTK_CONTAINER( seqv->frame) , 1 );
gtk_widget_show( GTK_WIDGET( seqv->frame ) );
gtk_container_add( GTK_CONTAINER( seqv->event_box), seqv->frame );
seqv->main_vbox = gtk_vbox_new(FALSE,0);
gtk_container_add( GTK_CONTAINER( seqv->frame ), seqv->main_vbox );
gtk_widget_show( GTK_WIDGET( seqv->main_vbox ) );
seqv->area = gtk_image_new();
gtk_box_pack_start( GTK_BOX(seqv->main_vbox),GTK_WIDGET( seqv->area), FALSE,FALSE,0);
gtk_widget_set_size_request_( seqv->area, 176,144 ); //FIXME
seqv->panel = gtk_frame_new(NULL);
seqv->toggle = gtk_toggle_button_new_with_label( "preview" );
if(num>0) {
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(seqv->toggle), FALSE );
g_signal_connect( G_OBJECT( seqv->toggle ), "toggled", G_CALLBACK(sequence_preview_cb),
(gpointer)seqv );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
gtk_widget_show( seqv->toggle );
} else {
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_show( seqv->toggle );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
}
GtkWidget *vvbox = gtk_vbox_new(FALSE, 0);
seqv->button_box = gtk_hbox_new(FALSE,0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box ,FALSE,FALSE, 0 );
add_buttons( seqv,seqv,seqv->button_box );
gtk_widget_show( seqv->button_box );
gtk_container_add( GTK_CONTAINER( seqv->main_vbox ), seqv->panel );
seqv->button_box2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box2, FALSE,FALSE, 0 );
add_buttons2( seqv,seqv,seqv->button_box2 );
gtk_widget_show( seqv->button_box2 );
gtk_container_add( GTK_CONTAINER( seqv->panel ), vvbox );
gtk_widget_show(vvbox);
GtkWidget *box = gtk_vbox_new(FALSE,0);
seqv->timeline_ = gtk_hscale_new_with_range( 0.0,1.0,0.1 );
gtk_scale_set_draw_value( GTK_SCALE(seqv->timeline_), FALSE );
//gtk_widget_set_size_request_( seqv->panel,180 ,180);
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->timeline_)->adjustment), 0.0 );
gtk_widget_show( seqv->panel );
gtk_box_pack_start( GTK_BOX( box ), seqv->timeline_, FALSE,FALSE, 0 );
gtk_box_pack_start( GTK_BOX( vvbox ), box , FALSE,FALSE,0);
gtk_widget_show(seqv->timeline_);
g_signal_connect( seqv->timeline_, "value_changed",
(GCallback) sequence_set_current_frame, (gpointer*) seqv );
GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN );
gtk_widget_set_size_request_(scroll,30,140);
gtk_container_set_border_width(GTK_CONTAINER(scroll),0);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
GtkWidget *vvvbox = gtk_hbox_new(FALSE,0);
seqv->tracks = create_track_view(seqv->num, MAX_TRACKS, (void*) seqv );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( get_track_tree(seqv->tracks)) , FALSE );
gtk_widget_set_size_request_( get_track_tree(seqv->tracks),20,80 );
gtk_widget_show(scroll);
gtk_scrolled_window_add_with_viewport(
GTK_SCROLLED_WINDOW( scroll ), get_track_tree(seqv->tracks) );
gtk_widget_show( get_track_tree(seqv->tracks));
gtk_box_pack_start( GTK_BOX(vvvbox), scroll, TRUE,TRUE, 0);
GtkWidget *hhbox = gtk_hbox_new(FALSE,0);
seqv->sliders_[0] = gtk_vscale_new_with_range( -12.0,12.0,1.0 );
seqv->sliders_[1] = gtk_vscale_new_with_range( 0.0, 1.0, 0.01 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[0])->adjustment), 1.0 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[1])->adjustment), 0.0 );
gtk_scale_set_digits( GTK_SCALE(seqv->sliders_[1]), 2 );
g_signal_connect( G_OBJECT( seqv->sliders_[0] ), "value_changed", G_CALLBACK( seq_speed ),
(gpointer*)seqv );
g_signal_connect( G_OBJECT( seqv->sliders_[1] ), "value_changed", G_CALLBACK( seq_opacity ),
(gpointer*)seqv );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[0], TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[1], TRUE, TRUE, 0 );
gtk_widget_show( seqv->sliders_[0] );
gtk_widget_show( seqv->sliders_[1] );
gtk_box_pack_start( GTK_BOX(vvvbox), hhbox, TRUE,TRUE, 0 );
gtk_widget_show( hhbox );
gtk_container_add( GTK_CONTAINER( box ), vvvbox );
gtk_widget_show( vvvbox );
gtk_widget_show( box );
GtkWidget *hbox = gtk_hbox_new(FALSE,0);
gtk_box_set_spacing( GTK_BOX(hbox), 10 );
seqv->labels_[0] = gtk_label_new( "00:00:00:00" );
seqv->labels_[1] = gtk_label_new( "00:00:00:00" );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[0], FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[1], FALSE, FALSE, 0 );
gtk_widget_show( seqv->labels_[0] );
gtk_widget_show( seqv->labels_[1] );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), hbox, FALSE,FALSE, 0 );
gtk_widget_show( hbox );
gtk_widget_set_sensitive_(GTK_WIDGET(seqv->panel), FALSE );
gtk_widget_show( GTK_WIDGET( seqv->area ) );
return seqv;
}
GtkWidget*
gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
{
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkGrid * grid;
int row;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_default_size(GTK_WINDOW(d),
gtr_pref_int_get (TR_KEY_details_window_width),
gtr_pref_int_get (TR_KEY_details_window_height));
if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))
g_assert_not_reached ();
g_assert (str);
data = g_new0 (struct OpenData, 1);
data->core = core;
data->ctor = ctor;
data->filename = g_strdup (tr_ctorGetSourceFile (ctor));
data->downloadDir = g_strdup (str);
data->file_list = gtr_file_list_new (core, 0);
str = _("Mo_ve .torrent file to the trash");
data->trash_check = gtk_check_button_new_with_mnemonic (str);
str = _("_Start when added");
data->run_check = gtk_check_button_new_with_mnemonic (str);
w = data->priority_combo = gtr_priority_combo_new ();
gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);
g_signal_connect (G_OBJECT (d), "response",
G_CALLBACK (addResponseCB), data);
row = 0;
grid = GTK_GRID (gtk_grid_new ());
gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
gtk_grid_set_row_spacing (grid, GUI_PAD);
gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);
/* "torrent file" row */
l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Source File"),
GTK_FILE_CHOOSER_ACTION_OPEN);
source_chooser = w;
gtk_widget_set_hexpand (w, TRUE);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
addTorrentFilters (GTK_FILE_CHOOSER (w));
g_signal_connect (w, "selection-changed",
G_CALLBACK (sourceChanged), data);
/* "destination folder" row */
row++;
l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Destination Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),
data->downloadDir))
g_warning ("couldn't select '%s'", data->downloadDir);
list = get_recent_destinations ();
for (walk = list; walk; walk = walk->next)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);
g_slist_free (list);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
g_signal_connect (w, "selection-changed",
G_CALLBACK (downloadDirChanged), data);
row++;
l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);
gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);
gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 2, 1);
/* file list row */
row++;
w = data->file_list;
gtk_widget_set_vexpand (w, TRUE);
gtk_widget_set_size_request (w, 466u, 300u);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* torrent priority row */
row++;
l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = data->priority_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
/* torrent priority row */
row++;
w = data->run_check;
if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* "trash .torrent file" row */
row++;
w = data->trash_check;
if (!tr_ctorGetDeleteSource (ctor, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if (data->filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename);
else
sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data);
gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid));
w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
gtk_widget_grab_focus (w);
return d;
}
gboolean multi_res_dialog (GimpDrawable *drawable) {
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
gboolean run;
GtkWidget *gpu_button;
GtkWidget *gpu_tex_button;
GtkWidget *gpu_shared_op_button;
gimp_ui_init("Generic Blob Detector", FALSE);
dialog = gimp_dialog_new("Generic Blob Detector", "Generic Blob Detector",
NULL, (GtkDialogFlags) 0,
gimp_standard_help_func, "plug-in-blob",
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
main_vbox = gtk_vbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show(main_vbox);
gpu_button = gtk_check_button_new_with_mnemonic("_Use GPU");
gtk_box_pack_start(GTK_BOX(main_vbox), gpu_button, FALSE, FALSE, 0);
gpu_tex_button = gtk_check_button_new_with_mnemonic("_Use GPU With Textures");
gtk_box_pack_start(GTK_BOX(main_vbox), gpu_tex_button, FALSE, FALSE, 0);
//gpu_shared_op_button = gtk_check_button_new_with_mnemonic("_Use GPU Shared Optimized");
//gtk_box_pack_start(GTK_BOX(main_vbox), gpu_shared_op_button, FALSE, FALSE, 0);
if(has_cuda_device())
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_button), TRUE);
gtk_widget_set_sensitive(gpu_button, TRUE);
filter_vals.gpu = TRUE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_tex_button), TRUE);
gtk_widget_set_sensitive(gpu_tex_button, TRUE);
filter_vals.gpu_op = TRUE;
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_shared_op_button), TRUE);
//gtk_widget_set_sensitive(gpu_shared_op_button, TRUE);
//filter_vals.gpu_shared_op = TRUE;
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_button), FALSE);
gtk_widget_set_sensitive(gpu_button, FALSE);
filter_vals.gpu = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_tex_button), FALSE);
gtk_widget_set_sensitive(gpu_tex_button, FALSE);
filter_vals.gpu_op = FALSE;
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gpu_shared_op_button), FALSE);
//filter_vals.gpu_shared_op = FALSE;
}
g_signal_connect(gpu_button, "toggled", G_CALLBACK(gimp_toggle_button_update), &filter_vals.gpu);
g_signal_connect(gpu_tex_button, "toggled", G_CALLBACK(gimp_toggle_button_update), &filter_vals.gpu_op);
//g_signal_connect(gpu_shared_op_button, "toggled", G_CALLBACK(gimp_toggle_button_update), &filter_vals.gpu_shared_op);
gtk_widget_show(gpu_button);
gtk_widget_show(gpu_tex_button);
//gtk_widget_show(gpu_shared_op_button);
gtk_widget_show(dialog);
//run_multi_filter(drawable, GIMP_PREVIEW(preview));
run = (gimp_dialog_run(GIMP_DIALOG(dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return run;
}
void
stickynotes_applet_update_prefs (void)
{
int height;
gboolean sys_color, sys_font, sticky, force_default, desktop_hide;
char *font_str;
char *color_str, *font_color_str;
GdkColor color, font_color;
gint width = gconf_client_get_int(stickynotes->gconf,
GCONF_PATH "/defaults/width", NULL);
width = MAX (width, 1);
height = gconf_client_get_int (stickynotes->gconf,
GCONF_PATH "/defaults/height", NULL);
height = MAX (height, 1);
sys_color = gconf_client_get_bool (stickynotes->gconf,
GCONF_PATH "/settings/use_system_color", NULL);
sys_font = gconf_client_get_bool (stickynotes->gconf,
GCONF_PATH "/settings/use_system_font", NULL);
sticky = gconf_client_get_bool (stickynotes->gconf,
GCONF_PATH "/settings/sticky", NULL);
force_default = gconf_client_get_bool (stickynotes->gconf,
GCONF_PATH "/settings/force_default", NULL);
font_str = gconf_client_get_string (stickynotes->gconf,
GCONF_PATH "/defaults/font", NULL);
desktop_hide = gconf_client_get_bool (stickynotes->gconf,
GCONF_PATH "/settings/desktop_hide", NULL);
if (!font_str)
{
font_str = g_strdup ("Sans 10");
}
color_str = gconf_client_get_string (stickynotes->gconf,
GCONF_PATH "/defaults/color", NULL);
if (!color_str)
{
color_str = g_strdup ("#ECF833");
}
font_color_str = gconf_client_get_string (stickynotes->gconf,
GCONF_PATH "/defaults/font_color", NULL);
if (!font_color_str)
{
font_color_str = g_strdup ("#000000");
}
gdk_color_parse (color_str, &color);
g_free (color_str);
gdk_color_parse (font_color_str, &font_color);
g_free (font_color_str);
gtk_adjustment_set_value (stickynotes->w_prefs_width, width);
gtk_adjustment_set_value (stickynotes->w_prefs_height, height);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_sys_color),
sys_color);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON(stickynotes->w_prefs_sys_font),
sys_font);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_sticky),
sticky);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_force),
force_default);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_desktop),
desktop_hide);
gtk_color_button_set_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_color), &color);
gtk_color_button_set_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_font_color),
&font_color);
gtk_font_button_set_font_name (
GTK_FONT_BUTTON (stickynotes->w_prefs_font), font_str);
g_free (font_str);
if (gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/color", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_color_label")),
!sys_color);
gtk_widget_set_sensitive (stickynotes->w_prefs_color,
!sys_color);
}
if (gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/prefs_font_color", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_font_color_label")),
!sys_color);
gtk_widget_set_sensitive (stickynotes->w_prefs_font_color,
!sys_color);
}
if (gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/font", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_font_label")),
!sys_font);
gtk_widget_set_sensitive (stickynotes->w_prefs_font,
!sys_font);
}
}
static void create_adapter(adapter_data *adapter)
{
GHashTable *hash = NULL;
GValue *value;
DBusGProxy *default_proxy;
const gchar *name;
gboolean powered, discoverable;
guint timeout;
GtkWidget *mainbox;
GtkWidget *vbox;
GtkWidget *alignment;
GtkWidget *table;
GtkWidget *label;
GtkWidget *image;
GtkWidget *button;
GtkWidget *entry;
GtkWidget *buttonbox;
int page_num;
dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID,
dbus_g_type_get_map("GHashTable",
G_TYPE_STRING, G_TYPE_VALUE),
&hash, G_TYPE_INVALID);
if (hash != NULL) {
value = g_hash_table_lookup(hash, "Name");
name = value ? g_value_get_string(value) : NULL;
value = g_hash_table_lookup(hash, "Powered");
powered = value ? g_value_get_boolean(value) : FALSE;
value = g_hash_table_lookup(hash, "Discoverable");
discoverable = value ? g_value_get_boolean(value) : FALSE;
value = g_hash_table_lookup(hash, "DiscoverableTimeout");
timeout = value ? g_value_get_uint(value) : 0;
} else {
name = NULL;
powered = FALSE;
discoverable = FALSE;
timeout = 0;
}
adapter->powered = powered;
adapter->discoverable = discoverable;
adapter->timeout_value = timeout;
default_proxy = bluetooth_client_get_default_adapter (client);
if (default_proxy != NULL) {
adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy),
dbus_g_proxy_get_path (adapter->proxy));
g_object_unref (default_proxy);
}
mainbox = gtk_vbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12);
page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook),
mainbox, NULL);
adapter->child = mainbox;
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0);
/* The discoverable checkbox */
button = gtk_check_button_new_with_mnemonic (_("Make computer _visible"));
if (powered == FALSE)
discoverable = FALSE;
if (discoverable != FALSE && timeout == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
else if (discoverable == FALSE)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
}
gtk_widget_set_sensitive (button, adapter->powered);
adapter->button_discoverable = button;
adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(discoverable_changed_cb), adapter);
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
/* The friendly name */
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);
label = create_label(_("Friendly name"));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), 248);
gtk_widget_set_size_request(entry, 240, -1);
gtk_container_add (GTK_CONTAINER (alignment), entry);
if (name != NULL)
gtk_entry_set_text(GTK_ENTRY(entry), name);
adapter->entry = entry;
adapter->name_vbox = vbox;
g_signal_connect(G_OBJECT(entry), "changed",
G_CALLBACK(name_callback), adapter);
g_signal_connect(G_OBJECT(entry), "focus-out-event",
G_CALLBACK(focus_callback), adapter);
gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered);
/* The known devices */
table = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0);
label = create_label(_("Devices"));
gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6);
/* Note that this will only ever show the devices on the default
* adapter, this is on purpose */
adapter->chooser = bluetooth_chooser_new (NULL);
g_object_set (adapter->chooser,
"show-searching", FALSE,
"show-device-type", FALSE,
"show-device-category", FALSE,
"show-pairing", TRUE,
"show-connected", TRUE,
"device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED,
NULL);
g_signal_connect (adapter->chooser, "notify::device-selected",
G_CALLBACK(device_selected_cb), adapter);
gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
adapter->devices_table = table;
buttonbox = gtk_vbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX(buttonbox), 6);
gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE);
gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 6, 6);
button = gtk_button_new_with_mnemonic(_("Set up _new device..."));
image = gtk_image_new_from_stock(GTK_STOCK_ADD,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(wizard_callback), adapter);
button = gtk_button_new_with_label(_("Disconnect"));
image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
button, TRUE);
gtk_widget_set_sensitive(button, FALSE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(disconnect_callback), adapter);
adapter->button_disconnect = button;
button = gtk_button_new_with_mnemonic(_("_Remove"));
image = gtk_image_new_from_stock(GTK_STOCK_REMOVE,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
button, TRUE);
gtk_widget_set_sensitive(button, FALSE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(remove_callback), adapter);
adapter->button_delete = button;
gtk_widget_set_sensitive (adapter->devices_table, adapter->powered);
g_object_set_data(G_OBJECT(mainbox), "adapter", adapter);
gtk_widget_show_all(mainbox);
if (adapter->is_default != FALSE)
gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num);
}
static void
stm_new_transfer_window_ui (StmNewTransferWindow *self)
{
StmNewTransferWindowPrivate *priv = self->priv;
gtk_window_set_title (GTK_WINDOW (self), _("Add transfer"));
/* Buttons */
GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
g_signal_connect (G_OBJECT (close), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
/* Table */
GtkWidget *table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
GtkWidget *label;
/* Left column */
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>URL:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Save to:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK, 0, 0);
/* Right column */
GtkWidget *entry;
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->source = GTK_ENTRY (entry);
entry = gtk_file_chooser_button_new (_("Select destination"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->destination = GTK_FILE_CHOOSER_BUTTON (entry);
entry = gtk_check_button_new_with_label (_("Automatically start transfer"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), TRUE);
gtk_table_attach (GTK_TABLE (table), entry,
0, 2, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->auto_start = GTK_CHECK_BUTTON (entry);
gtk_widget_show_all (table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table,
FALSE, FALSE, 0);
/* Buttons */
GtkWidget *ok = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (ok), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
}
void DownloadUI::CreateDownloadUI(void)
{
m_downloadUI = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(m_downloadUI), BRANDING" - DownloadManager");
gtk_signal_connect(GTK_OBJECT(m_downloadUI), "destroy",
GTK_SIGNAL_FUNC(toggle_vis_internal), this);
gtk_container_set_border_width(GTK_CONTAINER(m_downloadUI), 5);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(m_downloadUI), vbox);
gtk_widget_set_usize(vbox, 400, 400);
gtk_widget_show(vbox);
GtkWidget *text = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
gtk_label_set_text(GTK_LABEL(text), szEMusicText);
else
gtk_label_set_text(GTK_LABEL(text), szFreeAmpText);
gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_FILL);
gtk_misc_set_alignment(GTK_MISC(text), (gfloat)0.0, (gfloat)0.0);
gtk_box_pack_start(GTK_BOX(vbox), text, FALSE, FALSE, 2);
gtk_widget_set_usize(text, 400, 46);
gtk_widget_show(text);
GtkWidget *emusic_button;
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
emusic_button = gtk_button_new_with_label(szEMusicURLText);
else
emusic_button = gtk_button_new_with_label(szFreeAmpURLText);
gtk_box_pack_start(GTK_BOX(vbox), emusic_button, FALSE, FALSE, 2);
gtk_signal_connect(GTK_OBJECT(emusic_button), "clicked",
GTK_SIGNAL_FUNC(emusic_click), this);
gtk_widget_show(emusic_button);
GtkWidget *listwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), listwindow, TRUE, TRUE, 0);
gtk_widget_set_usize(listwindow, 400, 140);
gtk_widget_show(listwindow);
GtkWidget *table = gtk_table_new(7, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_widget_show(table);
GtkWidget *label = gtk_label_new("Artist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
artist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(artist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), artist, 1, 2, 0, 1);
gtk_widget_show(artist);
label = gtk_label_new("Album:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
album = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(album), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), album, 1, 2, 1, 2);
gtk_widget_show(album);
label = gtk_label_new("Title:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
title = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(title), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), title, 1, 2, 2, 3);
gtk_widget_show(title);
label = gtk_label_new("Genre:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
genre = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(genre), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), genre, 1, 2, 3, 4);
gtk_widget_show(genre);
label = gtk_label_new("Playlist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
playlist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(playlist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), playlist, 1, 2, 4, 5);
gtk_widget_show(playlist);
label = gtk_label_new("File Name:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
name = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(name), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), name, 1, 2, 5, 6);
gtk_widget_show(name);
label = gtk_label_new("File Size:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
size = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(size), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), size, 1, 2, 6, 7);
gtk_widget_show(size);
CreateDownloadList(listwindow);
GtkWidget *sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 2);
gtk_widget_show(sep);
m_closeComplete = gtk_check_button_new_with_label("Close the Download Manager when all downloads finish");
gtk_box_pack_start(GTK_BOX(vbox), m_closeComplete, FALSE, FALSE, 1);
bool set = false;
m_prefs->GetPrefBoolean(kCloseDLMOnCompletePref, &set);
if (set)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_closeComplete), TRUE);
gtk_widget_show(m_closeComplete);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 5);
gtk_widget_show(sep);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
m_CancelButton = gtk_button_new_with_label(" Cancel ");
gtk_box_pack_start(GTK_BOX(hbox), m_CancelButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CancelButton), "clicked",
GTK_SIGNAL_FUNC(cancel_internal), this);
gtk_widget_show(m_CancelButton);
m_PauseButton = gtk_button_new_with_label(" Pause ");
gtk_box_pack_start(GTK_BOX(hbox), m_PauseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_PauseButton), "clicked",
GTK_SIGNAL_FUNC(pause_internal), this);
gtk_widget_show(m_PauseButton);
m_ResumeButton = gtk_button_new();
m_ResumeLabel = gtk_label_new(" Resume ");
gtk_container_add(GTK_CONTAINER(m_ResumeButton), m_ResumeLabel);
gtk_box_pack_start(GTK_BOX(hbox), m_ResumeButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_ResumeButton), "clicked",
GTK_SIGNAL_FUNC(resume_internal), this);
gtk_widget_show(m_ResumeLabel);
gtk_widget_show(m_ResumeButton);
sep = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), sep, TRUE, FALSE, 5);
gtk_widget_show(sep);
m_CloseButton = gtk_button_new_with_label(" Close ");
gtk_box_pack_end(GTK_BOX(hbox), m_CloseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CloseButton), "clicked",
GTK_SIGNAL_FUNC(close_internal), this);
gtk_widget_show(m_CloseButton);
m_helpButton = gtk_button_new_with_label(" Help ");
gtk_box_pack_end(GTK_BOX(hbox), m_helpButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_helpButton), "clicked",
GTK_SIGNAL_FUNC(help_button_click), this);
gtk_widget_show(m_helpButton);
gtk_widget_show(m_downloadUI);
}
