static void
update_switches_visibility (NmnApplet *applet)
{
NmnAppletPrivate *priv = GET_PRIVATE (applet);
GtkTable *table;
gboolean visible;
int ethernet;
int wifi;
int modem;
int wimax;
int bt;
ethernet = wifi = modem = wimax = bt = 0;
if (!nmn_model_offline_mode_get_active (priv->model)) {
const GPtrArray *devices;
int i;
devices = nm_client_get_devices (nmn_model_get_client (priv->model));
for (i = 0; devices && i < devices->len; i++) {
NMDevice *device = NM_DEVICE (g_ptr_array_index (devices, i));
if (NM_IS_DEVICE_ETHERNET (device))
ethernet++;
else if (NM_IS_DEVICE_WIFI (device))
wifi++;
else if (NM_IS_SERIAL_DEVICE (device))
modem++;
else if (NM_IS_DEVICE_BT (device))
bt++;
}
}
table = GTK_TABLE (priv->switches_table);
visible = wifi > 0;
gtk_table_set_row_spacing (table, SWITCHES_ROW_WIFI, visible ? 6 : 0);
g_object_set (priv->enable_wifi_label, "visible", visible, NULL);
g_object_set (priv->enable_wifi, "visible", visible, NULL);
visible = ethernet > 0;
gtk_table_set_row_spacing (table, SWITCHES_ROW_ETHERNET, visible ? 6 : 0);
g_object_set (priv->enable_ethernet_label, "visible", visible, NULL);
g_object_set (priv->enable_ethernet, "visible", visible, NULL);
visible = modem > 0;
gtk_table_set_row_spacing (table, SWITCHES_ROW_3G, visible ? 6 : 0);
g_object_set (priv->enable_3g_label, "visible", visible, NULL);
g_object_set (priv->enable_3g, "visible", visible, NULL);
visible = wimax > 0;
gtk_table_set_row_spacing (table, SWITCHES_ROW_WIMAX, visible ? 6 : 0);
g_object_set (priv->enable_wimax_label, "visible", visible, NULL);
g_object_set (priv->enable_wimax, "visible", visible, NULL);
visible = bt > 0;
gtk_table_set_row_spacing (table, SWITCHES_ROW_BT, visible ? 6 : 0);
g_object_set (priv->enable_bt_label, "visible", visible, NULL);
g_object_set (priv->enable_bt, "visible", visible, NULL);
}
static void arch_notebook_page (GtkWidget *notebook,
enum server_type type, struct arch_stats *arch) {
GtkWidget *table;
int i, j;
int cpu_total;
table = gtk_table_new (CPU_NUM + 2, OS_NUM + 3, FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, NULL);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 20);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_col_spacing (GTK_TABLE (table), OS_NUM, 20);
gtk_table_set_row_spacing (GTK_TABLE (table), CPU_NUM, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), CPU_NUM+1, 12);
put_label_to_table (table, _("CPU \\ OS"), 0.5, 0, 0);
for (i = 0; i < OS_NUM; i++) {
put_label_to_table (table, _(os_names[i]), 1.0, i + 1, 0);
}
put_label_to_table (table, _("Total"), 1.0, OS_NUM + 1, 0);
for (i = 0; i < CPU_NUM; i++) {
put_label_to_table (table, _(cpu_names[i]), 0.0, 0, i + 1);
}
put_label_to_table (table, _("Total"), 0.0, 0, CPU_NUM + 1);
put_label_to_table (table, _("Players"), 0.0, 0, CPU_NUM + 2);
for (j = 0; j < CPU_NUM; j++) {
cpu_total = 0;
for (i = 0; i < OS_NUM; i++) {
put_arch_stats (table, arch->oscpu[i][j], arch->count, i + 1, j + 1);
cpu_total += arch->oscpu[i][j];
if (j > 0)
arch->oscpu[i][0] += arch->oscpu[i][j];
}
put_arch_stats (table, cpu_total, arch->count, OS_NUM + 1, j + 1);
}
for (i = 0; i < OS_NUM; i++) {
put_arch_stats (table, arch->oscpu[i][0], arch->count, i + 1, CPU_NUM + 1);
put_arch_stats (table, players[type].on_os[i],
players[type].total, i + 1, CPU_NUM + 2);
}
put_arch_stats (table, arch->count, arch->count, OS_NUM + 1, CPU_NUM + 1);
put_arch_stats (table, srv_stats[type].players, players_count, OS_NUM + 1, CPU_NUM + 2);
gtk_widget_show (table);
}
static int _grid_table_by_list(button_processor_t *button_processor,
List node_list)
{
sview_node_info_t *sview_node_info_ptr = NULL;
int inx = 0, rc = SLURM_SUCCESS;
ListIterator itr = list_iterator_create(node_list);
button_processor->inx = &inx;
while ((sview_node_info_ptr = list_next(itr))) {
/* if (!working_sview_config.show_hidden) { */
/* if (!check_part_includes_node(inx)) { */
/* inx++; */
/* continue; */
/* } */
/* } */
if ((rc = _add_button_to_list(
sview_node_info_ptr->node_ptr,
button_processor)) != SLURM_SUCCESS)
break;
inx++;
}
list_iterator_destroy(itr);
rc = _add_button_to_list(NULL, button_processor);
/* This is needed to get the correct width of the grid window.
* If it is not given then we get a really narrow window. */
gtk_table_set_row_spacing(button_processor->table,
(*button_processor->coord_y)?
((*button_processor->coord_y)-1):0, 1);
return rc;
}
static gboolean
xydenoise_dialog(XYdenoiseArgs *args)
{
GtkWidget *dialog, *table, *chooser;
gint row, response;
gboolean ok = FALSE;
dialog = gtk_dialog_new_with_buttons(_("XY Denoising"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
table = gtk_table_new(9, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
row = 0;
/* Correlate with */
chooser = gwy_data_chooser_new_channels();
g_object_set_data(G_OBJECT(chooser), "dialog", dialog);
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser),
xydenoise_data_filter, &args->op1, NULL);
g_signal_connect(chooser, "changed",
G_CALLBACK(xydenoise_data_cb), &args->op2);
xydenoise_data_cb(GWY_DATA_CHOOSER(chooser), &args->op2);
gwy_table_attach_hscale(table, row, _("Second direction:"), NULL,
GTK_OBJECT(chooser), GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_NONE:
gtk_widget_destroy(dialog);
return FALSE;
break;
case GTK_RESPONSE_OK:
ok = TRUE;
break;
default:
g_assert_not_reached();
break;
}
} while (!ok);
gtk_widget_destroy(dialog);
return TRUE;
}
static void
gimp_rotate_tool_dialog (GimpTransformTool *tr_tool)
{
GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool);
GtkWidget *table;
GtkWidget *button;
GtkWidget *scale;
GtkAdjustment *adj;
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
rotate->angle_adj = (GtkAdjustment *)
gtk_adjustment_new (0, -180, 180, 0.1, 15, 0);
button = gtk_spin_button_new (rotate->angle_adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Angle:"),
0.0, 0.5, button, 1, TRUE);
rotate->angle_spin_button = button;
g_signal_connect (rotate->angle_adj, "value-changed",
G_CALLBACK (rotate_angle_changed),
tr_tool);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, rotate->angle_adj);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (scale);
adj = (GtkAdjustment *) gtk_adjustment_new (0, -1, 1, 1, 10, 0);
button = gtk_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Center _X:"),
0.0, 0.5, button, 1, TRUE);
rotate->sizeentry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, TRUE, FALSE, SB_WIDTH,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (rotate->sizeentry),
GTK_SPIN_BUTTON (button), NULL);
gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (rotate->sizeentry), 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Center _Y:"),
0.0, 0.5, rotate->sizeentry, 1, TRUE);
g_signal_connect (rotate->sizeentry, "value-changed",
G_CALLBACK (rotate_center_changed),
tr_tool);
}
static void
monitoring_mode_changed (GtkComboBox *combo, gpointer user_data)
{
CEPageBond *self = user_data;
CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);
if (gtk_combo_box_get_active (combo) == MONITORING_MII) {
gtk_widget_show (GTK_WIDGET (priv->updelay));
gtk_widget_show (priv->updelay_label);
gtk_widget_show (priv->updelay_box);
gtk_widget_show (GTK_WIDGET (priv->downdelay));
gtk_widget_show (priv->downdelay_label);
gtk_widget_show (priv->downdelay_box);
gtk_widget_hide (GTK_WIDGET (priv->arp_targets));
gtk_widget_hide (priv->arp_targets_label);
gtk_table_set_row_spacing (priv->table, priv->updelay_row, priv->table_row_spacing);
gtk_table_set_row_spacing (priv->table, priv->downdelay_row, priv->table_row_spacing);
gtk_table_set_row_spacing (priv->table, priv->arp_targets_row, 0);
} else {
gtk_widget_hide (GTK_WIDGET (priv->updelay));
gtk_widget_hide (priv->updelay_label);
gtk_widget_hide (priv->updelay_box);
gtk_widget_hide (GTK_WIDGET (priv->downdelay));
gtk_widget_hide (priv->downdelay_label);
gtk_widget_hide (priv->downdelay_box);
gtk_widget_show (GTK_WIDGET (priv->arp_targets));
gtk_widget_show (priv->arp_targets_label);
gtk_table_set_row_spacing (priv->table, priv->updelay_row, 0);
gtk_table_set_row_spacing (priv->table, priv->downdelay_row, 0);
gtk_table_set_row_spacing (priv->table, priv->arp_targets_row, priv->table_row_spacing);
}
}
/* changes the space between a given table row and its surrounding rows. */
int
clip_GTK_TABLESETROWSPACING(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
guint row = INT_OPTION(cm,2,1);
guint spacing = _clip_parni(cm,3);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
gtk_table_set_row_spacing(GTK_TABLE(ctbl->widget), row-1, spacing);
return 0;
err:
return 1;
}
static void
gimp_sample_point_editor_init (GimpSamplePointEditor *editor)
{
gint content_spacing;
gint i;
gint row = 0;
gint column = 0;
editor->sample_merged = TRUE;
gtk_widget_style_get (GTK_WIDGET (editor),
"content-spacing", &content_spacing,
NULL);
editor->table = gtk_table_new (2, 2, TRUE);
gtk_table_set_row_spacing (GTK_TABLE (editor->table), 0, content_spacing);
gtk_table_set_col_spacing (GTK_TABLE (editor->table), 0, content_spacing);
gtk_box_pack_start (GTK_BOX (editor), editor->table, FALSE, FALSE, 0);
gtk_widget_show (editor->table);
for (i = 0; i < 4; i++)
{
GtkWidget *frame;
frame = g_object_new (GIMP_TYPE_COLOR_FRAME,
"mode", GIMP_COLOR_FRAME_MODE_PIXEL,
"has-number", TRUE,
"number", i + 1,
"has-color-area", TRUE,
"sensitive", FALSE,
NULL);
gtk_table_attach (GTK_TABLE (editor->table), frame,
column, column + 1, row, row + 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (frame);
editor->color_frames[i] = frame;
column++;
if (column > 1)
{
column = 0;
row++;
}
}
}
static void
gimp_sample_point_editor_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpSamplePointEditor *editor = GIMP_SAMPLE_POINT_EDITOR (widget);
gint content_spacing;
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget,
"content-spacing", &content_spacing,
NULL);
gtk_table_set_row_spacing (GTK_TABLE (editor->table), 0, content_spacing);
gtk_table_set_col_spacing (GTK_TABLE (editor->table), 0, content_spacing);
}
extern int update_grid_table(GtkTable *table, List button_list, List node_list)
{
int rc = SLURM_SUCCESS;
int coord_x=0, coord_y=0, inx=0;
ListIterator itr = NULL, itr2 = NULL;
sview_node_info_t *sview_node_info_ptr = NULL;
button_processor_t button_processor;
if (!node_list) {
g_print("update_grid_table: no node_list given\n");
return SLURM_ERROR;
}
if (_init_button_processor(&button_processor, list_count(node_list))
!= SLURM_SUCCESS)
return SLURM_ERROR;
button_processor.table = table;
button_processor.button_list = button_list;
button_processor.coord_x = &coord_x;
button_processor.coord_y = &coord_y;
button_processor.inx = &inx;
gtk_table_resize(table, button_processor.table_y,
working_sview_config.grid_x_width);
gtk_table_set_row_spacings(table, 0);
gtk_table_set_col_spacings(table, 0);
itr = list_iterator_create(node_list);
itr2 = list_iterator_create(button_list);
while ((sview_node_info_ptr = list_next(itr))) {
int found = 0;
/* if (!working_sview_config.show_hidden */
/* && !check_part_includes_node(inx)) { */
/* inx++; */
/* continue; */
/* } */
// again:
while ((button_processor.grid_button = list_next(itr2))) {
if (button_processor.grid_button->inx != inx) {
continue;
}
found = 1;
if ((rc = _add_button_to_list(
sview_node_info_ptr->node_ptr,
&button_processor)) != SLURM_SUCCESS)
goto end_it;
break;
}
if (!found) {
//list_iterator_reset(itr2);
//goto again;
return RESET_GRID;
}
inx++;
}
rc = _add_button_to_list(NULL, &button_processor);
/* This is needed to get the correct width of the grid window.
* If it is not given then we get a really narrow window. */
gtk_table_set_row_spacing(table, coord_y?(coord_y-1):0, 1);
end_it:
list_iterator_destroy(itr);
list_iterator_destroy(itr2);
return rc;
}
extern void put_buttons_in_table(GtkTable *table, List button_list)
{
int coord_x=0, coord_y=0;
button_processor_t button_processor;
grid_button_t *grid_button = NULL;
ListIterator itr = NULL;
list_sort(button_list, (ListCmpF) _sort_button_inx);
if (!button_list) {
g_print("put_buttons_in_table: no node_list given\n");
return;
}
if (_init_button_processor(&button_processor, list_count(button_list))
!= SLURM_SUCCESS)
return;
button_processor.table = table;
button_processor.button_list = button_list;
button_processor.coord_x = &coord_x;
button_processor.coord_y = &coord_y;
gtk_table_resize(table, button_processor.table_y,
working_sview_config.grid_x_width);
itr = list_iterator_create(button_list);
while ((grid_button = list_next(itr))) {
if (cluster_dims == 3) {
grid_button->table = table;
gtk_table_attach(table, grid_button->button,
grid_button->table_x,
(grid_button->table_x+1),
grid_button->table_y,
(grid_button->table_y+1),
GTK_SHRINK, GTK_SHRINK,
1, 1);
if (!grid_button->table_x) {
gtk_table_set_row_spacing(table,
grid_button->table_y,
working_sview_config.gap_size);
}
} else {
grid_button->table = table;
grid_button->table_x = coord_x;
grid_button->table_y = coord_y;
gtk_table_attach(table, grid_button->button,
coord_x, (coord_x+1),
coord_y, (coord_y+1),
GTK_SHRINK, GTK_SHRINK,
1, 1);
coord_x++;
if (coord_x == working_sview_config.grid_x_width) {
coord_x = 0;
coord_y++;
if (!(coord_y % working_sview_config.grid_vert))
gtk_table_set_row_spacing(
table, coord_y-1,
working_sview_config.gap_size);
}
if (coord_y == button_processor.table_y)
break;
if (coord_x
&& !(coord_x % working_sview_config.grid_hori))
gtk_table_set_col_spacing(table, coord_x-1, 5);
}
}
list_iterator_destroy(itr);
if (cluster_dims == 0) {
/* This is needed to get the correct width of the grid window.
* If it is not given then we get a really narrow window. */
gtk_table_set_row_spacing(table, coord_y?(coord_y-1):0, 1);
}
gtk_widget_show_all(GTK_WIDGET(table));
}
static void
deposit_dialog(DepositArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GtkWidget *dialog, *table, *hbox, *label, *pivot;
DepositControls controls;
gint response;
GwyPixmapLayer *layer;
gint row, newid;
GwyDataField *rfield;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Deposit spherical particles"), NULL, 0,
NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Start"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.mydata = gwy_container_duplicate_by_prefix(data,
"/0/data/",
"/0/base/palette",
"/0/base/range-type",
"/0/base/", NULL);
gwy_container_set_object_by_name(controls.mydata, "/0/data", gwy_data_field_duplicate(dfield));
controls.old_dfield = gwy_data_field_duplicate(dfield);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(10, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Deposition parameters:")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
table_attach_threshold(table, &row, _("_Size"),
&controls.size, args->size,
&controls);
pivot = gwy_table_hscale_get_scale(controls.size);
controls.value_size = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_size), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_size,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.size, "value-changed",
G_CALLBACK(update_threshold_size), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_size);
controls.format_size
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_size->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/*
table_attach_threshold(table, &row, _("_Distribution width"),
&controls.width, args->width,
&controls);
pivot = gwy_table_hscale_get_scale(controls.width);
controls.value_width = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_width), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_width,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.width, "value-changed",
G_CALLBACK(update_threshold_width), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_width);
controls.format_width
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_width->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
*/
table_attach_threshold(table, &row, _("_Coverage:"),
&controls.coverage, args->coverage,
&controls);
table_attach_threshold(table, &row, _("_Revise after settle"),
&controls.revise, args->revise,
&controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
deposit_invalidate(&controls);
update_threshold_size(&controls);
//update_threshold_width(&controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
/* show initial preview if instant updates are on */
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
deposit_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = deposit_defaults;
deposit_dialog_update_controls(&controls, args);
controls.in_init = TRUE;
preview(&controls, args);
controls.in_init = FALSE;
break;
case RESPONSE_PREVIEW:
deposit_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
deposit_dialog_update_values(&controls, args);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
if (args->computed) {
rfield = gwy_container_get_object_by_name(controls.mydata, "/0/data");
newid = gwy_app_data_browser_add_data_field(rfield,
data, TRUE);
gwy_app_sync_data_items(data, data,
id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
GWY_DATA_ITEM_SELECTIONS,
0);
gwy_app_set_data_field_title(data, newid, _("Particles"));
g_object_unref(controls.mydata);
}
}
int
main (int argc, char *argv[])
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *hscrollbar;
GtkWidget *vscrollbar;
GtkWidget *hbox;
static GtkTargetEntry targetlist[] = {
{ "STRING", 0, STRING },
{ "TEXT", 0, TEXT },
{ "COMPOUND_TEXT", 0, COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
gtk_init (&argc, &argv);
init_atoms();
selection_widget = gtk_invisible_new ();
dialog = gtk_dialog_new ();
gtk_widget_set_name (dialog, "Test Input");
gtk_container_set_border_width (GTK_CONTAINER(dialog), 0);
g_signal_connect (dialog, "destroy",
G_CALLBACK (quit), NULL);
table = gtk_table_new (4, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER(table), 10);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 5);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox),
table, TRUE, TRUE, 0);
gtk_widget_show (table);
selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
gtk_table_attach (GTK_TABLE (table), selection_button, 0, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (selection_button);
g_signal_connect (selection_button, "toggled",
G_CALLBACK (selection_toggled), NULL);
g_signal_connect (selection_widget, "selection_clear_event",
G_CALLBACK (selection_clear), NULL);
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (selection_received), NULL);
gtk_selection_add_targets (selection_widget, GDK_SELECTION_PRIMARY,
targetlist, ntargets);
g_signal_connect (selection_widget, "selection_get",
G_CALLBACK (selection_get), NULL);
selection_text = gtk_text_new (NULL, NULL);
gtk_table_attach_defaults (GTK_TABLE (table), selection_text, 0, 1, 1, 2);
gtk_widget_show (selection_text);
hscrollbar = gtk_hscrollbar_new (GTK_TEXT (selection_text)->hadj);
gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hscrollbar);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (selection_text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);
hbox = gtk_hbox_new (FALSE, 2);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 2, 3, 4,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (hbox);
label = gtk_label_new ("Target:");
gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Paste");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (paste), entry);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), dialog);
gtk_widget_show (button);
gtk_widget_show (dialog);
gtk_main ();
return 0;
}
static void
gfilter_dialog(GFilterArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *vbox, *hbox, *scwin, *hbox2, *label;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GFilterControls controls;
gint response, row, i;
GwySIUnit *siunit;
GwyPixmapLayer *layer;
controls.args = args;
controls.mask = mfield;
controls.in_init = TRUE;
controls.computed = FALSE;
siunit = gwy_si_unit_new(NULL);
for (i = 0; i < NQUANTITIES; i++) {
controls.vf[i]
= gwy_si_unit_get_format_with_digits(siunit,
GWY_SI_UNIT_FORMAT_VFMARKUP,
1.0, 4, NULL);
}
g_object_unref(siunit);
dialog = gtk_dialog_new_with_buttons(_("Filter Grains"),
NULL, 0, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), RESPONSE_PREVIEW,
!args->update);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 4);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
mfield = gwy_data_field_duplicate(mfield);
gwy_container_set_object_by_name(controls.mydata, "/0/mask", mfield);
g_object_unref(mfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
layer = gwy_layer_mask_new();
gwy_pixmap_layer_set_data_key(layer, "/0/mask");
gwy_layer_mask_set_color_key(GWY_LAYER_MASK(layer), "/0/mask");
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update),
args->update);
gtk_box_pack_start(GTK_BOX(vbox), controls.update, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.update, "toggled",
G_CALLBACK(update_changed), &controls);
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Mask color:"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.color_button);
gtk_box_pack_start(GTK_BOX(hbox2), controls.color_button, FALSE, FALSE, 0);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_changed), &controls);
table = gtk_table_new(10, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4);
controls.table = table;
row = 0;
scwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scwin, 0, 4, row, row+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
controls.values = gwy_grain_value_tree_view_new(FALSE,
"name", "symbol_markup",
NULL);
treeview = GTK_TREE_VIEW(controls.values);
gtk_widget_set_size_request(scwin, -1, 120);
gtk_tree_view_set_headers_visible(treeview, FALSE);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gwy_grain_value_tree_view_set_same_units(treeview, args->units_equal);
gwy_grain_value_tree_view_set_expanded_groups(treeview, args->expanded);
gtk_container_add(GTK_CONTAINER(scwin), controls.values);
row++;
hbox2 = gtk_hbox_new(FALSE, 0);
for (i = 0; i < NQUANTITIES; i++) {
gchar buf[2];
buf[0] = 'A' + i;
buf[1] = '\0';
controls.set_as[i] = gtk_button_new_with_label(buf);
gtk_box_pack_start(GTK_BOX(hbox2), controls.set_as[i], FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(controls.set_as[i]),
"id", GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.set_as[i], "clicked",
G_CALLBACK(set_as_clicked), &controls);
}
gwy_table_attach_hscale(table, row++,
_("Set selected as:"), NULL,
GTK_OBJECT(hbox2), GWY_HSCALE_WIDGET_NO_EXPAND);
controls.logical_op
= gwy_enum_combo_box_newl(G_CALLBACK(logical_op_changed), &controls,
args->logical,
"A", GRAIN_LOGICAL_A,
"A ∧ B", GRAIN_LOGICAL_A_AND_B,
"A ∨ B", GRAIN_LOGICAL_A_OR_B,
"A ∧ B ∧ C", GRAIN_LOGICAL_A_AND_B_AND_C,
"A ∨ B ∨ C", GRAIN_LOGICAL_A_OR_B_OR_C,
"(A ∧ B) ∨ C", GRAIN_LOGICAL_A_AND_B_OR_C,
"(A ∨ B) ∧ C", GRAIN_LOGICAL_A_OR_B_AND_C,
NULL);
gwy_table_attach_hscale(table, row++,
_("Keep grains satisfying:"), NULL,
GTK_OBJECT(controls.logical_op),
GWY_HSCALE_WIDGET);
for (i = 0; i < NQUANTITIES; i++) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.header[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.header[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.header[i],
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
/* The values are set properly later. */
controls.lower_label[i] = gtk_label_new(_("Lower threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.lower_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.lower[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.lower[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.lower_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.lower[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.lower_scale[i]), FALSE);
gtk_widget_set_size_request(controls.lower_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.lower_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.lower_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.lower_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.lower_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.lower_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.lower_entry[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.lower_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.lower_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.upper_label[i] = gtk_label_new(_("Upper threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.upper_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.upper[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.upper[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.upper_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.upper[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.upper_scale[i]), FALSE);
gtk_widget_set_size_request(controls.upper_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.upper_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.upper_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.upper_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.upper_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.upper_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.upper_entry[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.upper_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.upper_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
}
for (i = 0; i < NQUANTITIES; i++) {
GwyInventory *inventory;
GwyGrainValue *gvalue;
inventory = gwy_grain_values();
gvalue = gwy_inventory_get_item(inventory, args->ranges[i].quantity);
set_up_quantity(&controls, gvalue, i);
}
logical_op_changed(GTK_COMBO_BOX(controls.logical_op), &controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
gfilter_invalidate(&controls);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gfilter_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_PREVIEW:
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gfilter_save_args(gwy_app_settings_get(), args);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, controls.mask, mquark);
}
gwy_app_channel_log_add_proc(data, id, id);
}
static void
presentation_attach(GwyContainer *data,
GwyRunType run)
{
GtkWidget *dialog, *table, *label, *chooser;
GwyAppDataId target;
gint row, response;
g_return_if_fail(run & PRESENTATION_ATTACH_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_CONTAINER_ID, &target.datano,
GWY_APP_DATA_FIELD_ID, &target.id,
0);
gwy_app_data_id_verify_channel(&attach_source_id);
dialog = gtk_dialog_new_with_buttons(_("Attach Presentation"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
table = gtk_table_new(1, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
row = 0;
label = gtk_label_new_with_mnemonic(_("_Data to attach:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
chooser = gwy_data_chooser_new_channels();
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser),
&presentation_attach_filter, &target, NULL);
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(chooser),
&attach_source_id);
gtk_table_attach(GTK_TABLE(table), chooser, 1, 2, row, row+1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), chooser);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return;
break;
case GTK_RESPONSE_OK:
gwy_data_chooser_get_active_id(GWY_DATA_CHOOSER(chooser),
&attach_source_id);
/* The data must be always compatible at least with itself */
g_assert(attach_source_id.datano);
presentation_attach_do(&attach_source_id, &target);
gwy_app_channel_log_add_proc(data, target.id, target.id);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
}
static gboolean
tile_dialog (gint32 image_ID,
gint32 drawable_ID)
{
GtkWidget *dlg;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *sizeentry;
GtkWidget *chainbutton;
GtkWidget *toggle;
gint width;
gint height;
gdouble xres;
gdouble yres;
GimpUnit unit;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
width = gimp_drawable_width (drawable_ID);
height = gimp_drawable_height (drawable_ID);
unit = gimp_image_get_unit (image_ID);
gimp_image_get_resolution (image_ID, &xres, &yres);
tvals.new_width = width;
tvals.new_height = height;
dlg = gimp_dialog_new (_("Tile"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dlg));
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
frame = gimp_frame_new (_("Tile to New Size"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, 8,
GIMP_SIZE_ENTRY_UPDATE_SIZE,
tvals.constrain, TRUE,
_("_Width:"), width, xres,
1, GIMP_MAX_IMAGE_SIZE,
0, width,
_("_Height:"), height, yres,
1, GIMP_MAX_IMAGE_SIZE,
0, height);
gtk_container_add (GTK_CONTAINER (frame), sizeentry);
gtk_table_set_row_spacing (GTK_TABLE (sizeentry), 1, 6);
gtk_widget_show (sizeentry);
chainbutton = GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (sizeentry));
toggle = gtk_check_button_new_with_mnemonic (_("C_reate new image"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), tvals.new_image);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&tvals.new_image);
gtk_widget_show (dlg);
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);
if (run)
{
tvals.new_width =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 0));
tvals.new_height =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 1));
tvals.constrain =
gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (chainbutton));
}
gtk_widget_destroy (dlg);
return run;
}
static GtkWidget *server_stats_page (void) {
GtkWidget *page_vbox;
GtkWidget *alignment;
GtkWidget *table;
GtkWidget *game_label;
GtkWidget *scrollwin;
int i;
int row = 0;
page_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (page_vbox), scrollwin, TRUE, TRUE, 0);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwin), alignment);
table = gtk_table_new (GAMES_TOTAL + 2, 7, FALSE);
gtk_container_add (GTK_CONTAINER (alignment), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 20);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 20);
gtk_table_set_col_spacing (GTK_TABLE (table), 5, 20);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), GAMES_TOTAL, 12);
for (i = 0; i < 6; i++)
put_label_to_table (table, _(srv_headers[i]), 1.0, i + 1, 0);
for (i = 0, row = 1; i < GAMES_TOTAL; i++) {
// Skip a game if it's not configured and show only configured is enabled
if (!games[i].cmd && default_show_only_configured_games)
continue;
game_label = game_pixmap_with_label (i);
gtk_table_attach_defaults (GTK_TABLE (table),
game_label,
0, 1, row, row+1);
put_server_stats (table, i, row);
{
srv_stats[GAMES_TOTAL].servers += srv_stats[i].servers;
srv_stats[GAMES_TOTAL].ok += srv_stats[i].ok;
srv_stats[GAMES_TOTAL].timeout += srv_stats[i].timeout;
srv_stats[GAMES_TOTAL].down += srv_stats[i].down;
srv_stats[GAMES_TOTAL].na += srv_stats[i].na;
srv_stats[GAMES_TOTAL].players += srv_stats[i].players;
}
row++;
}
put_label_to_table (table, _("Total"), 0.0, 0, row + 1);
put_server_stats (table, GAMES_TOTAL, row + 1);
gtk_widget_show (table);
gtk_widget_show (scrollwin);
gtk_widget_show (alignment);
gtk_widget_show (page_vbox);
return page_vbox;
}
void ui_dialog_results_add_entry(GtkWidget *table, gint offset,
RinksTournament *tournament, RinksEncounter *encounter)
{
g_printf("dialog-results: add entry\n");
struct UiDialogResultsEntry *entry = g_malloc(sizeof(struct UiDialogResultsEntry));
entry->encounter_id = encounter->id;
gint i;
RinksTeam *team;
RinksResult *result;
GtkWidget *label;
entry->teams[0] = encounter->real_team1;
entry->teams[1] = encounter->real_team2;
gchar *buffer;
for (i = 0; i < 2; ++i) {
team = tournament_get_team(tournament, i == 0 ? encounter->real_team1 : encounter->real_team2);
if (team) {
label = gtk_label_new(team->name); /* get team name */
result = tournament_get_result(tournament, encounter->id, team->id);
}
else {
label = gtk_label_new("Team nicht gesetzt");
result = NULL;
}
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, offset + i, offset + i + 1, GTK_FILL, 0, 2, 2);
entry->points[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(entry->points[i]), 2);
gtk_table_attach(GTK_TABLE(table), entry->points[i], 1, 2, offset + i, offset + i + 1, 0, 0, 2, 2);
entry->ends[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(entry->ends[i]), 3);
gtk_table_attach(GTK_TABLE(table), entry->ends[i], 2, 3, offset + i, offset + i + 1, 0, 0, 2, 2);
entry->stones[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(entry->stones[i]), 3);
gtk_table_attach(GTK_TABLE(table), entry->stones[i], 3, 4, offset + i, offset + i + 1, 0, 0, 2, 2);
if (result) {
buffer = g_strdup_printf("%d", result->points);
gtk_entry_set_text(GTK_ENTRY(entry->points[i]), buffer);
g_free(buffer);
buffer = g_strdup_printf("%d", result->ends);
gtk_entry_set_text(GTK_ENTRY(entry->ends[i]), buffer);
g_free(buffer);
buffer = g_strdup_printf("%d", result->stones);
gtk_entry_set_text(GTK_ENTRY(entry->stones[i]), buffer);
g_free(buffer);
g_free(result);
}
}
gtk_table_set_row_spacing(GTK_TABLE(table), offset + 1, 15);
ui_dialog_results_entries = g_list_prepend(ui_dialog_results_entries, entry);
}
static void
tip_blind_dialog(TipBlindArgs *args)
{
GtkWidget *dialog, *table, *hbox, *vbox, *label;
GwyContainer *data;
GwyGraphModel *gmodel;
GwyGraphArea *area;
TipBlindControls controls;
GwyPixmapLayer *layer;
GwyDataField *dfield;
GQuark quark;
GwySIUnit *unit;
gint response, row;
dialog = gtk_dialog_new_with_buttons(_("Blind Tip Estimation"), NULL, 0,
_("Run _Partial"), RESPONSE_ESTIMATE,
_("Run _Full"), RESPONSE_REFINE,
_("_Reset Tip"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.args = args;
controls.in_update = TRUE;
controls.good_tip = FALSE;
controls.dialog = dialog;
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK,
controls.good_tip);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.vxres = 240;
controls.vyres = 240;
controls.oldnstripes = args->nstripes;
/* set initial tip properties */
data = gwy_app_data_browser_get(args->source.datano);
quark = gwy_app_get_data_key_for_id(args->source.id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
controls.tip = gwy_data_field_new_alike(dfield, TRUE);
gwy_data_field_resample(controls.tip, args->xres, args->yres,
GWY_INTERPOLATION_NONE);
gwy_data_field_clear(controls.tip);
/* set up data of rescaled image of the tip */
controls.vtip = gwy_container_new();
gwy_app_sync_data_items(data, controls.vtip,
args->source.id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
0);
dfield = gwy_data_field_new_alike(controls.tip, TRUE);
gwy_data_field_resample(dfield, controls.vxres, controls.vyres,
GWY_INTERPOLATION_ROUND);
gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield);
g_object_unref(dfield);
/* set up rescaled image of the tip */
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.vtip);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
/* set up tip estimation controls */
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
gmodel = gwy_graph_model_new();
controls.graph = gwy_graph_new(gmodel);
g_object_unref(gmodel);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_LEFT),
FALSE);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_BOTTOM),
FALSE);
area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph)));
gtk_widget_set_no_show_all(gwy_graph_area_get_label(area), TRUE);
g_signal_connect_after(gwy_graph_area_get_label(area), "map",
G_CALLBACK(gtk_widget_hide), NULL);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0);
table = gtk_table_new(13, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 4);
row = 0;
controls.data = gwy_data_chooser_new_channels();
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(controls.data),
tip_blind_source_filter, &args->orig, NULL);
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(controls.data),
&args->source);
g_signal_connect(controls.data, "changed",
G_CALLBACK(data_changed), &args->source);
gwy_table_attach_hscale(table, row, _("Related _data:"), NULL,
GTK_OBJECT(controls.data), GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gtk_label_new(_("Estimated Tip Size"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.xres = gtk_adjustment_new(args->xres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Width:"), "px", controls.xres, 0);
g_object_set_data(G_OBJECT(controls.xres), "controls", &controls);
g_signal_connect(controls.xres, "value-changed",
G_CALLBACK(width_changed), &controls);
row++;
controls.yres = gtk_adjustment_new(args->yres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Height:"), "px", controls.yres, 0);
g_object_set_data(G_OBJECT(controls.yres), "controls", &controls);
g_signal_connect(controls.yres, "value-changed",
G_CALLBACK(height_changed), &controls);
row++;
controls.same_resolution
= gtk_check_button_new_with_mnemonic(_("_Same resolution"));
gtk_table_attach(GTK_TABLE(table), controls.same_resolution,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_resolution),
args->same_resolution);
g_signal_connect(controls.same_resolution, "toggled",
G_CALLBACK(same_resolution_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.threshold = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0);
controls.threshold_spin
= gtk_spin_button_new(GTK_ADJUSTMENT(controls.threshold), 0.1, 2);
gtk_table_attach(GTK_TABLE(table), controls.threshold_spin,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Noise suppression t_hreshold:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.threshold_spin);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_z(dfield);
controls.threshold_unit
= gwy_combo_box_metric_unit_new(G_CALLBACK(thresh_changed),
&controls,
-12, -3, unit, -9);
gtk_table_attach(GTK_TABLE(table), controls.threshold_unit,
3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.threshold, "value-changed",
G_CALLBACK(thresh_changed), &controls);
sci_entry_set_value(GTK_ADJUSTMENT(controls.threshold),
GTK_COMBO_BOX(controls.threshold_unit),
args->thresh);
row++;
controls.boundaries
= gtk_check_button_new_with_mnemonic(_("Use _boundaries"));
gtk_table_attach(GTK_TABLE(table), controls.boundaries,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.boundaries),
args->use_boundaries);
g_signal_connect(controls.boundaries, "toggled",
G_CALLBACK(bound_changed), args);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Stripes")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.nstripes = gtk_adjustment_new(args->nstripes,
MIN_STRIPES, MAX_STRIPES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Split to stripes:"), NULL,
controls.nstripes, GWY_HSCALE_CHECK);
controls.split_to_stripes = gwy_table_hscale_get_check(controls.nstripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
!args->split_to_stripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
args->split_to_stripes);
g_signal_connect(controls.split_to_stripes, "toggled",
G_CALLBACK(split_to_stripes_changed), &controls);
g_signal_connect(controls.nstripes, "value-changed",
G_CALLBACK(nstripes_changed), &controls);
row++;
controls.stripeno = gtk_adjustment_new(1, 1, args->nstripes, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Preview stripe:"), NULL,
controls.stripeno, GWY_HSCALE_DEFAULT);
g_signal_connect(controls.stripeno, "value-changed",
G_CALLBACK(stripeno_changed), &controls);
row++;
controls.plot_size_graph
= gtk_check_button_new_with_mnemonic(_("Plot size _graph"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_size_graph),
args->plot_size_graph);
gtk_table_attach(GTK_TABLE(table), controls.plot_size_graph,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.plot_size_graph, "toggled",
G_CALLBACK(plot_size_graph_changed), &controls);
row++;
controls.create_images
= gtk_check_button_new_with_mnemonic(_("Create tip i_mages"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.create_images),
args->create_images);
gtk_table_attach(GTK_TABLE(table), controls.create_images,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.create_images, "toggled",
G_CALLBACK(create_images_changed), &controls);
row++;
controls.tipdone = FALSE;
controls.in_update = FALSE;
split_to_stripes_changed(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
&controls);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
tip_blind_dialog_abandon(&controls);
tip_blind_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
tip_blind_save_args(gwy_app_settings_get(), args);
tip_blind_do(&controls, args);
break;
case RESPONSE_RESET:
reset(&controls, args);
break;
case RESPONSE_ESTIMATE:
tip_blind_run(&controls, args, FALSE);
break;
case RESPONSE_REFINE:
tip_blind_run(&controls, args, TRUE);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
tip_blind_dialog_abandon(&controls);
return;
}
static gboolean
vpropagate_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle_vbox;
GtkWidget *button;
GtkObject *adj;
GSList *group = NULL;
gint index = 0;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, VPROPAGATE_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (value_propagate_body),
drawable);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Propagate Mode */
frame = gimp_frame_new (_("Mode"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
gtk_widget_show (toggle_vbox);
for (index = 0; index < num_mode; index++)
{
button =
gtk_radio_button_new_with_mnemonic (group,
gettext (modes[index].name));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (index));
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_radio_button_update),
&vpvals.propagate_mode);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
index == vpvals.propagate_mode);
}
/* Parameter settings */
frame = gimp_frame_new (_("Propagate"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (8, 3, FALSE); /* 4 raw, 2 columns(name and value) */
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 5, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Lower t_hreshold:"), SCALE_WIDTH, 4,
vpvals.lower_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.lower_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("_Upper threshold:"), SCALE_WIDTH, 4,
vpvals.upper_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.upper_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("_Propagating rate:"), SCALE_WIDTH, 4,
vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vpvals.propagating_rate);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_table_add_toggle (table, _("To l_eft"), 0, 1, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Right2Left]);
gtk_table_add_toggle (table, _("To _right"), 2, 3, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Left2Right]);
gtk_table_add_toggle (table, _("To _top"), 1, 2, 3,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Bottom2Top]);
gtk_table_add_toggle (table, _("To _bottom"), 1, 2, 5,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Top2Bottom]);
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
GtkWidget *toggle;
toggle =
gtk_table_add_toggle (table, _("Propagating _alpha channel"),
0, 3, 6,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_alpha);
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0);
gtk_widget_set_sensitive (toggle, FALSE);
}
gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_value);
}
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
gint i, result;
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
}
gtk_widget_destroy (dialog);
return run;
}
static GtkWidget *
cdisplay_lcms_configure (GimpColorDisplay *display)
{
CdisplayLcms *lcms = CDISPLAY_LCMS (display);
GObject *config = G_OBJECT (gimp_color_display_get_config (display));
GtkWidget *vbox;
GtkWidget *hint;
GtkWidget *table;
GtkWidget *label;
gint row = 0;
if (! config)
return NULL;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
hint = gimp_hint_box_new (_("This filter takes its configuration "
"from the Color Management section "
"in the Preferences dialog."));
gtk_box_pack_start (GTK_BOX (vbox), hint, FALSE, FALSE, 0);
gtk_widget_show (hint);
table = gtk_table_new (5, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
cdisplay_lcms_attach_labelled (GTK_TABLE (table), row++,
_("Mode of operation:"),
gimp_prop_enum_label_new (config, "mode"));
label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
g_object_set_data (G_OBJECT (lcms), "rgb-profile", label);
cdisplay_lcms_attach_labelled (GTK_TABLE (table), row++,
_("Image profile:"),
label);
cdisplay_lcms_update_profile_label (lcms, "rgb-profile");
label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
g_object_set_data (G_OBJECT (lcms), "display-profile", label);
cdisplay_lcms_attach_labelled (GTK_TABLE (table), row++,
_("Monitor profile:"),
label);
cdisplay_lcms_update_profile_label (lcms, "display-profile");
label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
g_object_set_data (G_OBJECT (lcms), "printer-profile", label);
cdisplay_lcms_attach_labelled (GTK_TABLE (table), row++,
_("Print simulation profile:"),
label);
cdisplay_lcms_update_profile_label (lcms, "printer-profile");
g_signal_connect_object (config, "notify",
G_CALLBACK (cdisplay_lcms_notify_profile),
lcms, 0);
return vbox;
}
/* Add a button for a given node. If node_ptr == NULL then fill in any gaps
* in the grid just for a clean look. Always call with node_ptr == NULL for
* the last call in the sequence. */
static int _add_button_to_list(node_info_t *node_ptr,
button_processor_t *button_processor)
{
static bool *node_exists = NULL;
static int node_exists_cnt = 1;
grid_button_t *grid_button = button_processor->grid_button;
int *dim_size = NULL, i, coord_x = 0, coord_y = 0;
int len = 0, len_a = 0;
if (cluster_dims > 1) {
dim_size = _get_cluster_dims();
if (dim_size == NULL) {
g_error("Could not read dim_size\n");
return SLURM_ERROR;
}
if ((dim_size[0] < 1) || (cluster_dims < 1)) {
g_error("Invalid dim_size %d or cluster_dims %d\n",
dim_size[0], cluster_dims);
return SLURM_ERROR;
}
/* Translate a 3D or 4D space into a 2D space to the extent
* possible. */
if (node_exists == NULL) {
node_exists_cnt = 1;
for (i = 0; i < cluster_dims; i++)
node_exists_cnt *= dim_size[i];
node_exists = xmalloc(sizeof(bool) * node_exists_cnt);
}
if (node_ptr) {
len = strlen(node_ptr->name);
if (len < cluster_dims) {
g_error("bad node name %s\n", node_ptr->name);
return SLURM_ERROR;
}
if (cluster_flags & CLUSTER_FLAG_CRAY_A) {
len_a = strlen(node_ptr->node_addr);
if (len_a < cluster_dims) {
g_error("bad node addr %s\n",
node_ptr->node_addr);
return SLURM_ERROR;
}
}
}
}
if (cluster_dims == 3) {
int x, y, z;
if (node_ptr) {
if (cluster_flags & CLUSTER_FLAG_CRAY_A) {
x = select_char2coord(
node_ptr->node_addr[len_a-3]);
y = select_char2coord(
node_ptr->node_addr[len_a-2]);
z = select_char2coord(
node_ptr->node_addr[len_a-1]);
} else {
x = select_char2coord(node_ptr->name[len-3]);
y = select_char2coord(node_ptr->name[len-2]);
z = select_char2coord(node_ptr->name[len-1]);
}
i = (x * dim_size[1] + y) * dim_size[2] + z;
node_exists[i] = true;
_calc_coord_3d(x, y, z,
button_processor->default_y_offset,
&coord_x, &coord_y, dim_size);
} else {
for (x = 0; x < dim_size[0]; x++) {
for (y = 0; y < dim_size[1]; y++) {
for (z = 0; z < dim_size[2]; z++) {
i = (x * dim_size[1] + y) *
dim_size[2] + z;
if (node_exists[i])
continue;
_calc_coord_3d(x, y, z,
button_processor->
default_y_offset,
&coord_x, &coord_y,
dim_size);
_build_empty_node(
coord_x, coord_y,
button_processor);
}
}
}
xfree(node_exists);
return SLURM_SUCCESS;
}
}
if (node_ptr == NULL)
return SLURM_SUCCESS;
if (cluster_dims > 1) {
(*button_processor->coord_x) = coord_x;
(*button_processor->coord_y) = coord_y;
#if 0
g_print("%s %d:%d\n", node_ptr->name, coord_x, coord_y);
#endif
}
if (!grid_button) {
grid_button = xmalloc(sizeof(grid_button_t));
grid_button->color_inx = MAKE_INIT;
grid_button->inx = (*button_processor->inx);
grid_button->table = button_processor->table;
grid_button->table_x = (*button_processor->coord_x);
grid_button->table_y = (*button_processor->coord_y);
grid_button->button = gtk_button_new();
grid_button->node_name = xstrdup(node_ptr->name);
gtk_widget_set_size_request(grid_button->button,
working_sview_config.button_size,
working_sview_config.button_size);
_add_button_signals(grid_button);
list_append(button_processor->button_list, grid_button);
gtk_table_attach(button_processor->table, grid_button->button,
(*button_processor->coord_x),
((*button_processor->coord_x)+1),
(*button_processor->coord_y),
((*button_processor->coord_y)+1),
GTK_SHRINK, GTK_SHRINK,
1, 1);
} else {
grid_button->table_x = (*button_processor->coord_x);
grid_button->table_y = (*button_processor->coord_y);
gtk_container_child_set(
GTK_CONTAINER(button_processor->table),
grid_button->button,
"left-attach", (*button_processor->coord_x),
"right-attach", ((*button_processor->coord_x)+1),
"top-attach", (*button_processor->coord_y),
"bottom-attach", ((*button_processor->coord_y)+1),
NULL);
}
/* gtk_container_add(GTK_CONTAINER(grid_button->frame), */
/* grid_button->button); */
/* gtk_frame_set_shadow_type(GTK_FRAME(grid_button->frame), */
/* GTK_SHADOW_ETCHED_OUT); */
if (cluster_dims < 3) {
/* On linear systems we just up the x_coord until we hit the
* side of the table and then increment the coord_y. We add
* space between each tenth row. */
(*button_processor->coord_x)++;
if (button_processor->force_row_break) {
(*button_processor->coord_x) = 0;
(*button_processor->coord_y)++;
gtk_table_set_row_spacing(
button_processor->table,
(*button_processor->coord_y)-1,
working_sview_config.gap_size);
return SLURM_SUCCESS;
}
if ((*button_processor->coord_x)
== working_sview_config.grid_x_width) {
(*button_processor->coord_x) = 0;
(*button_processor->coord_y)++;
if (!((*button_processor->coord_y)
% working_sview_config.grid_vert))
gtk_table_set_row_spacing(
button_processor->table,
(*button_processor->coord_y)-1,
working_sview_config.gap_size);
}
if ((*button_processor->coord_y) == button_processor->table_y)
return SLURM_SUCCESS;
if ((*button_processor->coord_x) &&
!((*button_processor->coord_x)
% working_sview_config.grid_hori))
gtk_table_set_col_spacing(
button_processor->table,
(*button_processor->coord_x)-1,
working_sview_config.gap_size);
}
return SLURM_SUCCESS;
}
static int _grid_table_by_switch(button_processor_t *button_processor,
List node_list)
{
int rc = SLURM_SUCCESS;
int inx = 0, ii = 0;
switch_record_bitmaps_t *sw_nodes_bitmaps_ptr = g_switch_nodes_maps;
#if TOPO_DEBUG
/* engage if want original display below switched */
ListIterator itr = list_iterator_create(node_list);
sview_node_info_t *sview_node_info_ptr = NULL;
#endif
button_processor->inx = &inx;
for (ii=0; ii<g_topo_info_msg_ptr->record_count;
ii++, sw_nodes_bitmaps_ptr++) {
int j = 0, first, last;
if (g_topo_info_msg_ptr->topo_array[ii].level)
continue;
first = bit_ffs(sw_nodes_bitmaps_ptr->node_bitmap);
if (first == -1)
continue;
last = bit_fls(sw_nodes_bitmaps_ptr->node_bitmap);
button_processor->inx = &j;
button_processor->force_row_break = false;
for (j = first; j <= last; j++) {
if (TOPO_DEBUG)
g_print("allocated node = %s button# %d\n",
g_node_info_ptr->node_array[j].name,
j);
if (!bit_test(sw_nodes_bitmaps_ptr->node_bitmap, j))
continue;
/* if (!working_sview_config.show_hidden) { */
/* if (!check_part_includes_node(j)) */
/* continue; */
/* } */
if (j == last)
button_processor->force_row_break = true;
if ((rc = _add_button_to_list(
&g_node_info_ptr->node_array[j],
button_processor)) != SLURM_SUCCESS)
break;
button_processor->force_row_break = false;
}
rc = _add_button_to_list(NULL, button_processor);
}
#if TOPO_DEBUG
/* engage this if want original display below
* switched grid */
button_processor->inx = &inx;
while ((sview_node_info_ptr = list_next(itr))) {
if ((rc = _add_button_to_list(
sview_node_info_ptr->node_ptr,
button_processor)) != SLURM_SUCCESS)
break;
inx++;
}
list_iterator_destroy(itr);
#endif
/* This is needed to get the correct width of the grid window.
* If it is not given then we get a really narrow window. */
gtk_table_set_row_spacing(button_processor->table,
(*button_processor->coord_y)?
((*button_processor->coord_y)-1):0, 1);
return rc;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *check;
GtkWidget *separator;
GtkWidget *table;
GtkWidget *vscrollbar;
GtkWidget *text;
GdkColormap *cmap;
GdkColor color;
GdkFont *fixed_font;
FILE *infile;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (window, 600, 500);
gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Text Widget Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Create the GtkText widget */
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (text);
/* Add a vertical scrollbar to the GtkText widget */
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);
/* Get the system color map and allot the color red */
cmap = gdk_colormap_get_system();
color.red = 0xffff;
color.green = 0;
color.blue = 0;
if (!gdk_color_allot(cmap, &color)) {
g_error("couldn't allot color");
}
/* Load a fixed font */
fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-140-*-*-*-*-*-*");
/* Realizing a widget creates a window for it,
* * ready for us to insert some text */
gtk_widget_realize (text);
/* Freeze the text widget, ready for multiple updates */
gtk_text_freeze (GTK_TEXT (text));
/* Insert some colored text */
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"Supports ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &color, NULL,
"colored ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"text and different ", -1);
gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL,
"fonts\n\n", -1);
/* Load the file text.c into the text window */
infile = fopen("text.c", "r");
if (infile) {
char buffer[1024];
int nchars;
while (1)
{
nchars = fread(buffer, 1, 1024, infile);
gtk_text_insert (GTK_TEXT (text), fixed_font, NULL,
NULL, buffer, nchars);
if (nchars < 1024)
break;
}
fclose (infile);
}
/* Thaw the text widget, allowing the updates to become visible */
gtk_text_thaw (GTK_TEXT (text));
hbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
check = gtk_check_button_new_with_label("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_flags (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return(0);
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_export_t *d = (dt_lib_export_t *)malloc(sizeof(dt_lib_export_t));
self->data = (void *)d;
self->widget = gtk_table_new(8, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5);
GtkWidget *label;
label = dtgtk_label_new(_("target storage"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
d->storage = GTK_COMBO_BOX(gtk_combo_box_new_text());
GList *it = darktable.imageio->plugins_storage;
while(it)
{
dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
gtk_combo_box_append_text(d->storage, module->name(module));
it = g_list_next(it);
}
dt_control_signal_connect(darktable.signals,DT_SIGNAL_IMAGEIO_STORAGE_CHANGE,G_CALLBACK(on_storage_list_changed),self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage), 0, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (d->storage), "changed",
G_CALLBACK (storage_changed),
(gpointer)d);
d->storage_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0));
gtk_alignment_set_padding(GTK_ALIGNMENT(d->storage_box), 0, 0, 0, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage_box), 0, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = dtgtk_label_new(_("file format"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_set_row_spacing(GTK_TABLE(self->widget), 2, 20);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->format = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format), 0, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (d->format), "changed",
G_CALLBACK (format_changed),
(gpointer)d);
d->format_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0));
gtk_alignment_set_padding(GTK_ALIGNMENT(d->format_box), 0, 0, 0, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format_box), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = dtgtk_label_new(_("global options"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_table_set_row_spacing(GTK_TABLE(self->widget), 5, 20);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 6, 7, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->width = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1));
g_object_set(G_OBJECT(d->width), "tooltip-text", _("maximum output width\nset to 0 for no scaling"), (char *)NULL);
d->height = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1));
g_object_set(G_OBJECT(d->height), "tooltip-text", _("maximum output height\nset to 0 for no scaling"), (char *)NULL);
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->width));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->height));
/*
gtk_widget_add_events(GTK_WIDGET(d->width), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (d->width), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (d->width), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(d->height), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (d->height), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (d->height), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
label = gtk_label_new(_("max size"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0);
GtkBox *hbox = GTK_BOX(gtk_hbox_new(FALSE, 5));
gtk_box_pack_start(hbox, GTK_WIDGET(d->width), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, gtk_label_new(_("x")), FALSE, FALSE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(d->height), TRUE, TRUE, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 1, 2, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("intent"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->intent = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_combo_box_append_text(d->intent, _("image settings"));
gtk_combo_box_append_text(d->intent, _("perceptual"));
gtk_combo_box_append_text(d->intent, _("relative colorimetric"));
gtk_combo_box_append_text(d->intent, C_("rendering intent", "saturation"));
gtk_combo_box_append_text(d->intent, _("absolute colorimetric"));
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->intent), 1, 2, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0);
// Add profile combo
d->profiles = NULL;
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename));
g_strlcpy(prof->name, _("sRGB (web-safe)"), sizeof(prof->name));
int pos;
prof->pos = 1;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename));
g_strlcpy(prof->name, _("Adobe RGB"), sizeof(prof->name));
prof->pos = 2;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "X profile", sizeof(prof->filename));
g_strlcpy(prof->name, "X profile", sizeof(prof->name));
prof->pos = 3;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, _("linear RGB"), sizeof(prof->name));
pos = prof->pos = 4;
d->profiles = g_list_append(d->profiles, prof);
// read datadir/color/out/*.icc
char datadir[DT_MAX_PATH_LEN];
char confdir[DT_MAX_PATH_LEN];
char dirname[DT_MAX_PATH_LEN];
char filename[DT_MAX_PATH_LEN];
dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN);
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
cmsHPROFILE tmpprof;
const gchar *d_name;
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir);
if(!g_file_test(dirname, G_FILE_TEST_IS_DIR))
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir);
GDir *dir = g_dir_open(dirname, 0, NULL);
if(dir)
{
while((d_name = g_dir_read_name(dir)))
{
snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name);
tmpprof = cmsOpenProfileFromFile(filename, "r");
if(tmpprof)
{
char *lang = getenv("LANG");
if (!lang) lang = "en_US";
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
char name[1024];
cmsGetProfileInfoASCII(tmpprof, cmsInfoDescription, lang, lang+3, name, 1024);
g_strlcpy(prof->name, name, sizeof(prof->name));
g_strlcpy(prof->filename, d_name, sizeof(prof->filename));
prof->pos = ++pos;
cmsCloseProfile(tmpprof);
d->profiles = g_list_append(d->profiles, prof);
}
}
g_dir_close(dir);
}
GList *l = d->profiles;
label = gtk_label_new(_("profile"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->profile = GTK_COMBO_BOX(gtk_combo_box_new_text());
dt_ellipsize_combo(d->profile);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_SHRINK|GTK_EXPAND|GTK_FILL, 0, 0, 0);
// gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);
gtk_combo_box_append_text(d->profile, _("image settings"));
while(l)
{
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)l->data;
if(!strcmp(prof->name, "X profile"))
gtk_combo_box_append_text(d->profile, _("system display profile"));
else
gtk_combo_box_append_text(d->profile, prof->name);
l = g_list_next(l);
}
gtk_combo_box_set_active(d->profile, 0);
char tooltip[1024];
snprintf(tooltip, 1024, _("output icc profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(d->profile), "tooltip-text", tooltip, (char *)NULL);
// Add style combo
label = gtk_label_new(_("style"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->style = GTK_COMBO_BOX(gtk_combo_box_new_text());
dt_ellipsize_combo(d->style);
gtk_combo_box_append_text(d->style, _("none"));
GList *styles = dt_styles_get_list("");
while (styles)
{
dt_style_t *style=(dt_style_t *)styles->data;
gtk_combo_box_append_text(d->style, style->name);
styles=g_list_next(styles);
}
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->style), 1, 2, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_object_set(G_OBJECT(d->style), "tooltip-text", _("temporary style to append while exporting"), (char *)NULL);
// Set callback signals
g_signal_connect (G_OBJECT (d->intent), "changed",
G_CALLBACK (intent_changed),
(gpointer)d);
g_signal_connect (G_OBJECT (d->profile), "changed",
G_CALLBACK (profile_changed),
(gpointer)d);
g_signal_connect (G_OBJECT (d->style), "changed",
G_CALLBACK (style_changed),
(gpointer)d);
// Export button
GtkButton *button = GTK_BUTTON(gtk_button_new_with_label(_("export")));
d->export_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("export with current settings (ctrl-e)"), (char *)NULL);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(button), 1, 2, 11, 12, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (export_button_clicked),
(gpointer)self);
g_signal_connect (G_OBJECT (d->width), "value-changed",
G_CALLBACK (width_changed),
(gpointer)0);
g_signal_connect (G_OBJECT (d->height), "value-changed",
G_CALLBACK (height_changed),
(gpointer)0);
self->gui_reset(self);
}
static gboolean
load_dialog (const gchar *filename)
{
GtkWidget *dialog;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *abox;
GtkWidget *res;
GtkWidget *label;
GtkWidget *spinbutton;
GtkObject *adj;
guchar *pixels;
gboolean run = FALSE;
WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION,
- WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE };
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, LOAD_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* The WMF preview */
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0);
gtk_widget_show (abox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (abox), frame);
gtk_widget_show (frame);
pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height);
image = gimp_preview_area_new ();
gtk_widget_set_size_request (image, vals.width, vals.height);
gtk_container_add (GTK_CONTAINER (frame), image);
gtk_widget_show (image);
g_signal_connect (image, "size-allocate",
G_CALLBACK (wmf_preview_callback),
pixels);
size_label = gtk_label_new (NULL);
gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER);
gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4);
gtk_widget_show (size_label);
/* query the initial size after the size label is created */
vals.resolution = load_vals.resolution;
load_wmf_size (filename, &vals);
wmf_width = vals.width;
wmf_height = vals.height;
table = gtk_table_new (7, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2);
gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Width and Height */
label = gtk_label_new (_("Width:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, FALSE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_SIZE));
gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6);
gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (size));
gimp_size_entry_set_refval_boundaries (size, 0,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval_boundaries (size, 1,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval (size, 0, wmf_width);
gimp_size_entry_set_refval (size, 1, wmf_height);
gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE);
gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE);
g_signal_connect (size, "value-changed",
G_CALLBACK (load_dialog_size_callback),
NULL);
/* Scale ratio */
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
table2 = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2);
gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4);
gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0);
spinbutton =
gimp_spin_button_new (&xadj,
ratio_x,
(gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width,
(gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width,
0.01, 0.1, 0,
0.01, 4);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1);
gtk_widget_show (spinbutton);
g_signal_connect (xadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_X ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
spinbutton =
gimp_spin_button_new (&yadj,
ratio_y,
(gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height,
(gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height,
0.01, 0.1, 0,
0.01, 4);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2);
gtk_widget_show (spinbutton);
g_signal_connect (yadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_Y ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
/* the constrain ratio chainbutton */
constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT);
gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2);
gtk_widget_show (constrain);
gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button,
_("Constrain aspect ratio"), NULL);
gtk_widget_show (table2);
/* Resolution */
label = gtk_label_new (_("Resolution:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"),
FALSE, FALSE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_RESOLUTION);
gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6);
gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (res);
/* don't let the resolution become too small ? does libwmf tend to
crash with very small resolutions */
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0,
5.0, GIMP_MAX_RESOLUTION);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution);
g_signal_connect (res, "value-changed",
G_CALLBACK (load_dialog_resolution_callback),
(gpointer) filename);
gtk_widget_show (dialog);
if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0));
load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1));
run = TRUE;
}
gtk_widget_destroy (GTK_WIDGET (dialog));
return run;
}
static gboolean
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *entry;
GtkWidget *table;
GtkWidget *scrolled_window;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
gchar *gump_from;
gint row = 0;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* check gimprc for a preferred "From:" address */
gump_from = gimp_gimprc_query ("gump-from");
if (gump_from)
{
g_strlcpy (mail_info.from, gump_from, BUFFER_SIZE);
g_free (gump_from);
}
dlg = gimp_dialog_new (_("Send by Email"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Send"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
/* table */
table = gtk_table_new (5, 2, FALSE);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
/* Filename entry */
entry = gtk_entry_new ();
gtk_widget_set_size_request (entry, 200, -1);
gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1);
gtk_entry_set_text (GTK_ENTRY (entry), mail_info.filename);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("_Filename:"), 0.0, 0.5,
entry, 1, FALSE);
g_signal_connect (entry, "changed",
G_CALLBACK (mail_entry_callback),
mail_info.filename);
/* To entry */
entry = gtk_entry_new ();
gtk_widget_set_size_request (entry, 200, -1);
gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1);
gtk_entry_set_text (GTK_ENTRY (entry), mail_info.receipt);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
C_("email-address", "_To:"), 0.0, 0.5,
entry, 1, FALSE);
g_signal_connect (entry, "changed",
G_CALLBACK (mail_entry_callback),
mail_info.receipt);
gtk_widget_grab_focus (entry);
/* From entry */
entry = gtk_entry_new ();
gtk_widget_set_size_request (entry, 200, -1);
gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1);
gtk_entry_set_text (GTK_ENTRY (entry), mail_info.from);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
C_("email-address", "_From:"), 0.0, 0.5,
entry, 1, FALSE);
g_signal_connect (entry, "changed",
G_CALLBACK (mail_entry_callback),
mail_info.from);
/* Subject entry */
entry = gtk_entry_new ();
gtk_widget_set_size_request (entry, 200, -1);
gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1);
gtk_entry_set_text (GTK_ENTRY (entry), mail_info.subject);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("S_ubject:"), 0.0, 0.5,
entry, 1, FALSE);
g_signal_connect (entry, "changed",
G_CALLBACK (mail_entry_callback),
mail_info.subject);
/* Body */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (main_vbox), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
text_buffer = gtk_text_buffer_new (NULL);
g_signal_connect (text_buffer, "changed",
G_CALLBACK (mesg_body_callback),
NULL);
gtk_text_buffer_set_text (text_buffer, mail_info.comment, -1);
text_view = gtk_text_view_new_with_buffer (text_buffer);
g_object_unref (text_buffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
gtk_widget_show (dlg);
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg);
return run;
}
static void
thunar_apr_desktop_page_init (ThunarAprDesktopPage *desktop_page)
{
AtkRelationSet *relations;
PangoAttribute *attribute;
PangoAttrList *attr_list;
AtkRelation *relation;
AtkObject *object;
GtkWidget *table;
GtkWidget *label;
gtk_container_set_border_width (GTK_CONTAINER (desktop_page), 12);
/* allocate shared bold Pango attributes */
attr_list = pango_attr_list_new ();
attribute = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
attribute->start_index = 0;
attribute->end_index = -1;
pango_attr_list_insert (attr_list, attribute);
table = gtk_table_new (8, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
gtk_container_add (GTK_CONTAINER (desktop_page), table);
gtk_widget_show (table);
label = gtk_label_new (_("Description:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->description_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (desktop_page->description_entry, _("The generic name of the entry, for example \"Web Browser\" "
"in case of Firefox."));
g_signal_connect (G_OBJECT (desktop_page->description_entry), "activate", G_CALLBACK (thunar_apr_desktop_page_activated), desktop_page);
g_signal_connect (G_OBJECT (desktop_page->description_entry), "focus-out-event", G_CALLBACK (thunar_apr_desktop_page_focus_out_event), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->description_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->description_entry);
exo_binding_new (G_OBJECT (desktop_page->description_entry), "visible", G_OBJECT (label), "visible");
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (desktop_page->description_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
label = gtk_label_new (_("Command:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->command_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (desktop_page->command_entry, _("The program to execute, possibly with arguments."));
g_signal_connect (G_OBJECT (desktop_page->command_entry), "activate", G_CALLBACK (thunar_apr_desktop_page_activated), desktop_page);
g_signal_connect (G_OBJECT (desktop_page->command_entry), "focus-out-event", G_CALLBACK (thunar_apr_desktop_page_focus_out_event), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->command_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->command_entry);
exo_binding_new (G_OBJECT (desktop_page->command_entry), "visible", G_OBJECT (label), "visible");
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (desktop_page->command_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
label = gtk_label_new (_("Working Directory:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->path_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (desktop_page->path_entry, _("The working directory for the program."));
g_signal_connect (G_OBJECT (desktop_page->path_entry), "activate", G_CALLBACK (thunar_apr_desktop_page_activated), desktop_page);
g_signal_connect (G_OBJECT (desktop_page->path_entry), "focus-out-event", G_CALLBACK (thunar_apr_desktop_page_focus_out_event), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->path_entry, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->path_entry);
exo_binding_new (G_OBJECT (desktop_page->path_entry), "visible", G_OBJECT (label), "visible");
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (desktop_page->path_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
label = gtk_label_new (_("URL:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->url_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (desktop_page->url_entry, _("The URL to access."));
g_signal_connect (G_OBJECT (desktop_page->url_entry), "activate", G_CALLBACK (thunar_apr_desktop_page_activated), desktop_page);
g_signal_connect (G_OBJECT (desktop_page->url_entry), "focus-out-event", G_CALLBACK (thunar_apr_desktop_page_focus_out_event), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->url_entry, 1, 2, 3, 4, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->url_entry);
exo_binding_new (G_OBJECT (desktop_page->url_entry), "visible", G_OBJECT (label), "visible");
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (desktop_page->url_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
label = gtk_label_new (_("Comment:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->comment_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (desktop_page->comment_entry, _("Tooltip for the entry, for example \"View sites on the Internet\" "
"in case of Firefox. Should not be redundant with the name or the "
"description."));
g_signal_connect (G_OBJECT (desktop_page->comment_entry), "activate", G_CALLBACK (thunar_apr_desktop_page_activated), desktop_page);
g_signal_connect (G_OBJECT (desktop_page->comment_entry), "focus-out-event", G_CALLBACK (thunar_apr_desktop_page_focus_out_event), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->comment_entry, 1, 2, 4, 5, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->comment_entry);
exo_binding_new (G_OBJECT (desktop_page->comment_entry), "visible", G_OBJECT (label), "visible");
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (desktop_page->comment_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
/* add spacing between the entries and the options */
gtk_table_set_row_spacing (GTK_TABLE (table), 4, 24);
label = gtk_label_new (_("Options:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), attr_list);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7, GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (label);
desktop_page->snotify_button = gtk_check_button_new_with_mnemonic (_("Use _startup notification"));
gtk_widget_set_tooltip_text (desktop_page->snotify_button, _("Select this option to enable startup notification when the command "
"is run from the file manager or the menu. Not every application supports "
"startup notification."));
g_signal_connect (G_OBJECT (desktop_page->snotify_button), "toggled", G_CALLBACK (thunar_apr_desktop_page_toggled), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->snotify_button, 1, 2, 6, 7, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->snotify_button);
desktop_page->terminal_button = gtk_check_button_new_with_mnemonic (_("Run in _terminal"));
gtk_widget_set_tooltip_text (desktop_page->terminal_button, _("Select this option to run the command in a terminal window."));
g_signal_connect (G_OBJECT (desktop_page->terminal_button), "toggled", G_CALLBACK (thunar_apr_desktop_page_toggled), desktop_page);
gtk_table_attach (GTK_TABLE (table), desktop_page->terminal_button, 1, 2, 7, 8, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 3);
gtk_widget_show (desktop_page->terminal_button);
/* set Atk label relation for the buttons */
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
object = gtk_widget_get_accessible (desktop_page->snotify_button);
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
object = gtk_widget_get_accessible (desktop_page->terminal_button);
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
exo_binding_new (G_OBJECT (desktop_page->snotify_button), "visible", G_OBJECT (label), "visible");
/* release shared bold Pango attributes */
pango_attr_list_unref (attr_list);
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
gint response;
GwyPixmapLayer *layer;
GwyVectorLayer *vlayer;
GwySelection *selection;
gint row;
memset(&controls, 0, sizeof(FacetsControls));
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Mark"), RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer);
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = gwy_data_view_new(controls.fdata);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.fview),
layer);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview),
GWY_VECTOR_LAYER(vlayer));
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
label = gwy_label_new_header(gwy_sgettext("noun|Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(9, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
facets_invalidate(&controls);
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
}
}
bool area_edit_t::run() {
GtkWidget *vbox;
area_context_t context(*this,
gtk_dialog_new_with_buttons(_("Area editor"),
GTK_WINDOW(parent), GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
nullptr));
osm2go_platform::dialog_size_hint(context.dialog, osm2go_platform::MISC_DIALOG_HIGH);
context.warning = gtk_dialog_add_button(context.dialog, _("Warning"), GTK_RESPONSE_HELP);
gtk_button_set_image(GTK_BUTTON(context.warning),
gtk_image_new_from_icon_name("dialog-warning", GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(context.warning, "clicked",
G_CALLBACK(on_area_warning_clicked), &context);
/* ------------- fetch from map ------------------------ */
context.map.needs_redraw = false;
context.map.widget = OSM_GPS_MAP(g_object_new(OSM_TYPE_GPS_MAP,
"map-source", OSM_GPS_MAP_SOURCE_OPENSTREETMAP,
"proxy-uri", g_getenv("http_proxy"),
"auto-center", FALSE,
"tile-cache", nullptr,
nullptr));
osm_gps_map_osd_select_init(context.map.widget);
g_signal_connect_swapped(context.map.widget, "configure-event",
G_CALLBACK(on_map_configure), &context);
g_signal_connect(context.map.widget, "button-press-event",
G_CALLBACK(on_map_button_press_event), &context);
g_signal_connect(context.map.widget, "motion-notify-event",
G_CALLBACK(on_map_motion_notify_event), &context);
g_signal_connect(context.map.widget, "button-release-event",
G_CALLBACK(on_map_button_release_event), &context);
/* install handler for timed updates of the gps button */
osm2go_platform::Timer timer;
timer.restart(1, map_gps_update, &context);
context.map.start.rlon = context.map.start.rlat = NAN;
osm2go_platform::notebook_append_page(context.notebook, GTK_WIDGET(context.map.widget), _(TAB_LABEL_MAP));
/* ------------ direct min/max edit --------------- */
vbox = gtk_vbox_new(FALSE, 10);
GtkTable *table = GTK_TABLE(gtk_table_new(3, 4, FALSE)); // x, y
gtk_table_set_col_spacings(table, 10);
gtk_table_set_row_spacings(table, 5);
context.direct.minlat = pos_lat_entry_new(bounds.min.lat);
table_attach(table, context.direct.minlat, 0, 0);
GtkWidget *label = gtk_label_new(_("to"));
table_attach(table, label, 1, 0);
context.direct.maxlat = pos_lat_entry_new(bounds.max.lat);
table_attach(table, context.direct.maxlat, 2, 0);
context.direct.minlon = pos_lon_entry_new(bounds.min.lon);
table_attach(table, context.direct.minlon, 0, 1);
label = gtk_label_new(_("to"));
table_attach(table, label, 1, 1);
context.direct.maxlon = pos_lon_entry_new(bounds.max.lon);
table_attach(table, context.direct.maxlon, 2, 1);
/* setup this page */
g_signal_connect_swapped(context.direct.minlat, "changed",
G_CALLBACK(callback_modified_direct), &context);
g_signal_connect_swapped(context.direct.minlon, "changed",
G_CALLBACK(callback_modified_direct), &context);
g_signal_connect_swapped(context.direct.maxlat, "changed",
G_CALLBACK(callback_modified_direct), &context);
g_signal_connect_swapped(context.direct.maxlon, "changed",
G_CALLBACK(callback_modified_direct), &context);
/* --- hint --- */
label = gtk_label_new(_("(recommended min/max diff <0.03 degrees)"));
gtk_table_attach_defaults(table, label, 0, 3, 2, 3);
const GdkColor *color = osm2go_platform::invalid_text_color();
/* error label */
context.direct.error = gtk_label_new(nullptr);
gtk_widget_modify_fg(context.direct.error, GTK_STATE_NORMAL, color);
gtk_table_attach_defaults(table, context.direct.error, 0, 3, 3, 4);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0);
osm2go_platform::notebook_append_page(context.notebook, vbox, _(TAB_LABEL_DIRECT));
/* ------------- center/extent edit ------------------------ */
vbox = gtk_vbox_new(FALSE, 10);
table = GTK_TABLE(gtk_table_new(3, 5, FALSE)); // x, y
gtk_table_set_col_spacings(table, 10);
gtk_table_set_row_spacings(table, 5);
label = gtk_label_new(_("Center:"));
gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
gtk_table_attach_defaults(table, label, 0, 1, 0, 1);
context.extent.lat = pos_lat_entry_new(0.0);
gtk_table_attach_defaults(table, context.extent.lat, 1, 2, 0, 1);
context.extent.lon = pos_lon_entry_new(0.0);
gtk_table_attach_defaults(table, context.extent.lon, 2, 3, 0, 1);
gtk_table_set_row_spacing(table, 0, 10);
label = gtk_label_new(_("Width:"));
gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
gtk_table_attach_defaults(table, label, 0, 1, 1, 2);
context.extent.width = osm2go_platform::entry_new();
gtk_table_attach_defaults(table, context.extent.width, 1, 2, 1, 2);
label = gtk_label_new(_("Height:"));
gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
gtk_table_attach_defaults(table, label, 0, 1, 2, 3);
context.extent.height = osm2go_platform::entry_new();
gtk_table_attach_defaults(table,
context.extent.height, 1, 2, 2, 3);
std::vector<const char *> units(2);
units[0] = _("mi");
units[1] = _("km");
context.extent.mil_km = osm2go_platform::combo_box_new(_("Unit"), units, 1);
gtk_table_attach(table, context.extent.mil_km, 2, 3, 1, 3,
static_cast<GtkAttachOptions>(0), static_cast<GtkAttachOptions>(0),
0, 0);
/* setup this page */
extent_update(&context);
/* connect signals after inital update to avoid confusion */
g_signal_connect_swapped(context.extent.lat, "changed",
G_CALLBACK(callback_modified_extent), &context);
g_signal_connect_swapped(context.extent.lon, "changed",
G_CALLBACK(callback_modified_extent), &context);
g_signal_connect_swapped(context.extent.width, "changed",
G_CALLBACK(callback_modified_extent), &context);
g_signal_connect_swapped(context.extent.height, "changed",
G_CALLBACK(callback_modified_extent), &context);
g_signal_connect_swapped(context.extent.mil_km, "changed",
G_CALLBACK(callback_modified_unit), &context);
/* --- hint --- */
label = gtk_label_new(_("(recommended width/height < 2km/1.25mi)"));
gtk_table_attach_defaults(table, label, 0, 3, 3, 4);
/* error label */
context.extent.error = gtk_label_new(nullptr);
gtk_widget_modify_fg(context.extent.error, GTK_STATE_NORMAL, color);
gtk_table_attach_defaults(table, context.extent.error, 0, 3, 4, 5);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0);
osm2go_platform::notebook_append_page(context.notebook, vbox, _(TAB_LABEL_EXTENT));
#ifdef HAS_MAEMO_MAPPER
/* ------------- fetch from maemo mapper ------------------------ */
vbox = gtk_vbox_new(FALSE, 8);
context.mmapper.fetch = osm2go_platform::button_new_with_label(_("Get from Maemo Mapper"));
gtk_box_pack_start(GTK_BOX(vbox), context.mmapper.fetch, FALSE, FALSE, 0);
g_signal_connect_swapped(context.mmapper.fetch, "clicked",
G_CALLBACK(callback_fetch_mm_clicked), &context);
/* --- hint --- */
label = gtk_label_new(_("(recommended MM zoom level < 7)"));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
osm2go_platform::notebook_append_page(context.notebook, vbox, _("M.Mapper"));
#endif
/* ------------------------------------------------------ */
gtk_box_pack_start(context.dialog.vbox(), context.notebook, TRUE, TRUE, 0);
g_signal_connect(osm2go_platform::notebook_get_gtk_notebook(context.notebook),
"switch-page", G_CALLBACK(on_page_switch), &context);
gtk_widget_show_all(context.dialog.get());
area_main_update(&context);
bool ok = false;
int response;
do {
response = gtk_dialog_run(context.dialog);
if(GTK_RESPONSE_ACCEPT == response) {
if(area_warning(&context)) {
/* copy modified values back to given storage */
bounds = context.bounds;
ok = true;
break;
}
}
} while(response == GTK_RESPONSE_HELP || response == GTK_RESPONSE_ACCEPT);
return ok;
}
