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); }