static void
setup_dialog (GtkBuilder *builder,
PagerData *pager)
{
gboolean value;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
int nr_ws, i;
pager->workspaces_frame = WID ("workspaces_frame");
pager->workspace_names_label = WID ("workspace_names_label");
pager->workspace_names_scroll = WID ("workspace_names_scroll");
pager->display_workspaces_toggle = WID ("workspace_name_toggle");
setup_sensitivity (pager, builder,
"workspace_name_toggle",
NULL,
NULL,
"display-workspace-names" /* key */);
pager->all_workspaces_radio = WID ("all_workspaces_radio");
pager->current_only_radio = WID ("current_only_radio");
setup_sensitivity (pager, builder,
"all_workspaces_radio",
"current_only_radio",
"label_row_col",
"display-all-workspaces" /* key */);
pager->num_rows_spin = WID ("num_rows_spin");
pager->label_row_col = WID("label_row_col");
setup_sensitivity (pager, builder,
"num_rows_spin",
NULL,
NULL,
"num-rows" /* key */);
pager->num_workspaces_spin = WID ("num_workspaces_spin");
pager->workspaces_tree = WID ("workspaces_tree_view");
/* Display workspace names: */
g_signal_connect (G_OBJECT (pager->display_workspaces_toggle), "toggled",
(GCallback) display_workspace_names_toggled, pager);
if (pager->display_mode == WNCK_PAGER_DISPLAY_NAME) {
value = TRUE;
} else {
value = FALSE;
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->display_workspaces_toggle),
value);
/* Display all workspaces: */
g_signal_connect (G_OBJECT (pager->all_workspaces_radio), "toggled",
(GCallback) all_workspaces_toggled, pager);
if (pager->display_all) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->all_workspaces_radio), TRUE);
if ( ! g_object_get_data (G_OBJECT (pager->num_rows_spin), NEVER_SENSITIVE))
gtk_widget_set_sensitive (pager->num_rows_spin, TRUE);
} else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->current_only_radio), TRUE);
gtk_widget_set_sensitive (pager->num_rows_spin, FALSE);
}
/* Num rows: */
g_signal_connect (G_OBJECT (pager->num_rows_spin), "value_changed",
(GCallback) num_rows_value_changed, pager);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_rows_spin), pager->n_rows);
gtk_label_set_text (GTK_LABEL (pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns"));
g_signal_connect (pager->properties_dialog, "destroy",
G_CALLBACK (properties_dialog_destroyed),
pager);
g_signal_connect (pager->properties_dialog, "delete_event",
G_CALLBACK (delete_event),
pager);
g_signal_connect (pager->properties_dialog, "response",
G_CALLBACK (response_cb),
pager);
g_signal_connect (WID ("done_button"), "clicked",
(GCallback) close_dialog, pager);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_workspaces_spin),
wnck_screen_get_workspace_count (pager->screen));
g_signal_connect (G_OBJECT (pager->num_workspaces_spin), "value_changed",
(GCallback) num_workspaces_value_changed, pager);
wncklet_connect_while_alive (pager->screen, "workspace_created",
G_CALLBACK(workspace_created),
pager,
pager->properties_dialog);
wncklet_connect_while_alive (pager->screen, "workspace_destroyed",
G_CALLBACK(workspace_destroyed),
pager,
pager->properties_dialog);
g_signal_connect (G_OBJECT (pager->workspaces_tree), "focus_out_event",
(GCallback) workspaces_tree_focused_out, pager);
pager->workspaces_store = gtk_list_store_new (1, G_TYPE_STRING, NULL);
update_workspaces_model (pager);
gtk_tree_view_set_model (GTK_TREE_VIEW (pager->workspaces_tree), GTK_TREE_MODEL (pager->workspaces_store));
g_object_unref (pager->workspaces_store);
cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL);
column = gtk_tree_view_column_new_with_attributes ("workspace",
cell,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (pager->workspaces_tree), column);
g_signal_connect (cell, "edited",
(GCallback) workspace_name_edited, pager);
nr_ws = wnck_screen_get_workspace_count (pager->screen);
for (i = 0; i < nr_ws; i++) {
wncklet_connect_while_alive (
G_OBJECT (wnck_screen_get_workspace (pager->screen, i)),
"name_changed",
G_CALLBACK(workspace_renamed),
pager,
pager->properties_dialog);
}
update_properties_for_wm (pager);
}
void
gnc_frequency_setup(GncFrequency *gf, GList *recurrences, const GDate *start_date)
{
gboolean made_changes = FALSE;
// setup start-date, if present
if (start_date != NULL
&& g_date_valid(start_date))
{
gnc_date_edit_set_gdate(gf->startDate, start_date);
made_changes = TRUE;
}
if (recurrences == NULL)
{
goto maybe_signal;
// return...
}
if (g_list_length(recurrences) > 1)
{
if (recurrenceListIsWeeklyMultiple(recurrences))
{
for (; recurrences != NULL; recurrences = recurrences->next)
{
_setup_weekly_recurrence(gf, (Recurrence*)recurrences->data);
}
gtk_notebook_set_current_page(gf->nb, PAGE_WEEKLY);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_WEEKLY);
}
else if (recurrenceListIsSemiMonthly(recurrences))
{
Recurrence *first, *second;
GtkWidget *multiplier_spin;
GtkWidget *dom_combobox;
first = (Recurrence*)g_list_nth_data(recurrences, 0);
second = (Recurrence*)g_list_nth_data(recurrences, 1);
multiplier_spin = glade_xml_get_widget(gf->gxml, "semimonthly_spin");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(multiplier_spin), recurrenceGetMultiplier(first));
dom_combobox = glade_xml_get_widget(gf->gxml, "semimonthly_first");
gtk_combo_box_set_active(GTK_COMBO_BOX(dom_combobox), _get_monthly_combobox_index(first));
dom_combobox = glade_xml_get_widget(gf->gxml, "semimonthly_first_weekend");
gtk_combo_box_set_active(GTK_COMBO_BOX(dom_combobox), recurrenceGetWeekendAdjust(first));
dom_combobox = glade_xml_get_widget(gf->gxml, "semimonthly_second");
gtk_combo_box_set_active(GTK_COMBO_BOX(dom_combobox), _get_monthly_combobox_index(second));
dom_combobox = glade_xml_get_widget(gf->gxml, "semimonthly_second_weekend");
gtk_combo_box_set_active(GTK_COMBO_BOX(dom_combobox), recurrenceGetWeekendAdjust(second));
gtk_notebook_set_current_page(gf->nb, PAGE_SEMI_MONTHLY);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_SEMI_MONTHLY);
}
else
{
g_error("unknown composite recurrence with [%d] entries", g_list_length(recurrences));
}
}
else
{
Recurrence *r = (Recurrence*)recurrences->data;
g_debug("recurrence period [%d]", recurrenceGetPeriodType(r));
switch (recurrenceGetPeriodType(r))
{
case PERIOD_ONCE:
{
GDate recurrence_date = recurrenceGetDate(r);
if (g_date_compare(start_date, &recurrence_date) != 0)
{
char start_date_str[128], recur_date_str[128];
g_date_strftime(start_date_str, 127, "%x", start_date);
g_date_strftime(recur_date_str, 127, "%x", &recurrence_date);
g_critical("start_date [%s] != recurrence_date [%s]", start_date_str, recur_date_str);
}
gtk_notebook_set_current_page(gf->nb, PAGE_ONCE);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_ONCE);
}
break;
case PERIOD_DAY:
{
guint multiplier;
GtkWidget *spin_button;
multiplier = recurrenceGetMultiplier(r);
spin_button = glade_xml_get_widget(gf->gxml, "daily_spin");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button), multiplier);
made_changes = TRUE;
gtk_notebook_set_current_page(gf->nb, PAGE_DAILY);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_DAILY);
}
break;
case PERIOD_WEEK:
{
_setup_weekly_recurrence(gf, r);
gtk_notebook_set_current_page(gf->nb, PAGE_WEEKLY);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_WEEKLY);
}
break;
case PERIOD_END_OF_MONTH:
case PERIOD_MONTH:
case PERIOD_YEAR:
case PERIOD_LAST_WEEKDAY:
case PERIOD_NTH_WEEKDAY:
{
guint multiplier;
GtkWidget *multipler_spin, *day_of_month, *weekend_mode;
multipler_spin = glade_xml_get_widget(gf->gxml, "monthly_spin");
multiplier = recurrenceGetMultiplier(r);
if (recurrenceGetPeriodType(r) == PERIOD_YEAR)
multiplier *= 12;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(multipler_spin), multiplier);
day_of_month = glade_xml_get_widget(gf->gxml, "monthly_day");
gtk_combo_box_set_active(GTK_COMBO_BOX(day_of_month), _get_monthly_combobox_index(r));
weekend_mode = glade_xml_get_widget(gf->gxml, "monthly_weekend");
gtk_combo_box_set_active(GTK_COMBO_BOX(weekend_mode), recurrenceGetWeekendAdjust(r));
gtk_notebook_set_current_page(gf->nb, PAGE_MONTHLY);
gtk_combo_box_set_active(gf->freqComboBox, PAGE_MONTHLY);
}
break;
default:
g_error("unknown recurrence period type [%d]", recurrenceGetPeriodType(r));
break;
}
}
maybe_signal:
if (made_changes)
g_signal_emit_by_name(gf, "changed");
}
int main(int argc, char** argv) {
//start gnome_init
initGUI(argc, argv);
cellsWide = DEFAULT_WIDTH / PIX_PER_CELL;
//GUI components
GtkWidget *window;
GtkWidget *imageEventBox, *mainHBox, *sideBox, *quitButton,
*settingFrame, *resetButton, *sideVBox, *widthFrame,
*saveButton, *hSep, *label, *lowerSideVBox, *checkButton,
*rulesFrame, *rulesClearButton, *rulesSetButton,
*rulesHBox, *rulesVBox;
GdkPixbuf *icon_buf_16, *icon_buf_32, *icon_buf_48,
*icon_buf_64, *icon_buf_128, *bg;
GList *icons = NULL;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//load icons from files
icon_buf_16 = gdk_pixbuf_new_from_file(ICON_16, NULL);
icon_buf_32 = gdk_pixbuf_new_from_file(ICON_32, NULL);
icon_buf_48 = gdk_pixbuf_new_from_file(ICON_48, NULL);
icon_buf_64 = gdk_pixbuf_new_from_file(ICON_64, NULL);
icon_buf_128 = gdk_pixbuf_new_from_file(ICON_128, NULL);
//tell gnome to use these icons
icons = g_list_append(icons, icon_buf_16);
icons = g_list_append(icons, icon_buf_32);
icons = g_list_append(icons, icon_buf_48);
icons = g_list_append(icons, icon_buf_64);
icons = g_list_append(icons, icon_buf_128);
gtk_window_set_icon_list(GTK_WINDOW(window), icons);
//connect the delete_event signal to the delete_event function
g_signal_connect (G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), NULL);
//here follows formatting, packing, etc of gtk widgets
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_window_set_title(GTK_WINDOW(window), "Cellular Automata");
widthAdjust = gtk_spin_button_new_with_range(WIDTH_LOWER, WIDTH_UPPER, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widthAdjust), DEFAULT_WIDTH);
widthFrame = gtk_frame_new("Set Width");
gtk_container_add(GTK_CONTAINER(widthFrame), widthAdjust);
gtk_container_set_border_width(GTK_CONTAINER(widthFrame), 10);
ruleAdjust = gtk_spin_button_new_with_range(0, 255, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(ruleAdjust), 30);
settingFrame = gtk_frame_new("Set Rule #");
gtk_container_add(GTK_CONTAINER(settingFrame), ruleAdjust);
gtk_container_set_border_width (GTK_CONTAINER(settingFrame), 10);
bg = gdk_pixbuf_new_from_file("./data/cellular_automata.png", NULL);
imagebuf = gdk_pixbuf_scale_simple(bg, WIDTH, HEIGHT, GDK_INTERP_BILINEAR);
mainImage = gtk_image_new_from_pixbuf(imagebuf);
imageEventBox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(imageEventBox), mainImage);
mainHBox = gtk_hbox_new(FALSE, 0);
sideVBox = gtk_vbox_new(FALSE, 0);
lowerSideVBox = gtk_vbox_new(TRUE, 0);
sideBox = gtk_vbox_new(TRUE, 0);
checkButton = gtk_check_button_new_with_mnemonic("_Autosave Images");
quitButton = gtk_button_new_from_stock (GTK_STOCK_QUIT);
startButton = gtk_button_new_with_mnemonic("_Start");
stopButton = gtk_button_new_with_mnemonic ("_Stop");
saveButton = gtk_button_new_from_stock(GTK_STOCK_SAVE);
gtk_widget_set_sensitive(GTK_WIDGET(stopButton), FALSE);
resetButton = gtk_button_new_with_mnemonic("_Reset");
//connect the proper callback functions to the proper signals
g_signal_connect_swapped (G_OBJECT(quitButton), "clicked", G_CALLBACK(gtk_main_quit), G_OBJECT (window));
g_signal_connect_swapped (G_OBJECT(startButton),"clicked", G_CALLBACK(getLoopy), G_OBJECT(ruleAdjust));
g_signal_connect_swapped (G_OBJECT(stopButton),"clicked", G_CALLBACK(stopLoopy), G_OBJECT(ruleAdjust));
g_signal_connect_swapped (G_OBJECT(resetButton),"clicked", G_CALLBACK(resetImage), G_OBJECT(resetButton));
g_signal_connect_swapped(G_OBJECT(ruleAdjust),"value-changed", G_CALLBACK(updateRule), GTK_WIDGET(ruleAdjust));
g_signal_connect_swapped(G_OBJECT(widthAdjust),"value-changed", G_CALLBACK(initCA), GTK_WIDGET(widthAdjust));
g_signal_connect_swapped(G_OBJECT(saveButton),"clicked", G_CALLBACK(getPic), GTK_WIDGET(saveButton));
g_signal_connect_swapped(G_OBJECT(checkButton),"toggled", G_CALLBACK(toggleSave), GTK_WIDGET(checkButton));
hSep = gtk_hseparator_new();
label = gtk_label_new("Save Image");
//load the meta-rule file names
std::vector<std::string> rulesList;
std::string rulesDir("./"), suff(".rules");
getRulesList(rulesDir, rulesList, suff);
rulesComboBox = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(rulesComboBox), "Rule Set");
for (uint i = 0; i < rulesList.size(); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(rulesComboBox), rulesList[i].c_str());
}
if (rulesList.size()) {
gtk_combo_box_set_active(GTK_COMBO_BOX(rulesComboBox), 0);
}
rulesFrame = gtk_frame_new("Rule Change Controls");
rulesHBox = gtk_hbox_new(FALSE, 0);
rulesVBox = gtk_vbox_new(TRUE, 0);
rulesClearButton = gtk_button_new_with_mnemonic("_Clear Rules Rule");
rulesSetButton = gtk_button_new_with_mnemonic("Set _Rules Rule");
g_signal_connect(G_OBJECT(rulesComboBox), "changed", G_CALLBACK(combo_selected), rulesFrame);
g_signal_connect_swapped(G_OBJECT(rulesClearButton), "clicked", G_CALLBACK(clearRules), G_OBJECT(rulesClearButton));
autoResetButton = gtk_check_button_new_with_mnemonic("_Auto Reset on Dead Lines");
randomizeLengthButton = gtk_check_button_new_with_mnemonic("Randomize _Time Between Rule Changes");
g_signal_connect_swapped(G_OBJECT(autoResetButton), "toggled", G_CALLBACK(autoResetFunction), G_OBJECT(autoResetButton));
g_signal_connect_swapped(G_OBJECT(randomizeLengthButton), "toggled", G_CALLBACK(randomizeLengthFunction), G_OBJECT(randomizeLengthButton));
//pack the widgets into their proper containers
gtk_box_pack_start(GTK_BOX(rulesHBox), rulesClearButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(rulesVBox), rulesComboBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(rulesVBox), rulesHBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(rulesVBox), autoResetButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(rulesVBox), randomizeLengthButton, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(rulesFrame), rulesVBox);
gtk_box_pack_start(GTK_BOX(sideVBox), settingFrame, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(sideVBox), stopButton, FALSE, FALSE,0);
gtk_box_pack_start(GTK_BOX(sideVBox), startButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(sideVBox), resetButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(sideBox), sideVBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(sideVBox), rulesFrame, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowerSideVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowerSideVBox), saveButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowerSideVBox), checkButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowerSideVBox), hSep, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowerSideVBox), quitButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(sideBox), lowerSideVBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainHBox), sideBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainHBox), imageEventBox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), mainHBox);
gtk_widget_show_all(window);
//load black and white pixels into buffers
blackb = gdk_pixbuf_new_subpixbuf(imagebuf, 0, 0, PIX_PER_CELL, PIX_PER_CELL);
black = gdk_pixbuf_copy(blackb);
gdk_pixbuf_fill(black, 0x000000ff);
whiteb = gdk_pixbuf_new_subpixbuf(imagebuf, 0, 0, PIX_PER_CELL, PIX_PER_CELL);
white = gdk_pixbuf_copy(whiteb);
gdk_pixbuf_fill(white, 0xffffffff);
//setup the cellular automaton=========================================
initCA();
//run the main loop of the program
gtk_main();
exit(0);
}
GtkWidget * build_tblock(MtxTextBlock *tblock, gint index)
{
/* MUCH faster that the glade way unfortunately */
GtkWidget *notebook = NULL;
GtkWidget *table = NULL;
GtkWidget *subtable = NULL;
GtkWidget *widget = NULL;
GtkWidget *x_spin = NULL;
GtkWidget *y_spin = NULL;
GtkWidget *hbox = NULL;
GtkWidget *img = NULL;
GtkWidget *label = NULL;
GtkWidget *minitable = NULL;
gchar * tmpbuf = NULL;
table = gtk_table_new(2,2,FALSE);
/* Close button */
widget = gtk_button_new();
img = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(widget),img);
OBJ_SET((widget),"tblock_index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"clicked", G_CALLBACK(remove_tblock),NULL);
gtk_table_attach(GTK_TABLE(table),widget,0,1,0,4,0,0,0,0);
notebook = gtk_notebook_new();
gtk_table_attach(GTK_TABLE(table),notebook,1,2,0,1,GTK_EXPAND|GTK_FILL,0,0,0);
/* text, color buttons */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Text & Color");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Text:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_entry_new();
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_TEXT));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
gtk_entry_set_width_chars(GTK_ENTRY(widget),12);
gtk_entry_set_text(GTK_ENTRY(widget),tblock->text);
g_signal_connect(G_OBJECT(widget),"changed",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND|GTK_FILL,0,0,0);
widget = gtk_color_button_new_with_color(&tblock->color[MTX_DAY]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_COLOR_DAY));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,GTK_FILL,0,0,0);
widget = gtk_color_button_new_with_color(&tblock->color[MTX_NITE]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_COLOR_NITE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,GTK_FILL,0,0,0);
/* font, font scale spinner */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Font");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Font:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_font_button_new();
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_FONT));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
tmpbuf = g_strdup_printf("%s 12",tblock->font);
gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget),tmpbuf);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(widget),FALSE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(widget),FALSE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(widget),FALSE);
g_free(tmpbuf);
g_signal_connect(G_OBJECT(widget),"font_set",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND|GTK_FILL,0,0,0);
widget = gtk_label_new("Font\nScale");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,0,0,0,0);
widget = gtk_spin_button_new_with_range(0.001,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_FONT_SCALE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tblock->font_scale, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,0,0,0,0);
/* Location Tab: Edit button, X/Y position spinners */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Location");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Position:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,0,0,0);
/* X position minilayout table */
minitable = gtk_table_new(1,2,FALSE);
gtk_table_attach(GTK_TABLE(subtable),minitable,2,3,0,1,GTK_EXPAND,0,0,0);
widget = gtk_label_new("X:");
gtk_table_attach(GTK_TABLE(minitable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_spin_button_new_with_range(-1.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_X_POS));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tblock->x_pos, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(minitable),widget,1,2,0,1,GTK_FILL,0,0,0);
x_spin = widget;
/* Y position minilayout table */
minitable = gtk_table_new(1,2,FALSE);
gtk_table_attach(GTK_TABLE(subtable),minitable,3,4,0,1,GTK_FILL|GTK_EXPAND,0,0,0);
widget = gtk_label_new("Y:");
gtk_table_attach(GTK_TABLE(minitable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_spin_button_new_with_range(-1.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_Y_POS));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tblock->y_pos, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(minitable),widget,1,2,0,1,GTK_FILL,0,0,0);
y_spin = widget;
widget = gtk_button_new();
OBJ_SET(widget,"x_spin",x_spin);
OBJ_SET(widget,"y_spin",y_spin);
hbox = gtk_hbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(widget),hbox);
img = gtk_image_new_from_stock("gtk-edit",GTK_ICON_SIZE_MENU);
gtk_box_pack_start(GTK_BOX(hbox),img,FALSE,FALSE,0);
label = gtk_label_new("Edit");
gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,0);
g_signal_connect(G_OBJECT(widget),"clicked",G_CALLBACK(grab_coords_event),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND|GTK_FILL,0,0,0);
/* Layer Tab: Layer */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Layer");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Layer:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_spin_button_new_with_range(0.0,10.0,1.0);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TB_LAYER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 1.0, "digits", 0, "numeric", TRUE, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(gfloat)tblock->layer);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tblock_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_FILL,0,0,0);
widget = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table),widget,0,2,1,2,GTK_FILL,0,0,0);
return table;
}
/*
* attach v4l2 controls tab widget
* args:
* parent - tab parent widget
*
* asserts:
* parent is not null
*
* returns: error code (0 -OK)
*/
int gui_attach_gtk3_v4l2ctrls(GtkWidget *parent)
{
/*assertions*/
assert(parent != NULL);
if(debug_level > 1)
printf("GUVCVIEW: attaching v4l2 controls\n");
GtkWidget *img_controls_grid = gtk_grid_new();
gtk_widget_show (img_controls_grid);
gtk_grid_set_column_homogeneous (GTK_GRID(img_controls_grid), FALSE);
gtk_widget_set_hexpand (img_controls_grid, TRUE);
gtk_widget_set_halign (img_controls_grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID(img_controls_grid), 4);
gtk_grid_set_column_spacing (GTK_GRID (img_controls_grid), 4);
gtk_container_set_border_width (GTK_CONTAINER (img_controls_grid), 2);
int i = 0;
int n = 0;
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next, ++n)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (attach gtk3 controls) empty control in list\n");
break;
}
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
++n; /*add a virtual software autofocus control*/
}
widget_list_size = n + 1;
control_widgets_list = realloc(control_widgets_list, sizeof(control_widgets_t) * widget_list_size);
if(control_widgets_list == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
/*label*/
char *tmp;
tmp = g_strdup_printf ("%s:", current->name);
control_widgets_list[widget_list_size - 1].label = gtk_label_new (tmp);
g_free(tmp);
gtk_widget_show (control_widgets_list[widget_list_size - 1].label);
#if GTK_VER_AT_LEAST(3,15)
gtk_label_set_xalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 1);
gtk_label_set_yalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (control_widgets_list[widget_list_size - 1].label), 1, 0.5);
#endif
control_widgets_list[widget_list_size - 1].id = current->control.id;
control_widgets_list[widget_list_size - 1].widget = NULL;
control_widgets_list[widget_list_size - 1].widget2 = NULL; /*usually a spin button*/
switch (current->control.type)
{
case V4L2_CTRL_TYPE_INTEGER:
switch (current->control.id)
{
//special cases
case V4L2_CID_PAN_RELATIVE:
case V4L2_CID_TILT_RELATIVE:
{
control_widgets_list[n].widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
GtkWidget *PanTilt1 = NULL;
GtkWidget *PanTilt2 = NULL;
if(current->control.id == V4L2_CID_PAN_RELATIVE)
{
PanTilt1 = gtk_button_new_with_label(_("Left"));
PanTilt2 = gtk_button_new_with_label(_("Right"));
}
else
{
PanTilt1 = gtk_button_new_with_label(_("Down"));
PanTilt2 = gtk_button_new_with_label(_("Up"));
}
gtk_widget_show (PanTilt1);
gtk_widget_show (PanTilt2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt1,TRUE,TRUE,2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt2,TRUE,TRUE,2);
g_object_set_data (G_OBJECT (PanTilt1), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (PanTilt2), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signals*/
g_signal_connect (GTK_BUTTON(PanTilt1), "clicked",
G_CALLBACK (button_PanTilt1_clicked), NULL);
g_signal_connect (GTK_BUTTON(PanTilt2), "clicked",
G_CALLBACK (button_PanTilt2_clicked), NULL);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2 = gtk_spin_button_new_with_range(-256, 256, 64);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2), TRUE);
if(current->control.id == V4L2_CID_PAN_RELATIVE)
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2), v4l2core_get_pan_step());
else
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2),v4l2core_get_tilt_step());
/*connect signal*/
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (pan_tilt_step_changed), NULL);
gtk_widget_show (control_widgets_list[n].widget2);
break;
}
case V4L2_CID_PAN_RESET:
case V4L2_CID_TILT_RESET:
{
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
};
case V4L2_CID_LED1_MODE_LOGITECH:
{
char* LEDMenu[4] = {_("Off"),_("On"),_("Blinking"),_("Auto")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(4+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (4+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'N'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'O';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = 'B';
current->menu[3].id = current->control.id;
current->menu[3].index = 3;
current->menu[3].name[0] = 'A';
current->menu[4].id = current->control.id;
current->menu[4].index = current->control.maximum+1;
current->menu[4].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) LEDMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH:
{
/*turn it into a menu control*/
char* BITSMenu[2] = {_("8 bit"),_("12 bit")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(2+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (2+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'o'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'd';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
//if (debug_level > 0)
// printf("GUVCVIEW: adding menu entry %d: %d, %s\n",j, current->menu[j].index, current->menu[j].name);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) BITSMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_FOCUS_LOGITECH:
case V4L2_CID_FOCUS_ABSOLUTE:
if(!is_control_panel)
{
/*add a virtual control for software autofocus*/
control_widgets_list[n-1].widget = gtk_check_button_new_with_label (_("Auto Focus (continuous)"));
control_widgets_list[n-1].widget2 = gtk_button_new_with_label (_("set Focus"));
gtk_widget_show (control_widgets_list[n-1].widget);
gtk_widget_show (control_widgets_list[n-1].widget2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n-1].widget), FALSE);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget), "toggled",
G_CALLBACK (autofocus_changed), NULL);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget2), "clicked",
G_CALLBACK (setfocus_clicked), NULL);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n-1].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n-1].widget, TRUE);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget2, 2, i, 1 , 1);
i++;
}
default: /*standard case - hscale + spin*/
{
/* check for valid range */
if((current->control.maximum > current->control.minimum) && (current->control.step != 0))
{
GtkAdjustment *adjustment = gtk_adjustment_new (
current->value,
current->control.minimum,
current->control.maximum,
current->control.step,
current->control.step*10,
0);
control_widgets_list[n].widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_draw_value (GTK_SCALE (control_widgets_list[n].widget), FALSE);
gtk_scale_set_digits(GTK_SCALE(control_widgets_list[n].widget), 0);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2= gtk_spin_button_new(adjustment, current->control.step, 0);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2),TRUE);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control_entry",
control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control2_entry",
control_widgets_list[n].widget2);
}
/*connect signals*/
g_signal_connect (GTK_SCALE(control_widgets_list[n].widget), "value-changed",
G_CALLBACK (slider_changed), NULL);
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (spin_changed), NULL);
}
else
fprintf(stderr, "GUVCVIEW: (Invalid range) [MAX <= MIN] for control id: 0x%08x \n", current->control.id);
break;
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (int64_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
control_widgets_list[n].widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2= gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (string_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
control_widgets_list[n].widget = gtk_entry_new();
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (bitmask_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
if(current->menu)
{
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->control.type == V4L2_CTRL_TYPE_MENU)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) current->menu_entry[j]);
}
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
else
{
char buffer[30]="0";
snprintf(buffer, "%" PRIu64 "", 29, current->menu[j].value);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget), buffer);
}
#endif
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
}
break;
case V4L2_CTRL_TYPE_BUTTON:
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
if(current->control.id ==V4L2_CID_DISABLE_PROCESSING_LOGITECH)
{
control_widgets_list[n].widget2 = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GBGB... | RGRG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GRGR... | BGBG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"BGBG... | GRGR...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"RGRG... | GBGB...");
v4l2core_set_bayer_pix_order(0);
gtk_combo_box_set_active(GTK_COMBO_BOX(control_widgets_list[n].widget2), v4l2core_get_bayer_pix_order());
gtk_widget_show (control_widgets_list[n].widget2);
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget2), "changed",
G_CALLBACK (bayer_pix_ord_changed), NULL);
uint8_t isbayer = (current->value ? TRUE : FALSE);
v4l2core_set_isbayer(isbayer);
}
control_widgets_list[n].widget = gtk_check_button_new();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n].widget),
current->value ? TRUE : FALSE);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_TOGGLE_BUTTON(control_widgets_list[n].widget), "toggled",
G_CALLBACK (check_changed), NULL);
break;
default:
printf("control[%d]:(unknown - 0x%x) 0x%x '%s'\n",i ,current->control.type,
current->control.id, current->control.name);
break;
}
/*attach widgets to grid*/
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].label, 0, i, 1 , 1);
if(control_widgets_list[n].widget)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n].widget, TRUE);
}
if(control_widgets_list[n].widget2)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget2, 2, i, 1 , 1);
}
i++;
}
/*add control grid to parent container*/
gtk_container_add(GTK_CONTAINER(parent), img_controls_grid);
gui_gtk3_update_controls_state();
return 0;
}
static void
on_song_changed (const BtEditApplication * app, GParamSpec * arg,
gpointer user_data)
{
BtMainPageInfo *self = BT_MAIN_PAGE_INFO (user_data);
BtSong *song;
GtkTextBuffer *buffer;
gchar *name, *genre, *author, *create_dts, *change_dts;
gulong bpm, tpb, bars;
gchar *info;
GST_INFO ("song has changed : app=%p, self=%p", app, self);
g_object_try_unref (self->priv->song_info);
// get song from app
g_object_get (self->priv->app, "song", &song, NULL);
if (!song) {
self->priv->song_info = NULL;
return;
}
GST_INFO ("song: %" G_OBJECT_REF_COUNT_FMT, G_OBJECT_LOG_REF_COUNT (song));
g_object_get (song, "song-info", &self->priv->song_info, NULL);
// update info fields
g_object_get (self->priv->song_info,
"name", &name, "genre", &genre, "author", &author, "info", &info,
"bpm", &bpm, "tpb", &tpb, "bars", &bars,
"create-dts", &create_dts, "change-dts", &change_dts, NULL);
g_signal_handlers_block_matched (self->priv->name,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_name_changed,
(gpointer) self);
gtk_entry_set_text (self->priv->name, safe_string (name));
g_free (name);
g_signal_handlers_unblock_matched (self->priv->name,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_name_changed,
(gpointer) self);
g_signal_handlers_block_matched (self->priv->genre,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_genre_changed,
(gpointer) self);
gtk_entry_set_text (self->priv->genre, safe_string (genre));
g_free (genre);
g_signal_handlers_unblock_matched (self->priv->genre,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_genre_changed,
(gpointer) self);
g_signal_handlers_block_matched (self->priv->author,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_author_changed,
(gpointer) self);
gtk_entry_set_text (self->priv->author, safe_string (author));
g_free (author);
g_signal_handlers_unblock_matched (self->priv->author,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_author_changed,
(gpointer) self);
g_signal_handlers_block_matched (self->priv->bpm,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_bpm_changed,
(gpointer) self);
gtk_spin_button_set_value (self->priv->bpm, (gdouble) bpm);
g_signal_handlers_unblock_matched (self->priv->bpm,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_bpm_changed,
(gpointer) self);
g_signal_handlers_block_matched (self->priv->tpb,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_tpb_changed,
(gpointer) self);
gtk_spin_button_set_value (self->priv->tpb, (gdouble) tpb);
g_signal_handlers_unblock_matched (self->priv->tpb,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_tpb_changed,
(gpointer) self);
g_signal_handlers_block_matched (self->priv->beats,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_beats_changed,
(gpointer) self);
gtk_spin_button_set_value (self->priv->beats, (gdouble) (bars / tpb));
g_signal_handlers_unblock_matched (self->priv->beats,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_beats_changed,
(gpointer) self);
/* the iso date is not nice for the user
* struct tm tm;
* char dts[255];
*
* strptime(create_dts, "%FT%TZ", &tm);
* strftime(dts, sizeof(buf), "%F %T", &tm);
*
* but the code below is simpler and works too :)
*/
create_dts[10] = ' ';
create_dts[19] = '\0';
gtk_entry_set_text (self->priv->date_created, create_dts);
g_free (create_dts);
change_dts[10] = ' ';
change_dts[19] = '\0';
gtk_entry_set_text (self->priv->date_changed, change_dts);
g_free (change_dts);
buffer = gtk_text_view_get_buffer (self->priv->info);
g_signal_handlers_block_matched (buffer,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_info_changed,
(gpointer) self);
gtk_text_buffer_set_text (buffer, safe_string (info), -1);
g_free (info);
g_signal_handlers_unblock_matched (buffer,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, on_info_changed,
(gpointer) self);
g_signal_connect (self->priv->song_info, "notify::name",
G_CALLBACK (on_name_notify), (gpointer) self);
// release the references
g_object_unref (song);
GST_INFO ("song has changed done");
}
// Set the value of a table item
void rtk_tableitem_set_int(rtk_tableitem_t *item, int value)
{
if (item->table->destroyed)
return;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(item->spin), value);
}
void init_tab_lua (GtkWidget *dialog, GtkWidget *tab)
{
if(!pref_list) return; // no option registered => don't create the tab
char tooltip[1024];
GtkWidget *label, *labelev;
GtkWidget *hbox = gtk_hbox_new(5, FALSE);
GtkWidget *vbox1 = gtk_vbox_new(5, TRUE);
GtkWidget *vbox2 = gtk_vbox_new(5, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 20, 20, 20, 20);
gtk_container_add(GTK_CONTAINER(alignment), hbox);
gtk_notebook_append_page(GTK_NOTEBOOK(tab), alignment, gtk_label_new(_("lua options")));
pref_element* cur_elt = pref_list;
while(cur_elt)
{
char pref_name[1024];
get_pref_name(pref_name,1024,cur_elt->script,cur_elt->name);
label = gtk_label_new(cur_elt->label);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
labelev = gtk_event_box_new();
gtk_widget_add_events(labelev, GDK_BUTTON_PRESS_MASK);
gtk_container_add(GTK_CONTAINER(labelev), label);
switch(cur_elt->type)
{
case pref_string:
cur_elt->widget = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(cur_elt->widget), dt_conf_get_string(pref_name));
g_signal_connect(G_OBJECT(cur_elt->widget), "activate", G_CALLBACK(callback_string), cur_elt);
snprintf(tooltip, 1024, _("double click to reset to `%s'"), cur_elt->string_data.default_value);
g_signal_connect(G_OBJECT(labelev), "button-press-event", G_CALLBACK(reset_widget_string), cur_elt);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(response_callback_string), cur_elt);
break;
case pref_bool:
cur_elt->widget = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cur_elt->widget), dt_conf_get_bool(pref_name));
g_signal_connect(G_OBJECT(cur_elt->widget), "toggled", G_CALLBACK(callback_bool), cur_elt);
snprintf(tooltip, 1024, _("double click to reset to `%s'"), cur_elt->bool_data.default_value?"true":"false");
g_signal_connect(G_OBJECT(labelev), "button-press-event", G_CALLBACK(reset_widget_bool), cur_elt);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(response_callback_bool), cur_elt);
break;
case pref_int:
cur_elt->widget = gtk_spin_button_new_with_range(cur_elt->int_data.min, cur_elt->int_data.max, 1);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(cur_elt->widget), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(cur_elt->widget), dt_conf_get_int(pref_name));
g_signal_connect(G_OBJECT(cur_elt->widget), "value-changed", G_CALLBACK(callback_int), cur_elt);
snprintf(tooltip, 1024, _("double click to reset to `%d'"), cur_elt->int_data.default_value);
g_signal_connect(G_OBJECT(labelev), "button-press-event", G_CALLBACK(reset_widget_int), cur_elt);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(response_callback_int), cur_elt);
break;
}
gtk_object_set(GTK_OBJECT(labelev), "tooltip-text", tooltip, (char *)NULL);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(labelev), FALSE);
gtk_object_set(GTK_OBJECT(cur_elt->widget), "tooltip-text", cur_elt->tooltip, (char *)NULL);
gtk_box_pack_start(GTK_BOX(vbox1), labelev, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), cur_elt->widget, FALSE, FALSE, 0);
cur_elt = cur_elt->next;
}
}
static void show_project_properties(gboolean show_build)
{
GeanyProject *p = app->project;
GtkWidget *widget = NULL;
GtkWidget *radio_long_line_custom;
static PropertyDialogElements e;
GSList *node;
g_return_if_fail(app->project != NULL);
entries_modified = FALSE;
if (e.dialog == NULL)
create_properties_dialog(&e);
insert_build_page(&e);
foreach_slist(node, stash_groups)
stash_group_display(node->data, e.dialog);
/* fill the elements with the appropriate data */
gtk_entry_set_text(GTK_ENTRY(e.name), p->name);
gtk_label_set_text(GTK_LABEL(e.file_name), p->file_name);
gtk_entry_set_text(GTK_ENTRY(e.base_path), p->base_path);
radio_long_line_custom = ui_lookup_widget(e.dialog, "radio_long_line_custom_project");
switch (p->long_line_behaviour)
{
case 0: widget = ui_lookup_widget(e.dialog, "radio_long_line_disabled_project"); break;
case 1: widget = ui_lookup_widget(e.dialog, "radio_long_line_default_project"); break;
case 2: widget = radio_long_line_custom; break;
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
widget = ui_lookup_widget(e.dialog, "spin_long_line_project");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), (gdouble)p->long_line_column);
on_radio_long_line_custom_toggled(GTK_TOGGLE_BUTTON(radio_long_line_custom), widget);
if (p->description != NULL)
{ /* set text */
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e.description));
gtk_text_buffer_set_text(buffer, p->description, -1);
}
if (p->file_patterns != NULL)
{ /* set the file patterns */
gchar *str;
str = g_strjoinv(" ", p->file_patterns);
gtk_entry_set_text(GTK_ENTRY(e.patterns), str);
g_free(str);
}
g_signal_emit_by_name(geany_object, "project-dialog-open", e.notebook);
gtk_widget_show_all(e.dialog);
/* note: notebook page must be shown before setting current page */
if (show_build)
gtk_notebook_set_current_page(GTK_NOTEBOOK(e.notebook), e.build_page_num);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(e.notebook), 0);
while (gtk_dialog_run(GTK_DIALOG(e.dialog)) == GTK_RESPONSE_OK)
{
if (update_config(&e, FALSE))
{
g_signal_emit_by_name(geany_object, "project-dialog-confirmed", e.notebook);
if (!write_config(TRUE))
SHOW_ERR(_("Project file could not be written"));
else
{
ui_set_statusbar(TRUE, _("Project \"%s\" saved."), app->project->name);
break;
}
}
}
build_free_fields(e.build_properties);
g_signal_emit_by_name(geany_object, "project-dialog-close", e.notebook);
gtk_notebook_remove_page(GTK_NOTEBOOK(e.notebook), e.build_page_num);
gtk_widget_hide(e.dialog);
}
/** \brief Create and initialise widgets for the refresh rates tab.
*
* The widgets must be preloaded with values from config. If a config value
* is NULL, sensible default values, eg. those from defaults.h should
* be laoded.
*/
GtkWidget *sat_pref_refresh_create (GKeyFile *cfg)
{
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *label;
gint val;
dirty = FALSE;
reset = FALSE;
/* create table */
table = gtk_table_new (6, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
/* data refresh */
label = gtk_label_new (_("Refresh data every"));
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_SHRINK,
0, 0);
dataspin = gtk_spin_button_new_with_range (100, 10000, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (dataspin), 1, 100);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (dataspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (dataspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_GLOBAL_SECTION,
MOD_CFG_TIMEOUT_KEY,
SAT_CFG_INT_MODULE_TIMEOUT);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_MODULE_TIMEOUT);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dataspin), val);
g_signal_connect (G_OBJECT (dataspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), dataspin, 1, 2, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[msec]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 1, 2,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* List View */
label = gtk_label_new (_("Refresh list view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL,
GTK_SHRINK,
0, 0);
listspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (listspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (listspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (listspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_LIST_SECTION,
MOD_CFG_LIST_REFRESH,
SAT_CFG_INT_LIST_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_LIST_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (listspin), val);
g_signal_connect (G_OBJECT (listspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), listspin, 1, 2, 2, 3,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Map View */
label = gtk_label_new (_("Refresh map view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
mapspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (mapspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mapspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mapspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_MAP_SECTION,
MOD_CFG_MAP_REFRESH,
SAT_CFG_INT_MAP_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_MAP_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mapspin), val);
g_signal_connect (G_OBJECT (mapspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), mapspin, 1, 2, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 3, 4,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Polar View */
label = gtk_label_new (_("Refresh polar view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
polarspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (polarspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (polarspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (polarspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_POLAR_SECTION,
MOD_CFG_POLAR_REFRESH,
SAT_CFG_INT_POLAR_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_POLAR_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (polarspin), val);
g_signal_connect (G_OBJECT (polarspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), polarspin, 1, 2, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 4, 5,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Single-Sat View */
label = gtk_label_new (_("Refresh single-sat view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6,
GTK_FILL,
GTK_SHRINK,
0, 0);
singlespin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (singlespin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (singlespin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (singlespin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_REFRESH,
SAT_CFG_INT_SINGLE_SAT_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_SINGLE_SAT_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (singlespin), val);
g_signal_connect (G_OBJECT (singlespin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), singlespin, 1, 2, 5, 6,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 5, 6,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* create vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 20);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
/* create RESET button */
create_reset_button (cfg, GTK_BOX (vbox));
return vbox;
}
int
set_params (dt_lib_module_t *self, const void *params, int size)
{
dt_lib_export_t *d = (dt_lib_export_t *)self->data;
// apply these stored presets again (parse blob)
const char *buf = (const char* )params;
const int max_width = *(const int *)buf;
buf += sizeof(int32_t);
const int max_height = *(const int *)buf;
buf += sizeof(int32_t);
const int iccintent = *(const int *)buf;
buf += sizeof(int32_t);
const char *iccprofile = buf;
buf += strlen(iccprofile) + 1;
// reverse these by setting the gui, not the conf vars!
gtk_combo_box_set_active (d->intent, iccintent + 1);
if(!strcmp(iccprofile, "image"))
{
gtk_combo_box_set_active(d->profile, 0);
}
else
{
GList *prof = d->profiles;
while(prof)
{
dt_lib_export_profile_t *pp = (dt_lib_export_profile_t *)prof->data;
if(!strcmp(pp->filename, iccprofile))
{
gtk_combo_box_set_active(d->profile, pp->pos);
break;
}
prof = g_list_next(prof);
}
}
// parse both names to '\0'
const char *fname = buf;
buf += strlen(fname) + 1;
const char *sname = buf;
buf += strlen(sname) + 1;
// get module by name and fail if not there.
dt_imageio_module_format_t *fmod = dt_imageio_get_format_by_name(fname);
dt_imageio_module_storage_t *smod = dt_imageio_get_storage_by_name(sname);
if(!fmod || !smod) return 1;
const int fsize = *(const int *)buf;
buf += sizeof(int32_t);
const int ssize = *(const int *)buf;
buf += sizeof(int32_t);
if(size != strlen(fname) + strlen(sname) + 2 + 2*sizeof(int32_t) + fsize + ssize + 3*sizeof(int32_t) + strlen(iccprofile) + 1) return 1;
const dt_imageio_module_data_t *fdata = (const dt_imageio_module_data_t *)buf;
_combo_box_set_active_text(d->style, fdata->style);
buf += fsize;
const void *sdata = buf;
// switch modules
set_storage_by_name(d, sname);
set_format_by_name(d, fname);
// set dimensions after switching, to have new range ready.
gtk_spin_button_set_value(d->width, max_width);
gtk_spin_button_set_value(d->height, max_height);
// propagate to modules
int res = 0;
if(ssize) res += smod->set_params(smod, sdata, ssize);
if(fsize) res += fmod->set_params(fmod, fdata, fsize);
return res;
}
void menu_request_settings(void)
{
gint result;
GtkDialog * dialog;
GtkToggleButton * autostart_studio_button;
GtkToggleButton * send_notifications_button;
GtkEntry * shell_entry;
GtkEntry * terminal_entry;
GtkSpinButton * js_delay_spin;
GtkEntry * jack_conf_tool_entry;
bool autostart;
bool notify;
const char * shell;
const char * terminal;
unsigned int js_delay;
const char * jack_conf_tool;
autostart_studio_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("settings_studio_autostart_checkbutton"));
send_notifications_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("settings_send_notifications_checkbutton"));
shell_entry = GTK_ENTRY(get_gtk_builder_widget("settings_shell_entry"));
terminal_entry = GTK_ENTRY(get_gtk_builder_widget("settings_terminal_entry"));
js_delay_spin = GTK_SPIN_BUTTON(get_gtk_builder_widget("settings_js_delay_spin"));
jack_conf_tool_entry = GTK_ENTRY(get_gtk_builder_widget("settings_jack_conf_tool_entry"));
dialog = GTK_DIALOG(get_gtk_builder_widget("settings_dialog"));
if (!conf_get_bool(LADISH_CONF_KEY_DAEMON_STUDIO_AUTOSTART, &autostart))
{
autostart = LADISH_CONF_KEY_DAEMON_STUDIO_AUTOSTART_DEFAULT;
}
if (!conf_get_bool(LADISH_CONF_KEY_DAEMON_NOTIFY, ¬ify))
{
notify = LADISH_CONF_KEY_DAEMON_NOTIFY_DEFAULT;
}
if (!conf_get(LADISH_CONF_KEY_DAEMON_SHELL, &shell))
{
shell = LADISH_CONF_KEY_DAEMON_SHELL_DEFAULT;
}
if (!conf_get(LADISH_CONF_KEY_DAEMON_TERMINAL, &terminal))
{
terminal = LADISH_CONF_KEY_DAEMON_TERMINAL_DEFAULT;
}
if (!conf_get_uint(LADISH_CONF_KEY_DAEMON_JS_SAVE_DELAY, &js_delay))
{
js_delay = LADISH_CONF_KEY_DAEMON_JS_SAVE_DELAY_DEFAULT;
}
if (!conf_get(LADISH_CONF_KEY_JACK_CONF_TOOL, &jack_conf_tool))
{
jack_conf_tool = LADISH_CONF_KEY_JACK_CONF_TOOL_DEFAULT;
}
gtk_toggle_button_set_active(autostart_studio_button, autostart);
gtk_toggle_button_set_active(send_notifications_button, notify);
gtk_entry_set_text(shell_entry, shell);
gtk_entry_set_text(terminal_entry, terminal);
gtk_entry_set_text(jack_conf_tool_entry, jack_conf_tool);
gtk_spin_button_set_range(js_delay_spin, 0, 1000);
gtk_spin_button_set_increments(js_delay_spin, 1, 2);
gtk_spin_button_set_value(js_delay_spin, js_delay);
gtk_widget_show(GTK_WIDGET(dialog));
result = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_hide(GTK_WIDGET(dialog));
if (result != GTK_RESPONSE_OK)
{
return;
}
autostart = gtk_toggle_button_get_active(autostart_studio_button);
notify = gtk_toggle_button_get_active(send_notifications_button);
shell = gtk_entry_get_text(shell_entry);
terminal = gtk_entry_get_text(terminal_entry);
js_delay = gtk_spin_button_get_value(js_delay_spin);
jack_conf_tool = gtk_entry_get_text(jack_conf_tool_entry);
if (!conf_set_bool(LADISH_CONF_KEY_DAEMON_STUDIO_AUTOSTART, autostart) ||
!conf_set_bool(LADISH_CONF_KEY_DAEMON_NOTIFY, notify) ||
!conf_set(LADISH_CONF_KEY_DAEMON_SHELL, shell) ||
!conf_set(LADISH_CONF_KEY_DAEMON_TERMINAL, terminal) ||
!conf_set_uint(LADISH_CONF_KEY_DAEMON_JS_SAVE_DELAY, js_delay) ||
!conf_set(LADISH_CONF_KEY_JACK_CONF_TOOL, jack_conf_tool))
{
error_message_box(_("Storing settings"));
}
}
/* Creates a "goto date" dialog and runs it */
void
goto_dialog (GnomeCalendar *gcal)
{
time_t start_time;
struct icaltimetype tt;
int b;
char *gladefile;
if (dlg) {
return;
}
dlg = g_new0 (GoToDialog, 1);
/* Load the content widgets */
gladefile = g_build_filename (EVOLUTION_GLADEDIR,
"goto-dialog.glade",
NULL);
dlg->xml = glade_xml_new (gladefile, NULL, NULL);
g_free (gladefile);
if (!dlg->xml) {
g_message ("goto_dialog(): Could not load the Glade XML file!");
g_free (dlg);
return;
}
if (!get_widgets (dlg)) {
g_message ("goto_dialog(): Could not find all widgets in the XML file!");
g_free (dlg);
return;
}
dlg->gcal = gcal;
gnome_calendar_get_selected_time_range (dlg->gcal, &start_time, NULL);
tt = icaltime_from_timet_with_zone (start_time, FALSE, gnome_calendar_get_timezone (gcal));
dlg->year_val = tt.year;
dlg->month_val = tt.month - 1;
dlg->day_val = tt.day;
gtk_option_menu_set_history (GTK_OPTION_MENU (dlg->month), dlg->month_val);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dlg->year), dlg->year_val);
create_ecal (dlg);
goto_dialog_init_widgets (dlg);
gtk_window_set_transient_for (GTK_WINDOW (dlg->dialog),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (gcal))));
/* set initial selection to current day */
dlg->ecal->calitem->selection_set = TRUE;
dlg->ecal->calitem->selection_start_month_offset = 0;
dlg->ecal->calitem->selection_start_day = tt.day;
dlg->ecal->calitem->selection_end_month_offset = 0;
dlg->ecal->calitem->selection_end_day = tt.day;
/* Set week_start_day. Convert it to 0 (Mon) to 6 (Sun), which is what we use. */
dlg->ecal->calitem->week_start_day = (calendar_config_get_week_start_day () + 6) % 7;
gnome_canvas_item_grab_focus (GNOME_CANVAS_ITEM (dlg->ecal->calitem));
b = gtk_dialog_run (GTK_DIALOG (dlg->dialog));
gtk_widget_destroy (dlg->dialog);
if (b == 0)
goto_today (dlg);
g_object_unref (dlg->xml);
g_free (dlg);
dlg = NULL;
}
void
ags_navigation_init(AgsNavigation *navigation)
{
GtkHBox *hbox;
GtkLabel *label;
navigation->flags = 0;
navigation->soundcard = NULL;
g_signal_connect_after(G_OBJECT(navigation), "parent-set\0",
G_CALLBACK(ags_navigation_parent_set_callback), NULL);
/* GtkWidget */
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_box_pack_start((GtkBox *) navigation, (GtkWidget *) hbox, FALSE, FALSE, 2);
navigation->expander = (GtkToggleButton *) gtk_toggle_button_new();
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) navigation->expander, FALSE, FALSE, 2);
gtk_container_add((GtkContainer *) navigation->expander,
(GtkWidget *) gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE));
label = (GtkLabel *) gtk_label_new("bpm\0");
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->bpm = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 1000.0, 1.0);
navigation->bpm->adjustment->value = 120.0;
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) navigation->bpm, FALSE, FALSE, 2);
navigation->current_bpm = 120.0;
navigation->rewind = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->rewind, FALSE, FALSE, 0);
navigation->previous = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->previous, FALSE, FALSE, 0);
navigation->play = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->play, FALSE, FALSE, 0);
navigation->stop = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->stop, FALSE, FALSE, 0);
navigation->next = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_NEXT, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->next, FALSE, FALSE, 0);
navigation->forward = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->forward, FALSE, FALSE, 0);
navigation->loop = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(navigation->loop),
TRUE);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("position\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->position_time = (GtkLabel *) gtk_label_new(g_strdup("00:00.00\0"));
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->position_time, FALSE, FALSE, 2);
navigation->position_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, AGS_NOTE_EDIT_MAX_CONTROLS * 64.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->position_tact, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("duration\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->duration_time = (GtkLabel *) gtk_label_new(NULL);
g_object_set(navigation->duration_time,
"label\0", g_strdup("0000:00.00\0"),
NULL);
gtk_widget_queue_draw(navigation->duration_time);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->duration_time, FALSE, FALSE, 2);
navigation->duration_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, AGS_NOTE_EDIT_MAX_CONTROLS * 64.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->duration_tact, FALSE, FALSE, 2);
/* expansion */
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
// GTK_WIDGET_SET_FLAGS((GtkWidget *) hbox, GTK_NO_SHOW_ALL);
gtk_box_pack_start((GtkBox *) navigation, (GtkWidget *) hbox, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("loop L\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->loop_left_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 65000.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop_left_tact, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("loop R\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->loop_right_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 65000.0, 1.0);
gtk_spin_button_set_value(navigation->loop_right_tact,
4.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop_right_tact, FALSE, FALSE, 2);
navigation->scroll = (GtkCheckButton *) gtk_check_button_new_with_label("auto-scroll\0");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(navigation->scroll),
TRUE);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->scroll, FALSE, FALSE, 2);
}
/**
* dialog_init:
* @state:
*
* Create the dialog (guru).
*
**/
static gboolean
dialog_init (SolverState *state)
{
GtkGrid *grid;
GnmSolverParameters *param;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeViewColumn *column;
GSList *cl;
GnmCell *target_cell;
GnmValue const *input;
int i;
param = state->sheet->solver_parameters;
state->gui = gnm_gtk_builder_load ("solver.ui", NULL, GO_CMD_CONTEXT (state->wbcg));
if (state->gui == NULL)
return TRUE;
state->dialog = go_gtk_builder_get_widget (state->gui, "Solver");
if (state->dialog == NULL)
return TRUE;
state->notebook = go_gtk_builder_get_widget (state->gui, "solver_notebook");
/* buttons */
state->solve_button = go_gtk_builder_get_widget (state->gui, "solvebutton");
g_signal_connect (G_OBJECT (state->solve_button), "clicked",
G_CALLBACK (cb_dialog_solve_clicked), state);
state->close_button = go_gtk_builder_get_widget (state->gui, "closebutton");
g_signal_connect (G_OBJECT (state->close_button), "clicked",
G_CALLBACK (cb_dialog_close_clicked), state);
state->help_button = go_gtk_builder_get_widget (state->gui, "helpbutton");
gnm_init_help_button (state->help_button, GNUMERIC_HELP_LINK_SOLVER);
state->add_button = go_gtk_builder_get_widget (state->gui, "addbutton");
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0.5, .5);
g_signal_connect_swapped (G_OBJECT (state->add_button), "clicked",
G_CALLBACK (cb_dialog_add_clicked), state);
state->change_button = go_gtk_builder_get_widget (state->gui,
"changebutton");
g_signal_connect (G_OBJECT (state->change_button), "clicked",
G_CALLBACK (cb_dialog_change_clicked), state);
state->delete_button = go_gtk_builder_get_widget (state->gui,
"deletebutton");
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0.5, .5);
g_signal_connect (G_OBJECT (state->delete_button), "clicked",
G_CALLBACK (cb_dialog_delete_clicked), state);
state->stop_button = go_gtk_builder_get_widget (state->gui, "stopbutton");
g_signal_connect_swapped (G_OBJECT (state->stop_button),
"clicked", G_CALLBACK (cb_stop_solver),
state);
/* target_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"parameter-grid"));
state->target_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->target_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->target_entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->target_entry), 1, 0, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->target_entry));
gtk_widget_show (GTK_WIDGET (state->target_entry));
g_signal_connect_after (G_OBJECT (state->target_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity),
state);
/* change_cell_entry */
state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->change_cell_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->change_cell_entry), TRUE);
gtk_grid_attach (grid,
GTK_WIDGET (state->change_cell_entry), 1, 2, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->change_cell_entry));
gtk_widget_show (GTK_WIDGET (state->change_cell_entry));
g_signal_connect_after (G_OBJECT (state->change_cell_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity), state);
/* Algorithm */
state->algorithm_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "algorithm_combo"));
renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (state->algorithm_combo), renderer,
"text", 0,
NULL);
fill_algorithm_combo (state, param->options.model_type);
for (i = 0; model_type_group[i]; i++) {
const char *bname = model_type_group[i];
GtkWidget *w = go_gtk_builder_get_widget(state->gui, bname);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
param->options.model_type ==
(GnmSolverModelType)i);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_model_type_clicked), state);
}
/* Options */
state->max_iter_entry = go_gtk_builder_get_widget (state->gui,
"max_iter_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_iter_entry),
param->options.max_iter);
state->max_time_entry = go_gtk_builder_get_widget (state->gui,
"max_time_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_time_entry),
param->options.max_time_sec);
state->gradient_order_entry = go_gtk_builder_get_widget (state->gui,
"gradient_order_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->gradient_order_entry),
param->options.gradient_order);
/* lhs_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"constraints-grid"));
state->lhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->lhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->lhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->lhs.entry), 0, 4, 1, 1);
state->lhs.label = go_gtk_builder_get_widget (state->gui, "lhs_label");
gtk_label_set_mnemonic_widget (GTK_LABEL (state->lhs.label),
GTK_WIDGET (state->lhs.entry));
gtk_widget_show (GTK_WIDGET (state->lhs.entry));
g_signal_connect_after (G_OBJECT (state->lhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->lhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* rhs_entry */
state->rhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->rhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL |
GNM_EE_CONSTANT_ALLOWED,
GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->rhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->rhs.entry), 2, 4, 1, 1);
gtk_widget_show (GTK_WIDGET (state->rhs.entry));
state->rhs.label = go_gtk_builder_get_widget (state->gui, "rhs_label");
gtk_label_set_mnemonic_widget (
GTK_LABEL (state->rhs.label), GTK_WIDGET (state->rhs.entry));
g_signal_connect_after (G_OBJECT (state->rhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->rhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* type_menu */
state->type_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "type_menu"));
gtk_combo_box_set_active (state->type_combo, 0);
g_signal_connect (state->type_combo, "changed",
G_CALLBACK (dialog_set_sec_button_sensitivity),
state);
/* constraint_list */
state->constraint_list = GTK_TREE_VIEW (go_gtk_builder_get_widget
(state->gui, "constraint_list"));
state->constr = NULL;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (state->constraint_list)), "changed",
G_CALLBACK (constraint_select_click), state);
gtk_tree_view_set_reorderable (state->constraint_list, TRUE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (state->constraint_list, GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
_("Subject to the Constraints:"),
renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (state->constraint_list, column);
{
GtkWidget *w = GTK_WIDGET (state->constraint_list);
int width, height, vsep;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (w,
"vertical_separator", &vsep,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_widget_set_size_request (w,
-1,
(2 * height + vsep) * (4 + 1));
g_object_unref (layout);
}
/* Loading the old solver specs... from param */
for (cl = param->constraints; cl; cl = cl->next) {
GnmSolverConstraint const *c = cl->data;
GtkTreeIter iter;
char *str;
gtk_list_store_append (store, &iter);
str = gnm_solver_constraint_as_str (c, state->sheet);
gtk_list_store_set (store, &iter, 0, str, 1, c, -1);
g_free (str);
}
g_object_unref (store);
INIT_BOOL_ENTRY ("autoscale_button", options.automatic_scaling);
INIT_BOOL_ENTRY ("non_neg_button", options.assume_non_negative);
INIT_BOOL_ENTRY ("all_int_button", options.assume_discrete);
INIT_BOOL_ENTRY ("program", options.program_report);
INIT_BOOL_ENTRY ("sensitivity", options.sensitivity_report);
input = gnm_solver_param_get_input (param);
if (input != NULL)
gnm_expr_entry_load_from_text (state->change_cell_entry,
value_peek_string (input));
target_cell = gnm_solver_param_get_target_cell (param);
if (target_cell)
gnm_expr_entry_load_from_text (state->target_entry,
cell_name (target_cell));
else {
SheetView *sv = wb_control_cur_sheet_view
(GNM_WBC (state->wbcg));
if (sv) {
GnmRange first = {sv->edit_pos, sv->edit_pos};
gnm_expr_entry_load_from_range (state->target_entry,
state->sheet, &first);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "max_button")),
param->problem_type == GNM_SOLVER_MAXIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "min_button")),
param->problem_type == GNM_SOLVER_MINIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "no_scenario")),
! param->options.add_scenario);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "optimal_scenario")),
param->options.add_scenario);
state->scenario_name_entry = go_gtk_builder_get_widget
(state->gui, "scenario_name_entry");
gtk_entry_set_text (GTK_ENTRY (state->scenario_name_entry),
param->options.scenario_name);
state->run.status_widget = go_gtk_builder_get_widget (state->gui, "solver_status_label");
state->run.problem_status_widget = go_gtk_builder_get_widget (state->gui, "problem_status_label");
state->run.objective_value_widget = go_gtk_builder_get_widget (state->gui, "objective_value_label");
state->run.timer_widget = go_gtk_builder_get_widget (state->gui, "elapsed_time_label");
state->run.spinner = go_gtk_builder_get_widget (state->gui, "run_spinner");
/* Done */
gnm_expr_entry_grab_focus (state->target_entry, FALSE);
wbcg_set_entry (state->wbcg, state->target_entry);
dialog_set_main_button_sensitivity (NULL, state);
dialog_set_sec_button_sensitivity (NULL, state);
/* dialog */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK (cb_dialog_solver_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)unref_state);
return FALSE;
}
static GtkWidget *
create_window (void)
{
GtkWidget *window, *hbox, *vbox, *flowbox_cntl, *items_cntl;
GtkWidget *flowbox, *widget, *expander, *swindow;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_widget_show (vbox);
gtk_widget_show (hbox);
gtk_container_add (GTK_CONTAINER (window), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
flowbox = gtk_flow_box_new ();
gtk_widget_set_halign (flowbox, GTK_ALIGN_END);
the_flowbox = (GtkFlowBox *)flowbox;
gtk_widget_set_halign (flowbox, INITIAL_HALIGN);
gtk_widget_set_valign (flowbox, INITIAL_VALIGN);
gtk_flow_box_set_column_spacing (GTK_FLOW_BOX (flowbox), INITIAL_CSPACING);
gtk_flow_box_set_row_spacing (GTK_FLOW_BOX (flowbox), INITIAL_RSPACING);
gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MINIMUM_LENGTH);
gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (flowbox);
gtk_container_add (GTK_CONTAINER (swindow), flowbox);
gtk_flow_box_set_hadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swindow)));
gtk_flow_box_set_vadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swindow)));
g_signal_connect (flowbox, "child-activated", G_CALLBACK (on_child_activated), NULL);
g_signal_connect (flowbox, "selected-children-changed", G_CALLBACK (on_selected_children_changed), NULL);
/* Add Flowbox test control frame */
expander = gtk_expander_new ("Flow Box controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
flowbox_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (flowbox_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), flowbox_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label ("Homogeneous");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether the items should be displayed at the same size");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (homogeneous_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Activate on single click");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
g_object_bind_property (widget, "active",
flowbox, "activate-on-single-click",
G_BINDING_SYNC_CREATE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
/* Add alignment controls */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (horizontal_alignment_changed), flowbox);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_VALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (vertical_alignment_changed), flowbox);
/* Add Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the flowbox orientation");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), flowbox);
/* Add selection mode control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "None");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Single");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Browse");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Multiple");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the selection mode");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (selection_mode_changed), flowbox);
/* Add minimum line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (line_length_changed), flowbox);
/* Add natural line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the natural amount of items per line ");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (max_line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (max_line_length_changed), flowbox);
/* Add horizontal/vertical spacing controls */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("H Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_CSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("V Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_RSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
/* filtering and sorting */
widget = gtk_check_button_new_with_label ("Filter");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether some items should be filtered out");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (filter_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Sort");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether items should be sorted");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (sort_toggled), flowbox);
/* Add test items control frame */
expander = gtk_expander_new ("Test item controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
items_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (items_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), items_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
/* Add Items control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Simple");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Focus");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Wrappy");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Stock");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Images");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item set to use");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (items_changed), flowbox);
/* Add Text Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (text_orientation_changed), flowbox);
populate_items (GTK_FLOW_BOX (flowbox));
/* This line was added only for the convenience of reproducing
* a height-for-width inside GtkScrolledWindow bug (bug 629778).
* -Tristan
*/
gtk_window_set_default_size (GTK_WINDOW (window), 390, -1);
return window;
}
static GtkCellEditable *
parasite_property_cell_renderer_start_editing(GtkCellRenderer *renderer,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
PangoFontDescription *font_desc;
GtkCellEditable *editable = NULL;
GObject *object;
const char *name;
GValue gvalue = {0};
GParamSpec *prop;
g_object_get(renderer,
"object", &object,
"name", &name,
NULL);
prop = g_object_class_find_property(G_OBJECT_GET_CLASS(object), name);
if (!(prop->flags & G_PARAM_WRITABLE))
return NULL;
g_value_init(&gvalue, prop->value_type);
g_object_get_property(object, name, &gvalue);
if (G_VALUE_HOLDS_ENUM(&gvalue) || G_VALUE_HOLDS_BOOLEAN(&gvalue))
{
GtkWidget *combobox = gtk_combo_box_new_text();
gtk_widget_show(combobox);
g_object_set(G_OBJECT(combobox), "has-frame", FALSE, NULL);
GList *renderers;
if (G_VALUE_HOLDS_BOOLEAN(&gvalue))
{
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "FALSE");
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "TRUE");
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox),
g_value_get_boolean(&gvalue) ? 1 : 0);
}
else if (G_VALUE_HOLDS_ENUM(&gvalue))
{
gint value = g_value_get_enum(&gvalue);
GEnumClass *enum_class = G_PARAM_SPEC_ENUM(prop)->enum_class;
guint i;
for (i = 0; i < enum_class->n_values; i++)
{
GEnumValue *enum_value = &enum_class->values[i];
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox),
enum_value->value_name);
if (enum_value->value == value)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), i);
}
}
renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(combobox));
g_object_set(G_OBJECT(renderers->data), "scale", TREE_TEXT_SCALE, NULL);
g_list_free(renderers);
editable = GTK_CELL_EDITABLE(combobox);
}
else if (G_VALUE_HOLDS_STRING(&gvalue))
{
GtkWidget *entry = gtk_entry_new();
gtk_widget_show(entry);
gtk_entry_set_text(GTK_ENTRY(entry), g_value_get_string(&gvalue));
editable = GTK_CELL_EDITABLE(entry);
}
else if (G_VALUE_HOLDS_INT(&gvalue) ||
G_VALUE_HOLDS_UINT(&gvalue) ||
G_VALUE_HOLDS_INT64(&gvalue) ||
G_VALUE_HOLDS_UINT64(&gvalue) ||
G_VALUE_HOLDS_LONG(&gvalue) ||
G_VALUE_HOLDS_ULONG(&gvalue) ||
G_VALUE_HOLDS_DOUBLE(&gvalue))
{
double min, max, value;
GtkWidget *spinbutton;
guint digits = 0;
if (G_VALUE_HOLDS_INT(&gvalue))
{
GParamSpecInt *paramspec = G_PARAM_SPEC_INT(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_int(&gvalue);
}
else if (G_VALUE_HOLDS_UINT(&gvalue))
{
GParamSpecUInt *paramspec = G_PARAM_SPEC_UINT(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_uint(&gvalue);
}
else if (G_VALUE_HOLDS_INT64(&gvalue))
{
GParamSpecInt64 *paramspec = G_PARAM_SPEC_INT64(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_int64(&gvalue);
}
else if (G_VALUE_HOLDS_UINT64(&gvalue))
{
GParamSpecUInt64 *paramspec = G_PARAM_SPEC_UINT64(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_uint64(&gvalue);
}
else if (G_VALUE_HOLDS_LONG(&gvalue))
{
GParamSpecLong *paramspec = G_PARAM_SPEC_LONG(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_long(&gvalue);
}
else if (G_VALUE_HOLDS_ULONG(&gvalue))
{
GParamSpecULong *paramspec = G_PARAM_SPEC_ULONG(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_ulong(&gvalue);
}
else if (G_VALUE_HOLDS_DOUBLE(&gvalue))
{
GParamSpecDouble *paramspec = G_PARAM_SPEC_DOUBLE(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_double(&gvalue);
digits = 2;
}
else
{
// Shouldn't really be able to happen.
return NULL;
}
spinbutton = gtk_spin_button_new_with_range(min, max, 1);
gtk_widget_show(spinbutton);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton), value);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spinbutton), digits);
editable = GTK_CELL_EDITABLE(spinbutton);
}
font_desc = pango_font_description_new();
pango_font_description_set_size(font_desc, 8 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(editable), font_desc);
pango_font_description_free(font_desc);
g_value_unset(&gvalue);
g_signal_connect(G_OBJECT(editable), "editing_done",
G_CALLBACK(parasite_property_cell_renderer_stop_editing),
renderer);
g_object_set_data_full(G_OBJECT(editable), "_prop_name", g_strdup(name),
g_free);
g_object_set_data(G_OBJECT(editable), "_prop_object", object);
return editable;
}
static void
port_event(LV2UI_Handle handle,
uint32_t port_index,
uint32_t buffer_size,
uint32_t format,
const void* buffer) {
DrMrPortIndex index = (DrMrPortIndex)port_index;
DrMrUi* ui = (DrMrUi*)handle;
if (index == DRMR_KITNUM) {
if (format != 0)
fprintf(stderr,"Invalid format for kitnum: %i\n",format);
else {
int kit = (int)(*((float*)buffer));
ui->kitReq = kit;
if (!idle) {
idle = TRUE;
g_idle_add(kit_callback,ui);
}
}
}
else if (index == DRMR_BASENOTE) {
int base = (int)(*((float*)buffer));
if (base >= 21 && base <= 107) {
setBaseLabel((int)base);
gtk_spin_button_set_value(ui->base_spin,base);
gtk_label_set_markup(ui->base_label,baseLabelBuf);
}
}
else if (index == DRMR_IGNORE_VELOCITY) {
int ig = (int)(*((float*)buffer));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->velocity_checkbox),
ig?TRUE:FALSE);
}
else if (index == DRMR_IGNORE_NOTE_OFF) {
int ig = (int)(*((float*)buffer));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->note_off_checkbox),
ig?TRUE:FALSE);
}
else if (index >= DRMR_GAIN_ONE &&
index <= DRMR_GAIN_THIRTYTWO) {
float gain = *(float*)buffer;
int idx = index-DRMR_GAIN_ONE;
ui->gain_vals[idx] = gain;
if (idx < ui->samples && ui->gain_sliders) {
struct slider_callback_data* data = malloc(sizeof(struct slider_callback_data));
data->range = GTK_RANGE(ui->gain_sliders[idx]);
data->val = gain;
g_idle_add(slider_callback,data);
//GtkRange* range = GTK_RANGE(ui->gain_sliders[idx]);
//gtk_range_set_value(range,gain);
}
}
else if (index >= DRMR_PAN_ONE &&
index <= DRMR_PAN_THIRTYTWO) {
float pan = *(float*)buffer;
int idx = index-DRMR_PAN_ONE;
ui->pan_vals[idx] = pan;
if (idx < ui->samples && ui->pan_sliders) {
struct slider_callback_data* data = malloc(sizeof(struct slider_callback_data));
data->range = GTK_RANGE(ui->pan_sliders[idx]);
data->val = pan;
g_idle_add(slider_callback,data);
}
}
}
void
dialog_so_size (WBCGtk *wbcg, GObject *so)
{
GtkBuilder *gui;
SOSizeState *state;
int width, height;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, SO_SIZE_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("sheetobject-size.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SOSizeState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg));
state->sheet = sv_sheet (state->sv);
state->scg = wbcg_get_nth_scg (wbcg, state->sheet->index_in_wb);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "object-size");
state->so = SHEET_OBJECT (so);
g_object_ref (so);
state->nameentry = GTK_ENTRY (go_gtk_builder_get_widget (state->gui, "name-entry"));
state->old_anchor = NULL;
state->old_name = NULL;
g_object_get (so, "name", &state->old_name, NULL);
if (state->old_name == NULL)
state->old_name = g_strdup ("");
gtk_entry_set_text (state->nameentry, state->old_name);
state->so_name_changed = FALSE;
g_signal_connect (G_OBJECT (state->nameentry),
"focus-out-event",
G_CALLBACK (cb_dialog_so_size_name_changed),
state);
state->so_print_check_changed = FALSE;
state->wpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "w-pts-label"));
state->wspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "w-spin"));
state->hpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "h-pts-label"));
state->hspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "h-spin"));
state->xpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "x-pts-label"));
state->xspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "x-spin"));
state->ypoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "y-pts-label"));
state->yspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "y-spin"));
state->print_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui,
"print-check"));
dialog_so_size_load (state);
state->active_anchor = sheet_object_anchor_dup (sheet_object_get_anchor
(state->so));
width = state->coords[2] - state->coords[0];
height = state->coords[3] - state->coords[1];
gtk_spin_button_set_value (state->wspin, (width < 0) ? - width : width);
gtk_spin_button_set_value (state->hspin, (height < 0) ? - height : height);
gtk_spin_button_set_value (state->xspin, 0.);
gtk_spin_button_set_value (state->yspin, 0.);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->print_check),
!(state->so->flags & SHEET_OBJECT_PRINT));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->wpoints);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->hpoints);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->xpoints);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->ypoints);
g_signal_connect (G_OBJECT (state->print_check),
"toggled",
G_CALLBACK (cb_dialog_so_size_print_check_toggled),
state);
cb_dialog_so_size_value_changed_update_points (state->wspin, GTK_LABEL (state->wpoints));
cb_dialog_so_size_value_changed_update_points (state->hspin, GTK_LABEL (state->hpoints));
cb_dialog_so_size_value_changed_update_points (state->xspin, GTK_LABEL (state->xpoints));
cb_dialog_so_size_value_changed_update_points (state->yspin, GTK_LABEL (state->ypoints));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_cancel_clicked), state);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_SO_SIZE);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_so_size_destroy);
gnumeric_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
SO_SIZE_DIALOG_KEY);
dialog_so_size_button_sensitivity (state);
gtk_widget_show (state->dialog);
}
static void presence_clicked_cb(GtkWidget *w, gpointer nul)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *to_entry;
GtkWidget *status_entry;
GtkWidget *priority_entry;
GtkWidget *label;
GtkWidget *show_combo;
GtkWidget *type_combo;
GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
GtkTextIter iter;
GtkTextBuffer *buffer;
const char *to, *type, *status, *show, *priority;
int result;
char *stanza;
GtkWidget *dialog = gtk_dialog_new_with_buttons("<presence/>",
GTK_WINDOW(console->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 12);
#if GTK_CHECK_VERSION(2,14,0)
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
#else
vbox = GTK_DIALOG(dialog)->vbox;
#endif
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("To:");
gtk_size_group_add_widget(sg, label);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
to_entry = gtk_entry_new();
gtk_entry_set_activates_default (GTK_ENTRY (to_entry), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), to_entry, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Type:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(sg, label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
type_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "default");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "unavailable");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "subscribe");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "unsubscribe");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "subscribed");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "unsubscribed");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "probe");
gtk_combo_box_append_text(GTK_COMBO_BOX(type_combo), "error");
gtk_combo_box_set_active(GTK_COMBO_BOX(type_combo), 0);
gtk_box_pack_start(GTK_BOX(hbox), type_combo, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Show:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(sg, label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
show_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(show_combo), "default");
gtk_combo_box_append_text(GTK_COMBO_BOX(show_combo), "away");
gtk_combo_box_append_text(GTK_COMBO_BOX(show_combo), "dnd");
gtk_combo_box_append_text(GTK_COMBO_BOX(show_combo), "xa");
gtk_combo_box_append_text(GTK_COMBO_BOX(show_combo), "chat");
gtk_combo_box_set_active(GTK_COMBO_BOX(show_combo), 0);
gtk_box_pack_start(GTK_BOX(hbox), show_combo, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Status:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(sg, label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
status_entry = gtk_entry_new();
gtk_entry_set_activates_default (GTK_ENTRY (status_entry), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), status_entry, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Priority:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(sg, label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
priority_entry = gtk_spin_button_new_with_range(-128, 127, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(priority_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), priority_entry, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
to = gtk_entry_get_text(GTK_ENTRY(to_entry));
type = gtk_combo_box_get_active_text(GTK_COMBO_BOX(type_combo));
if (!strcmp(type, "default"))
type = "";
show = gtk_combo_box_get_active_text(GTK_COMBO_BOX(show_combo));
if (!strcmp(show, "default"))
show = "";
status = gtk_entry_get_text(GTK_ENTRY(status_entry));
priority = gtk_entry_get_text(GTK_ENTRY(priority_entry));
if (!strcmp(priority, "0"))
priority = "";
stanza = g_strdup_printf("<presence %s%s%s id='console%x' %s%s%s>"
"%s%s%s%s%s%s%s%s%s"
"</presence>",
*to ? "to='" : "",
*to ? to : "",
*to ? "'" : "",
g_random_int(),
*type ? "type='" : "",
*type ? type : "",
*type ? "'" : "",
*show ? "<show>" : "",
*show ? show : "",
*show ? "</show>" : "",
*status ? "<status>" : "",
*status ? status : "",
*status ? "</status>" : "",
*priority ? "<priority>" : "",
*priority ? priority : "",
*priority ? "</priority>" : "");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(console->entry));
gtk_text_buffer_set_text(buffer, stanza, -1);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, strstr(stanza, "</presence>") - stanza);
gtk_text_buffer_place_cursor(buffer, &iter);
g_free(stanza);
gtk_widget_destroy(dialog);
g_object_unref(sg);
}
void CUIHandler::ShowSettingsDlg(void)
{
GtkWidget* settingsDlg;
GtkWidget* dialog_vbox1;
GtkWidget* frame4;
GtkWidget* alignment4;
GtkWidget* vbox2;
GtkWidget* radiobuttonBt;
GtkWidget* hbox2;
GtkWidget* radiobuttonInet;
GtkWidget* label5;
GtkWidget* inetPort;
GtkWidget* label4;
GtkWidget* dialog_action_area1;
CUserSettings crtSettings = pSmartEngine->GetSettings();
settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences",
GTK_WINDOW(pSmartEngine->GetMainWindow()),
GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox;
gtk_widget_show (dialog_vbox1);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (frame4), alignment4);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (alignment4), vbox2);
radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth");
gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)");
gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0);
label5 = gtk_label_new(" Port: ");
gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);
inetPort = gtk_spin_button_new_with_range(1025, 65536, 1);
gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0);
label4 = gtk_label_new("Connection");
gtk_frame_set_label_widget(GTK_FRAME(frame4), label4);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area;
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort);
if(crtSettings.connectionType == CONN_BLUETOOTH)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE);
g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE);
g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort);
gtk_widget_show_all(settingsDlg);
if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK)
{
CUserSettings newSettings = crtSettings;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt)))
{
newSettings.connectionType = CONN_BLUETOOTH;
}
else
{
newSettings.connectionType = CONN_INET;
newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort));
}
pSmartEngine->SaveSettings(newSettings);
}
gtk_widget_destroy(settingsDlg);
}
static void
gth_slideshow_preferences_construct (GthSlideshowPreferences *self,
const char *current_transition,
gboolean automatic,
int delay,
gboolean wrap_around,
gboolean random_order)
{
GtkListStore *model;
GtkCellRenderer *renderer;
GList *transitions;
int i, i_active;
GList *scan;
GtkTreeIter iter;
self->priv->builder = _gtk_builder_new_from_file ("slideshow-preferences.ui", "slideshow");
gtk_container_add (GTK_CONTAINER (self), _gtk_builder_get_widget (self->priv->builder, "preferences_page"));
model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
self->priv->transition_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->transition_combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->transition_combobox),
renderer,
"text", TRANSITION_COLUMN_DISPLAY_NAME,
NULL);
transitions = gth_main_get_registered_objects (GTH_TYPE_TRANSITION);
for (i = 0, i_active = 0, scan = transitions; scan; scan = scan->next, i++) {
GthTransition *transition = scan->data;
if (g_strcmp0 (gth_transition_get_id (transition), current_transition) == 0)
i_active = i;
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
TRANSITION_COLUMN_ID, gth_transition_get_id (transition),
TRANSITION_COLUMN_DISPLAY_NAME, gth_transition_get_display_name (transition),
-1);
}
if (g_strcmp0 ("random", current_transition) == 0)
i_active = i;
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
TRANSITION_COLUMN_ID, "random",
TRANSITION_COLUMN_DISPLAY_NAME, _("Random"),
-1);
gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->transition_combobox), i_active);
gtk_widget_show (self->priv->transition_combobox);
gtk_box_pack_start (GTK_BOX (_gtk_builder_get_widget (self->priv->builder, "transition_box")), self->priv->transition_combobox, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton")), automatic);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (_gtk_builder_get_widget (self->priv->builder, "change_delay_spinbutton")), ((float) delay) / 1000.0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "wrap_around_checkbutton")), wrap_around);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "random_order_checkbutton")), random_order);
/* signals */
g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "personalize_checkbutton"),
"toggled",
G_CALLBACK (personalize_checkbutton_toggled_cb),
self);
g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton"),
"toggled",
G_CALLBACK (automatic_checkbutton_toggled_cb),
self);
g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "remove_file_button"),
"clicked",
G_CALLBACK (remove_file_button_clicked_cb),
self);
g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "add_file_button"),
"clicked",
G_CALLBACK (add_file_button_clicked_cb),
self);
}
void AP_UnixDialog_Lists::loadXPDataIntoLocal(void)
{
//
// This function reads the various memeber variables and loads them into
// into the dialog variables.
//
//
// Block all signals while setting these things
//
XAP_GtkSignalBlocker b1( G_OBJECT(m_oAlignList_adj), m_iAlignListSpinID);
XAP_GtkSignalBlocker b2( G_OBJECT(m_oIndentAlign_adj), m_iIndentAlignSpinID);
XAP_GtkSignalBlocker b3( G_OBJECT(m_wDecimalEntry), m_iDecimalEntryID);
XAP_GtkSignalBlocker b4( G_OBJECT(m_wDelimEntry), m_iDelimEntryID );
//
// HACK to effectively block an update during this method
//
m_bDontUpdate = true;
UT_DEBUGMSG(("loadXP newListType = %d \n",getNewListType()));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_wAlignListSpin),getfAlign());
float indent = getfAlign() + getfIndent();
gtk_spin_button_set_value(GTK_SPIN_BUTTON( m_wIndentAlignSpin),indent);
if( (getfIndent() + getfAlign()) < 0.0)
{
setfIndent( - getfAlign());
gtk_spin_button_set_value(GTK_SPIN_BUTTON( m_wIndentAlignSpin), 0.0);
}
//
// Code to work out which is active Font
//
if(getFont() == "NULL")
{
gtk_combo_box_set_active(m_wFontOptions, 0 );
}
else
{
size_t i = 0;
for(std::vector<std::string>::const_iterator iter = m_glFonts.begin();
iter != m_glFonts.end(); ++iter, ++i)
{
if(*iter == getFont())
break;
}
if(i < m_glFonts.size())
{
gtk_combo_box_set_active(m_wFontOptions, i + 1 );
}
else
{
gtk_combo_box_set_active(m_wFontOptions, 0 );
}
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_wStartSpin),static_cast<float>(getiStartValue()));
gtk_entry_set_text( GTK_ENTRY(m_wDecimalEntry), getDecimal().c_str());
gtk_entry_set_text( GTK_ENTRY(m_wDelimEntry), getDelim().c_str());
//
// Now set the list type and style
FL_ListType save = getNewListType();
if(getNewListType() == NOT_A_LIST)
{
styleChanged(0);
setNewListType(save);
gtk_combo_box_set_active(m_wListTypeBox, 0);
gtk_combo_box_set_active(m_wListStyleBox, 0);
}
else if(IS_BULLETED_LIST_TYPE(getNewListType()) )
{
styleChanged(1);
setNewListType(save);
gtk_combo_box_set_active(m_wListTypeBox, 1);
gtk_combo_box_set_active(m_wListStyleBox, (gint) (getNewListType() - BULLETED_LIST));
}
else
{
styleChanged(2);
setNewListType(save);
gtk_combo_box_set_active(m_wListTypeBox, 2);
if(getNewListType() < OTHER_NUMBERED_LISTS)
{
gtk_combo_box_set_active(m_wListStyleBox, getNewListType());
}
else
{
gint iMenu = static_cast<gint>(getNewListType()) - OTHER_NUMBERED_LISTS + BULLETED_LIST -1 ;
gtk_combo_box_set_active(m_wListStyleBox,iMenu);
}
}
//
// HACK to allow an update during this method
//
m_bDontUpdate = false;
}
static GtkWidget *create_editor_widgets(radio_conf_t * conf)
{
GtkWidget *table;
GtkWidget *label;
table = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_grid_set_column_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_row_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 5);
gtk_grid_set_row_spacing(GTK_GRID(table), 5);
/* Config name */
label = gtk_label_new(_("Name"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
name = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(name), 25);
g_signal_connect(name, "changed", G_CALLBACK(name_changed), NULL);
gtk_widget_set_tooltip_text(name,
_("Enter a short name for this configuration, "
"e.g. IC910-1.\n"
"Allowed characters: "
"0..9, a..z, A..Z, - and _"));
gtk_grid_attach(GTK_GRID(table), name, 1, 0, 3, 1);
/* Host */
label = gtk_label_new(_("Host"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);
host = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(host), 50);
gtk_entry_set_text(GTK_ENTRY(host), "localhost");
gtk_widget_set_tooltip_text(host,
_("Enter the host where rigctld is running. "
"You can use both host name and IP address, "
"e.g. 192.168.1.100\n\n"
"If gpredict and rigctld are running on the "
"same computer use localhost"));
gtk_grid_attach(GTK_GRID(table), host, 1, 1, 3, 1);
/* port */
label = gtk_label_new(_("Port"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);
port = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(port), 4532);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(port), 0);
gtk_widget_set_tooltip_text(port,
_("Enter the port number where rigctld is "
"listening"));
gtk_grid_attach(GTK_GRID(table), port, 1, 2, 1, 1);
/* radio type */
label = gtk_label_new(_("Radio type"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
//gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);
type = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("RX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("TX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Simplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Duplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (auto)"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (manual)"));
gtk_combo_box_set_active(GTK_COMBO_BOX(type), RIG_TYPE_RX);
g_signal_connect(type, "changed", G_CALLBACK(type_changed), NULL);
gtk_widget_set_tooltip_markup(type,
_("<b>RX only:</b> The radio shall only be "
"used as receiver. If <i>Monitor PTT "
"status</i> is checked the doppler tuning "
"will be suspended while PTT is ON "
"(manual TX). If not, the controller will "
"always perform doppler tuning and "
"you cannot use the same RIG for uplink.\n\n"
"<b>TX only:</b> The radio shall only be "
"used for uplink. If <i>Monitor PTT status</i>"
" is checked the doppler tuning will be "
"suspended while PTT is OFF (manual RX).\n\n"
"<b>Simplex TRX:</b> The radio should be "
"used for both up- and downlink but in "
"simplex mode only. This option requires "
"that the PTT status is monitored (otherwise "
"gpredict cannot know whether to tune the "
"RX or the TX).\n\n"
"<b>Duplex:</b> The radio is a full duplex "
"radio, such as the IC910H. Gpredict will "
"be continuously tuning both uplink and "
"downlink simultaneously and not care about "
"PTT setting.\n\n"
"<b>FT817/857/897 (auto):</b> "
"This is a special mode that can be used with "
"YAESU FT-817, 857 and 897 radios. These radios"
" do not allow computer control while in TX mode."
" Therefore, TX Doppler correction is applied "
"while the radio is in RX mode by toggling "
"between VFO A/B.\n\n"
"<b>FT817/857/897 (manual):</b> "
"This is similar to the previous mode except"
" that switching to TX is done by pressing the"
" SPACE key on the keyboard. Gpredict will "
"then update the TX Doppler before actually"
" switching to TX."));
gtk_grid_attach(GTK_GRID(table), type, 1, 3, 2, 1);
/* ptt */
label = gtk_label_new(_("PTT status"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);
ptt = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("None"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read PTT"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read DCD"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ptt), 0);
g_signal_connect(ptt, "changed", G_CALLBACK(ptt_changed), NULL);
gtk_widget_set_tooltip_markup(ptt,
_("Select PTT type.\n\n"
"<b>None:</b>\nDon't read PTT status from this radio.\n\n"
"<b>Read PTT:</b>\nRead PTT status using get_ptt CAT command. "
"You have to check that your radio and hamlib supports this.\n\n"
"<b>Read DCD:</b>\nRead PTT status using get_dcd command. "
"This can be used if your radio does not support the read_ptt "
"CAT command and you have a special interface that can "
"read squelch status and send it via CTS."));
gtk_grid_attach(GTK_GRID(table), ptt, 1, 4, 2, 1);
/* VFO Up/Down */
label = gtk_label_new(_("VFO Up/Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);
vfo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo), _("Not applicable"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("MAIN \342\206\221 / SUB \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("SUB \342\206\221 / MAIN \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("A \342\206\221 / B \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("B \342\206\221 / A \342\206\223"));
gtk_combo_box_set_active(GTK_COMBO_BOX(vfo), 0);
g_signal_connect(vfo, "changed", G_CALLBACK(vfo_changed), NULL);
gtk_widget_set_tooltip_markup(vfo,
_
("Select which VFO to use for uplink and downlink. "
"This setting is used for full-duplex radios only, "
"such as the IC-910H, FT-847 and the TS-2000.\n\n"
"<b>IC-910H:</b> MAIN\342\206\221 / SUB\342\206\223\n"
"<b>FT-847:</b> SUB\342\206\221 / MAIN\342\206\223\n"
"<b>TS-2000:</b> B\342\206\221 / A\342\206\223"));
gtk_grid_attach(GTK_GRID(table), vfo, 1, 5, 2, 1);
/* Downconverter LO frequency */
label = gtk_label_new(_("LO Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 6, 1, 1);
lo = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lo), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lo), 0);
gtk_widget_set_tooltip_text(lo,
_
("Enter the frequency of the local oscillator "
" of the downconverter, if any."));
gtk_grid_attach(GTK_GRID(table), lo, 1, 6, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 6, 1, 1);
/* Upconverter LO frequency */
label = gtk_label_new(_("LO Up"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 7, 1, 1);
loup = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(loup), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(loup), 0);
gtk_widget_set_tooltip_text(loup,
_
("Enter the frequency of the local oscillator "
"of the upconverter, if any."));
gtk_grid_attach(GTK_GRID(table), loup, 1, 7, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 7, 1, 1);
/* AOS / LOS signalling */
label = gtk_label_new(_("Signalling"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 8, 1, 1);
sigaos = gtk_check_button_new_with_label(_("AOS"));
gtk_grid_attach(GTK_GRID(table), sigaos, 1, 8, 1, 1);
gtk_widget_set_tooltip_text(sigaos,
_("Enable AOS signalling for this radio."));
siglos = gtk_check_button_new_with_label(_("LOS"));
gtk_grid_attach(GTK_GRID(table), siglos, 2, 8, 1, 1);
gtk_widget_set_tooltip_text(siglos,
_("Enable LOS signalling for this radio."));
if (conf->name != NULL)
update_widgets(conf);
gtk_widget_show_all(table);
return table;
}
/*
* update the controls widgets state
* args:
* none
*
* asserts:
* none
*
* returns: none
*/
void gui_gtk3_update_controls_state()
{
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (update controls state) empty control in list\n");
break;
}
control_widgets_t *cur_widget = gui_gtk3_get_widgets_by_id(current->control.id);
if(!cur_widget)
{
fprintf(stderr, "GUVCVIEW: (update widget state): control %x doesn't have a widget set\n", current->control.id);
continue;
}
/*update controls values*/
switch(current->control.type)
{
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
{
char *text_input = g_strescape(current->string, "");
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
case V4L2_CTRL_TYPE_BOOLEAN:
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_TOGGLE_BUTTON(cur_widget->widget),
G_CALLBACK (check_changed), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cur_widget->widget),
current->value ? TRUE : FALSE);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_TOGGLE_BUTTON(cur_widget->widget),
G_CALLBACK (check_changed), NULL);
break;
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
{
char *text_input = g_strdup_printf("0x%x", current->value);
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
{
char *text_input = g_strdup_printf("0x%" PRIx64 "", c->value64);
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
case V4L2_CTRL_TYPE_INTEGER:
if( current->control.id != V4L2_CID_PAN_RELATIVE &&
current->control.id != V4L2_CID_TILT_RELATIVE &&
current->control.id != V4L2_CID_PAN_RESET &&
current->control.id != V4L2_CID_TILT_RESET &&
current->control.id != V4L2_CID_LED1_MODE_LOGITECH &&
current->control.id != V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH )
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_SCALE (cur_widget->widget),
G_CALLBACK (slider_changed), NULL);
gtk_range_set_value (GTK_RANGE (cur_widget->widget), current->value);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_SCALE (cur_widget->widget),
G_CALLBACK (slider_changed), NULL);
if(cur_widget->widget2)
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_SPIN_BUTTON(cur_widget->widget2),
G_CALLBACK (spin_changed), NULL);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(cur_widget->widget2), current->value);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_SPIN_BUTTON(cur_widget->widget2),
G_CALLBACK (spin_changed), NULL);
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_COMBO_BOX_TEXT(cur_widget->widget),
G_CALLBACK (combo_changed), NULL);
/*get new index*/
int j = 0;
int def = 0;
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(cur_widget->widget), def);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_COMBO_BOX_TEXT(cur_widget->widget),
G_CALLBACK (combo_changed), NULL);
break;
}
default:
break;
}
/*update flags (enable disable)*/
if((current->control.flags & V4L2_CTRL_FLAG_GRABBED) ||
(current->control.flags & V4L2_CTRL_FLAG_DISABLED))
{
if(cur_widget->label)
gtk_widget_set_sensitive (cur_widget->label, FALSE);
if(cur_widget->widget)
gtk_widget_set_sensitive (cur_widget->widget, FALSE);
if(cur_widget->widget2)
gtk_widget_set_sensitive (cur_widget->widget2, FALSE);
}
else
{
if(cur_widget->label)
gtk_widget_set_sensitive (cur_widget->label, TRUE);
if(cur_widget->widget)
gtk_widget_set_sensitive (cur_widget->widget, TRUE);
if(cur_widget->widget2)
gtk_widget_set_sensitive (cur_widget->widget2, TRUE);
}
}
}
MidiogreApp *midiogre_app_init(void)
{
MidiogreApp *app;
GtkWidget *header;
GtkWidget *separator;
GtkWidget *scrolled;
GtkWidget *label,*frame;
GtkWidget *button;
GtkBox *box;
gint i;
GError *err;
/* Allocate app */
app = calloc(1, sizeof(MidiogreApp));
/* Setup window */
app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));
/* Setup header bar */
header = gtk_header_bar_new();
gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
gtk_window_set_titlebar(app->window, header);
/* Setup close button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);
/* Add seperator */
separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);
/* Setup folder button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);
/* Global horizontal box */
app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));
/* Scroll container for sidepanel */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);
/* Sidepanel box */
app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);
/* Frame with favorit info */
frame = gtk_frame_new("Favorite");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));
/* Current favorite */
app->fav_title_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_title_label, 20);
gtk_label_set_width_chars(app->fav_title_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
gtk_label_set_max_width_chars(app->fav_artist_label, 20);
gtk_label_set_width_chars(app->fav_artist_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
app->fav_album_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_album_label, 20);
gtk_label_set_width_chars(app->fav_album_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);
/* Frame with search criteria widgets */
frame = gtk_frame_new("Search");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));
/* Title entry */
frame = gtk_frame_new("Title");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);
/* Artist entry */
frame = gtk_frame_new("Artist");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->artist_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);
/* Album entry */
frame = gtk_frame_new("Album");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->album_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);
/* Instrument class buttons */
frame = gtk_frame_new("Instrument Classes");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
app->instr_grid = GTK_GRID(gtk_grid_new());
#if GTK_MINOR_VERSION >= 12
gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));
for (i = 0; i < INSTR_CLASSES; i++) {
label = gtk_label_new(instrument_classes[i]);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);
app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
}
/* Result spinbutton */
frame = gtk_frame_new("Max result");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
gtk_spin_button_set_value(app->result_spinbutton, 25);
gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);
/* Search button */
app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);
/* Songboxes notebook (Tabsview) */
app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);
/* Add song boxes */
app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match");
app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity");
app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest");
/* Show all widgets */
gtk_widget_show_all(GTK_WIDGET(app->window));
/* Allocate song queue */
app->songs[SONGBOX_ALPHA] = g_queue_new();
app->songs[SONGBOX_FPRNT] = g_queue_new();
app->songs[SONGBOX_BEST] = g_queue_new();
app->songs[SONGBOX_POP] = g_queue_new();
app->songs[SONGBOX_NEW] = g_queue_new();
return app;
}
static void
populate_widgets_from_alarm (Dialog *dialog)
{
ECalComponentAlarmTrigger *trigger;
ECalComponentAlarmAction *action;
action = g_new0 (ECalComponentAlarmAction, 1);
e_cal_component_alarm_get_action (dialog->alarm, action);
g_return_if_fail ( action != NULL );
trigger = g_new0 (ECalComponentAlarmTrigger, 1);
e_cal_component_alarm_get_trigger (dialog->alarm, trigger);
g_return_if_fail ( trigger != NULL );
if (*action == E_CAL_COMPONENT_ALARM_NONE)
return;
gtk_window_set_title (GTK_WINDOW (dialog->toplevel),_("Edit Reminder"));
/* Alarm Types */
switch (trigger->type) {
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START:
e_dialog_combo_box_set (dialog->time_combo, E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START, time_map);
break;
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_END:
e_dialog_combo_box_set (dialog->time_combo, E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_END, time_map);
break;
default:
g_warning ("%s: Unexpected alarm type (%d)", G_STRLOC, trigger->type);
}
switch (trigger->u.rel_duration.is_neg) {
case 1:
e_dialog_combo_box_set (dialog->relative_combo, BEFORE, relative_map);
break;
case 0:
e_dialog_combo_box_set (dialog->relative_combo, AFTER, relative_map);
break;
}
if (trigger->u.rel_duration.days) {
e_dialog_combo_box_set (dialog->value_units_combo, DAYS, value_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->interval_value),
trigger->u.rel_duration.days);
} else if (trigger->u.rel_duration.hours) {
e_dialog_combo_box_set (dialog->value_units_combo, HOURS, value_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->interval_value),
trigger->u.rel_duration.hours);
} else if (trigger->u.rel_duration.minutes) {
e_dialog_combo_box_set (dialog->value_units_combo, MINUTES, value_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->interval_value),
trigger->u.rel_duration.minutes);
} else {
e_dialog_combo_box_set (dialog->value_units_combo, MINUTES, value_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->interval_value), 0);
}
/* Repeat options */
alarm_to_repeat_widgets (dialog, dialog->alarm);
/* Alarm options */
e_dialog_combo_box_set (dialog->action_combo, *action, action_map);
action_changed_cb (dialog->action_combo, dialog);
switch (*action) {
case E_CAL_COMPONENT_ALARM_AUDIO:
alarm_to_aalarm_widgets (dialog, dialog->alarm);
break;
case E_CAL_COMPONENT_ALARM_DISPLAY:
alarm_to_dalarm_widgets (dialog, dialog->alarm);
break;
case E_CAL_COMPONENT_ALARM_EMAIL:
alarm_to_malarm_widgets (dialog, dialog->alarm);
break;
case E_CAL_COMPONENT_ALARM_PROCEDURE:
alarm_to_palarm_widgets (dialog, dialog->alarm);
break;
default:
g_warning ("%s: Unexpected alarm action (%d)", G_STRLOC, *action);
}
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
GtkWidget *main_box, *central_box, *advance_box, *res_box, *hw_box, *sw_box, *shader_box;
GtkWidget *native_box, *fsaa_box, *resxy_box, *renderer_box, *interlace_box, *threads_box, *filter_box;
GtkWidget *hw_table, *shader_table, *res_frame, *hw_frame, *sw_frame, *shader_frame;
GtkWidget *interlace_combo_box, *threads_spin;
GtkWidget *interlace_label, *threads_label, *native_label, *fsaa_label, *rexy_label, *render_label, *filter_label;
GtkWidget *hack_table, *hack_skipdraw_label, *hack_box, *hack_frame;
GtkWidget *hack_alpha_check, *hack_date_check, *hack_offset_check, *hack_skipdraw_spin, *hack_msaa_check, *hack_sprite_check, * hack_wild_check, *hack_enble_check, *hack_logz_check;
GtkWidget *hack_tco_label, *hack_tco_entry;
GtkWidget *gl_box, *gl_frame, *gl_table;
GtkWidget *notebook, *page_label[2];
int return_value;
GdkPixbuf* logo_pixmap;
GtkWidget *logo_image;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
// The main area for the whole dialog box.
main_box = gtk_vbox_new(false, 5);
central_box = gtk_vbox_new(false, 5);
advance_box = gtk_vbox_new(false, 5);
// The Internal resolution frame and container.
res_box = gtk_vbox_new(false, 5);
res_frame = gtk_frame_new ("OpenGL Internal Resolution (can cause glitches)");
gtk_container_add(GTK_CONTAINER(res_frame), res_box);
// The extra shader setting frame/container/table
shader_box = gtk_vbox_new(false, 5);
shader_frame = gtk_frame_new("Custom Shader Settings");
gtk_container_add(GTK_CONTAINER(shader_frame), shader_box);
shader_table = gtk_table_new(5,2, false);
gtk_container_add(GTK_CONTAINER(shader_box), shader_table);
// The hardware mode frame, container, and table.
hw_box = gtk_vbox_new(false, 5);
hw_frame = gtk_frame_new ("Hardware Mode Settings");
gtk_container_add(GTK_CONTAINER(hw_frame), hw_box);
hw_table = gtk_table_new(5,2, false);
gtk_container_add(GTK_CONTAINER(hw_box), hw_table);
// The software mode frame and container. (It doesn't have enough in it for a table.)
sw_box = gtk_vbox_new(false, 5);
sw_frame = gtk_frame_new ("Software Mode Settings");
gtk_container_add(GTK_CONTAINER(sw_frame), sw_box);
// The hack frame and container.
hack_box = gtk_hbox_new(false, 5);
hack_frame = gtk_frame_new ("Hacks");
gtk_container_add(GTK_CONTAINER(hack_frame), hack_box);
hack_table = gtk_table_new(3,3, false);
gtk_container_add(GTK_CONTAINER(hack_box), hack_table);
// Grab a logo, to make things look nice.
logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
// Create the renderer combo box and label, and stash them in a box.
render_label = gtk_label_new ("Renderer:");
render_combo_box = CreateRenderComboBox();
renderer_box = gtk_hbox_new(false, 5);
// Use gtk_box_pack_start instead of gtk_container_add so it lines up nicely.
gtk_box_pack_start(GTK_BOX(renderer_box), render_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(renderer_box), render_combo_box, false, false, 5);
// Create the interlace combo box and label, and stash them in a box.
interlace_label = gtk_label_new ("Interlacing (F5):");
interlace_combo_box = CreateInterlaceComboBox();
interlace_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_combo_box, false, false, 5);
// Create the filter combo box.
filter_label = gtk_label_new ("Texture Filtering:");
filter_combo_box = CreateFilterComboBox();
filter_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_combo_box, false, false, 0);
// Create the threading spin box and label, and stash them in a box. (Yes, we do a lot of that.)
threads_label = gtk_label_new("Extra rendering threads:");
threads_spin = gtk_spin_button_new_with_range(0,100,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(threads_spin), theApp.GetConfig("extrathreads", 0));
threads_box = gtk_hbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(threads_box), threads_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(threads_box), threads_spin, false, false, 5);
// A bit of funkiness for the resolution box.
native_label = gtk_label_new("Original PS2 Resolution: ");
native_res_check = gtk_check_button_new_with_label("Native");
native_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_res_check, false, false, 5);
fsaa_label = gtk_label_new("Or Use Scaling:");
fsaa_combo_box = CreateMsaaComboBox();
fsaa_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_combo_box, false, false, 5);
rexy_label = gtk_label_new("Custom Resolution:");
resx_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resx_spin), theApp.GetConfig("resx", 1024));
resy_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resy_spin), theApp.GetConfig("resy", 1024));
resxy_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), rexy_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resx_spin, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resy_spin, false, false, 5);
// Create our hack settings.
hack_alpha_check = gtk_check_button_new_with_label("Alpha Hack");
hack_date_check = gtk_check_button_new_with_label("Date Hack");
hack_offset_check = gtk_check_button_new_with_label("Offset Hack");
hack_skipdraw_label = gtk_label_new("Skipdraw:");
hack_skipdraw_spin = gtk_spin_button_new_with_range(0,1000,1);
hack_enble_check = gtk_check_button_new_with_label("Enable User Hacks");
hack_wild_check = gtk_check_button_new_with_label("Wild arm Hack");
hack_sprite_check = gtk_check_button_new_with_label("Sprite Hack");
hack_msaa_check = gtk_check_button_new_with_label("Msaa Hack");
hack_tco_label = gtk_label_new("Texture Offset: 0x");
hack_tco_entry = gtk_entry_new();
hack_logz_check = gtk_check_button_new_with_label("Log Depth Hack");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(hack_skipdraw_spin), theApp.GetConfig("UserHacks_SkipDraw", 0));
set_hex_entry(hack_tco_entry, theApp.GetConfig("UserHacks_TCOffset", 0));
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_alpha_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_offset_check, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_sprite_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_wild_check, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_logz_check, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_date_check, 1, 2, 2, 3);
// Note: MSAA is not implemented yet. I disable it to make the table square
//gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_msaa_check, 2, 3, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_spin, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_entry, 1, 2, 4, 5);
// Create our checkboxes.
shadeboost_check = gtk_check_button_new_with_label("Shade boost");
paltex_check = gtk_check_button_new_with_label("Allow 8 bits textures");
fba_check = gtk_check_button_new_with_label("Alpha correction (FBA)");
aa_check = gtk_check_button_new_with_label("Edge anti-aliasing (AA1)");
fxaa_check = gtk_check_button_new_with_label("Fxaa shader");
// Set the checkboxes.
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shadeboost_check), theApp.GetConfig("shadeboost", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(paltex_check), theApp.GetConfig("paltex", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fba_check), theApp.GetConfig("fba", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(aa_check), theApp.GetConfig("aa1", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxaa_check), theApp.GetConfig("fxaa", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(native_res_check), theApp.GetConfig("nativeres", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_alpha_check), theApp.GetConfig("UserHacks_AlphaHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_offset_check), theApp.GetConfig("UserHacks_HalfPixelOffset", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_date_check), theApp.GetConfig("UserHacks_DateGL4", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_enble_check), theApp.GetConfig("UserHacks", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_msaa_check), theApp.GetConfig("UserHacks_MSAA", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_wild_check), theApp.GetConfig("UserHacks_WildHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_sprite_check), theApp.GetConfig("UserHacks_SpriteHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_logz_check), theApp.GetConfig("logz", 1));
// Shadeboost scale
sb_brightness = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_brightness_label = gtk_label_new("Shade Boost Brightness");
gtk_scale_set_value_pos(GTK_SCALE(sb_brightness), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_brightness), theApp.GetConfig("ShadeBoost_Brightness", 50));
sb_contrast = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_contrast_label = gtk_label_new("Shade Boost Contrast");
gtk_scale_set_value_pos(GTK_SCALE(sb_contrast), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_contrast), theApp.GetConfig("ShadeBoost_Contrast", 50));
sb_saturation = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_saturation_label = gtk_label_new("Shade Boost Saturation");
gtk_scale_set_value_pos(GTK_SCALE(sb_saturation), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_saturation), theApp.GetConfig("ShadeBoost_Saturation", 50));
// Populate all those boxes we created earlier with widgets.
gtk_container_add(GTK_CONTAINER(res_box), native_box);
gtk_container_add(GTK_CONTAINER(res_box), fsaa_box);
gtk_container_add(GTK_CONTAINER(res_box), resxy_box);
gtk_container_add(GTK_CONTAINER(sw_box), threads_box);
gtk_container_add(GTK_CONTAINER(sw_box), aa_check);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(shader_table), fxaa_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shadeboost_check, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness_label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation, 1, 2, 3, 4);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hw_table), filter_box, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hw_table), paltex_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hw_table), fba_check, 1, 2, 1, 2);
// The GL advance options
gl_box = gtk_vbox_new(false, 5);
gl_frame = gtk_frame_new ("OpenGL Very Advanced Custom Settings");
gtk_container_add(GTK_CONTAINER(gl_frame), gl_box);
gl_table = gtk_table_new(10, 2, false);
gtk_container_add(GTK_CONTAINER(gl_box), gl_table);
GtkWidget* gl_bs_label = gtk_label_new("Buffer Storage:");
GtkWidget* gl_bs_combo = CreateGlComboBox("override_GL_ARB_buffer_storage");
GtkWidget* gl_bt_label = gtk_label_new("Bindless Texture:");
GtkWidget* gl_bt_combo = CreateGlComboBox("override_GL_ARB_bindless_texture");
GtkWidget* gl_sso_label = gtk_label_new("Separate Shader:");
GtkWidget* gl_sso_combo = CreateGlComboBox("override_GL_ARB_separate_shader_objects");
GtkWidget* gl_ss_label = gtk_label_new("Shader Subroutine:");
GtkWidget* gl_ss_combo = CreateGlComboBox("override_GL_ARB_shader_subroutine");
GtkWidget* gl_gs_label = gtk_label_new("Geometry Shader:");
GtkWidget* gl_gs_combo = CreateGlComboBox("override_geometry_shader");
GtkWidget* gl_ils_label = gtk_label_new("Image Load Store:");
GtkWidget* gl_ils_combo = CreateGlComboBox("override_GL_ARB_shader_image_load_store");
GtkWidget* gl_cc_label = gtk_label_new("Clip Control (depth accuracy):");
GtkWidget* gl_cc_combo = CreateGlComboBox("override_GL_ARB_clip_control");
GtkWidget* gl_ct_label = gtk_label_new("Clear Texture:");
GtkWidget* gl_ct_combo = CreateGlComboBox("override_GL_ARB_clear_texture");
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_combo, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_combo, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_combo, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_combo, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_combo, 1, 2, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_label, 0, 1, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_combo, 1, 2, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_label, 0, 1, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_combo, 1, 2, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_label, 0, 1, 7, 8);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_combo, 1, 2, 7, 8);
// those one are properly detected so no need a gui
#if 0
override_GL_ARB_copy_image = -1
override_GL_ARB_explicit_uniform_location = -1
override_GL_ARB_gpu_shader5 = -1
override_GL_ARB_shading_language_420pack = -1
#endif
// Handle some nice tab
notebook = gtk_notebook_new();
page_label[0] = gtk_label_new("Global Setting");
page_label[1] = gtk_label_new("Advance Setting");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box, page_label[0]);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advance_box, page_label[1]);
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), renderer_box);
gtk_container_add(GTK_CONTAINER(main_box), interlace_box);
gtk_container_add(GTK_CONTAINER(main_box), notebook);
gtk_container_add(GTK_CONTAINER(central_box), res_frame);
gtk_container_add(GTK_CONTAINER(central_box), shader_frame);
gtk_container_add(GTK_CONTAINER(central_box), hw_frame);
gtk_container_add(GTK_CONTAINER(central_box), sw_frame);
gtk_container_add(GTK_CONTAINER(advance_box), hack_frame);
gtk_container_add(GTK_CONTAINER(advance_box), gl_frame);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value == GTK_RESPONSE_ACCEPT)
{
int mode_height = 0, mode_width = 0;
mode_width = theApp.GetConfig("ModeWidth", 640);
mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
// Get all the settings from the dialog box.
if (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box)) != -1) {
// Note the value are based on m_gs_renderers vector on GSdx.cpp
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box))) {
case 2: theApp.SetConfig("renderer", 10); break;
case 3: theApp.SetConfig("renderer", 11); break;
case 4: theApp.SetConfig("renderer", 12); break;
case 5: theApp.SetConfig("renderer", 13); break;
// Fallback to SW opengl
default: theApp.SetConfig("renderer", 13); break;
}
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)) != -1)
theApp.SetConfig( "interlace", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)));
theApp.SetConfig("extrathreads", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(threads_spin)));
theApp.SetConfig("filter", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(filter_combo_box)));
theApp.SetConfig("shadeboost", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shadeboost_check)));
theApp.SetConfig("paltex", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(paltex_check)));
theApp.SetConfig("fba", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fba_check)));
theApp.SetConfig("aa1", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(aa_check)));
theApp.SetConfig("fxaa", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fxaa_check)));
theApp.SetConfig("nativeres", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(native_res_check)));
theApp.SetConfig("ShadeBoost_Saturation", (int)gtk_range_get_value(GTK_RANGE(sb_saturation)));
theApp.SetConfig("ShadeBoost_Brightness", (int)gtk_range_get_value(GTK_RANGE(sb_brightness)));
theApp.SetConfig("ShadeBoost_Contrast", (int)gtk_range_get_value(GTK_RANGE(sb_contrast)));
theApp.SetConfig("upscale_multiplier", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(fsaa_combo_box))+1);
theApp.SetConfig("resx", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resx_spin)));
theApp.SetConfig("resy", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resy_spin)));
theApp.SetConfig("UserHacks_SkipDraw", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(hack_skipdraw_spin)));
theApp.SetConfig("UserHacks_HalfPixelOffset", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_offset_check)));
theApp.SetConfig("UserHacks_AlphaHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_alpha_check)));
theApp.SetConfig("logz", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_logz_check)));
theApp.SetConfig("UserHacks_DateGL4", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_date_check)));
theApp.SetConfig("UserHacks_MSAA", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_msaa_check)));
theApp.SetConfig("UserHacks_WildHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_wild_check)));
theApp.SetConfig("UserHacks_SpriteHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_sprite_check)));
theApp.SetConfig("UserHacks", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_enble_check)));
theApp.SetConfig("UserHacks_TCOffset", get_hex_entry(hack_tco_entry));
theApp.SetConfig("override_GL_ARB_clear_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ct_combo)) - 1);
theApp.SetConfig("override_GL_ARB_bindless_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bt_combo)) - 1);
theApp.SetConfig("override_GL_ARB_buffer_storage", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_separate_shader_objects", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_sso_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_subroutine", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ss_combo)) - 1);
theApp.SetConfig("override_geometry_shader", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_gs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_image_load_store", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ils_combo)) - 1);
theApp.SetConfig("override_GL_ARB_clip_control", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_cc_combo)) - 1);
// NOT supported yet
theApp.SetConfig("msaa", 0);
// Let's just be windowed for the moment.
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return true;
}
gtk_widget_destroy (dialog);
return false;
}
static void
populate_ui (CEPageBond *self)
{
CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);
NMSettingBond *setting = priv->setting;
const char *mode, *primary, *frequency, *updelay, *downdelay, *raw_targets;
char *targets;
int mode_idx = MODE_BALANCE_RR;
guint32 mtu_def, mtu_val;
/* Mode */
mode = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_MODE);
if (mode) {
if (!strcmp (mode, "balance-rr"))
mode_idx = MODE_BALANCE_RR;
else if (!strcmp (mode, "active-backup"))
mode_idx = MODE_ACTIVE_BACKUP;
else if (!strcmp (mode, "balance-xor"))
mode_idx = MODE_BALANCE_XOR;
else if (!strcmp (mode, "broadcast"))
mode_idx = MODE_BROADCAST;
else if (!strcmp (mode, "802.3ad"))
mode_idx = MODE_802_3AD;
else if (!strcmp (mode, "balance-tlb"))
mode_idx = MODE_BALANCE_TLB;
else if (!strcmp (mode, "balance-alb"))
mode_idx = MODE_BALANCE_ALB;
}
gtk_combo_box_set_active (priv->mode, mode_idx);
g_signal_connect (priv->mode, "changed",
G_CALLBACK (bonding_mode_changed),
self);
bonding_mode_changed (priv->mode, self);
/* Primary */
primary = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_PRIMARY);
gtk_entry_set_text (priv->primary, primary ? primary : "");
/* Monitoring mode/frequency */
frequency = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL);
if (frequency) {
gtk_combo_box_set_active (priv->monitoring, MONITORING_ARP);
} else {
gtk_combo_box_set_active (priv->monitoring, MONITORING_MII);
frequency = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_MIIMON);
}
g_signal_connect (priv->monitoring, "changed",
G_CALLBACK (monitoring_mode_changed),
self);
monitoring_mode_changed (priv->monitoring, self);
if (frequency)
gtk_spin_button_set_value (priv->frequency, (gdouble) atoi (frequency));
else
gtk_spin_button_set_value (priv->frequency, 0.0);
g_signal_connect (priv->frequency, "value-changed",
G_CALLBACK (frequency_changed),
self);
updelay = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_UPDELAY);
if (updelay)
gtk_spin_button_set_value (priv->updelay, (gdouble) atoi (updelay));
else
gtk_spin_button_set_value (priv->updelay, 0.0);
g_signal_connect (priv->updelay, "value-changed",
G_CALLBACK (delay_changed),
self);
downdelay = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_DOWNDELAY);
if (downdelay)
gtk_spin_button_set_value (priv->downdelay, (gdouble) atoi (downdelay));
else
gtk_spin_button_set_value (priv->downdelay, 0.0);
g_signal_connect (priv->downdelay, "value-changed",
G_CALLBACK (delay_changed),
self);
/* ARP targets */
raw_targets = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
targets = prettify_targets (raw_targets);
if (targets) {
gtk_entry_set_text (priv->arp_targets, targets);
g_free (targets);
}
/* MTU */
if (priv->wired) {
mtu_def = ce_get_property_default (NM_SETTING (priv->wired), NM_SETTING_WIRED_MTU);
mtu_val = nm_setting_wired_get_mtu (priv->wired);
} else {
mtu_def = mtu_val = 0;
}
g_signal_connect (priv->mtu, "output",
G_CALLBACK (ce_spin_output_with_automatic),
GINT_TO_POINTER (mtu_def));
gtk_spin_button_set_value (priv->mtu, (gdouble) mtu_val);
}
/*! \brief Creates the arc angle dialog
* \par Function Description
* This function creates the arc angle dialog. Depending on the
* \a arc_object the entries are filled with the arc OBJECT properties
* or with some standard values.
*
* \param [in] w_current The GschemToplevel object
* \param [in] arc_object an arc OBJECT if used to modify an arc
* or NULL to create a new arc.
*/
void arc_angle_dialog (GschemToplevel *w_current, OBJECT *arc_object)
{
GtkWidget *label[3];
GtkWidget *vbox;
GtkWidget *alignment, *table;
GtkWidget *widget[3];
if (!w_current->aawindow) {
w_current->aawindow = gschem_dialog_new_with_buttons(_("Arc Params"),
GTK_WINDOW(w_current->main_window),
GTK_DIALOG_MODAL,
"arc-angle", w_current,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
/* Set the alternative button order (ok, cancel, help) for other systems */
gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->aawindow),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_REJECT,
-1);
gtk_window_set_position (GTK_WINDOW (w_current->aawindow), GTK_WIN_POS_MOUSE);
g_signal_connect (G_OBJECT (w_current->aawindow), "response",
G_CALLBACK (arc_angle_dialog_response),
w_current);
gtk_dialog_set_default_response(GTK_DIALOG(w_current->aawindow),
GTK_RESPONSE_ACCEPT);
gtk_container_set_border_width (GTK_CONTAINER (w_current->aawindow),
DIALOG_BORDER_SPACING);
vbox = GTK_DIALOG(w_current->aawindow)->vbox;
gtk_box_set_spacing(GTK_BOX(vbox), DIALOG_V_SPACING);
alignment = gtk_alignment_new(0,0,1,1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0,
0 /*DIALOG_INDENTATION */, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0);
label[0] = gschem_dialog_misc_create_property_label (_("Arc Radius:"));
label[1] = gschem_dialog_misc_create_property_label (_("Start Angle:"));
label[2] = gschem_dialog_misc_create_property_label (_("Degrees of Sweep:"));
widget[0] = gtk_spin_button_new_with_range (1, 100000, 100);
gtk_entry_set_activates_default (GTK_ENTRY(widget[0]), TRUE);
widget[1] = gtk_spin_button_new_with_range (-360,360,1);
gtk_entry_set_activates_default (GTK_ENTRY(widget[1]), TRUE);
widget[2] = gtk_spin_button_new_with_range (-360,360,1);
gtk_entry_set_activates_default(GTK_ENTRY(widget[2]), TRUE);
table = gschem_dialog_misc_create_property_table (label, widget, 3);
gtk_container_add (GTK_CONTAINER(alignment), table);
GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[0], "radius");
GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[1],"spin_start");
GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[2],"spin_sweep");
g_object_set_data(G_OBJECT(w_current->aawindow), "arc_object", arc_object);
gtk_widget_show_all (w_current->aawindow);
}
else { /* dialog already created */
gtk_window_present (GTK_WINDOW(w_current->aawindow));
widget[0] = g_object_get_data(G_OBJECT(w_current->aawindow),"radius");
widget[1] = g_object_get_data(G_OBJECT(w_current->aawindow),"spin_start");
widget[2] = g_object_get_data(G_OBJECT(w_current->aawindow),"spin_sweep");
}
if (arc_object == NULL) {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]), w_current->distance);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]),0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]), 90);
} else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]),
arc_object->arc->radius);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]),
arc_object->arc->start_angle);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]),
arc_object->arc->sweep_angle);
}
gtk_widget_grab_focus(widget[0]);
}
