static void
populate_action_arguments_grid (GtkWidget *grid,
GList *arguments,
GUPnPServiceActionArgDirection direction,
GUPnPServiceIntrospection *introspection)
{
GList *arg_node;
GtkWidget *last_aligner_grid = NULL;
g_assert (introspection != NULL);
prepare_action_arguments_grid (GTK_CONTAINER (grid),
direction,
arguments);
gtk_widget_set_size_request (dialog, 0, 0);
for (arg_node = arguments;
arg_node;
arg_node = arg_node->next) {
GUPnPServiceActionArgInfo *arg_info;
GtkWidget *aligner_grid;
GtkWidget *label;
GtkWidget *input_widget;
arg_info = (GUPnPServiceActionArgInfo *) arg_node->data;
/* First add the name */
/* GTK_ALIGN_START seems to have a bug in a size group:
* use a container for alignment */
aligner_grid = gtk_grid_new ();
gtk_grid_attach_next_to (GTK_GRID (grid),
aligner_grid,
last_aligner_grid,
GTK_POS_BOTTOM,
1, 1);
last_aligner_grid = aligner_grid;
label = gtk_label_new (arg_info->name);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_widget_set_vexpand (label, TRUE);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (aligner_grid), label,
0, 0, 1, 1);
gtk_size_group_add_widget (label_container_group,
aligner_grid);
gtk_widget_show_all (aligner_grid);
/* Then the input widget */
input_widget = create_widget_for_argument (arg_info,
introspection);
gtk_widget_set_hexpand (input_widget, TRUE);
gtk_grid_attach_next_to (GTK_GRID (grid),
input_widget,
aligner_grid,
GTK_POS_RIGHT,
1,1);
gtk_widget_show_all (input_widget);
}
}
static void
add_row (GtkGrid *grid,
GtkWidget *title,
GtkWidget *value,
gboolean contact_info)
{
/* Title */
gtk_grid_attach_next_to (grid, title, NULL, GTK_POS_BOTTOM, 1, 1);
gtk_misc_set_alignment (GTK_MISC (title), 1, 0.5);
gtk_style_context_add_class (gtk_widget_get_style_context (title),
GTK_STYLE_CLASS_DIM_LABEL);
gtk_widget_show (title);
/* Value */
gtk_grid_attach_next_to (grid, value, title, GTK_POS_RIGHT,
contact_info ? 2 : 1, 1);
gtk_widget_set_hexpand (value, TRUE);
if (GTK_IS_LABEL (value))
{
gtk_misc_set_alignment (GTK_MISC (value), 0, 0.5);
gtk_label_set_selectable (GTK_LABEL (value), TRUE);
}
gtk_widget_show (value);
if (contact_info)
{
g_object_set_data (G_OBJECT (title),
DATA_IS_CONTACT_INFO, (gpointer) TRUE);
g_object_set_data (G_OBJECT (value),
DATA_IS_CONTACT_INFO, (gpointer) TRUE);
}
}
static GtkWidget *
add_spin_and_label(struct gtk_common_data *mdata, GtkWidget *relative_to, const char *lbl_text)
{
GtkWidget *spin, *lbl;
spin = gtk_spin_button_new_with_range(-INT64_MAX, INT64_MAX, 0.0001);
if (!relative_to)
gtk_grid_attach(GTK_GRID(mdata->widget), spin, 0, 0, 20, 20);
else
gtk_grid_attach_next_to(GTK_GRID(mdata->widget), spin,
relative_to, GTK_POS_RIGHT, 20, 20);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0.0);
g_signal_connect(spin, "value-changed",
G_CALLBACK(spin_value_changed), mdata);
g_object_set_data(G_OBJECT(mdata->widget), lbl_text, spin);
gtk_widget_show(spin);
lbl = gtk_label_new(lbl_text);
gtk_grid_attach_next_to(GTK_GRID(mdata->widget), lbl, spin,
GTK_POS_TOP, 20, 20);
gtk_widget_show(lbl);
return spin;
}
int main(void)
{
GtkWidget *mainwin;
GtkWidget *grid;
gtk_init(NULL, NULL);
mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(mainwin), "Foreground Colors with CSS");
gtk_container_set_border_width(GTK_CONTAINER(mainwin), 12);
g_signal_connect(mainwin, "delete-event", G_CALLBACK(quit), NULL);
grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
gtk_container_add(GTK_CONTAINER(mainwin), grid);
button = gtk_button_new_with_label("Color Me!");
gtk_widget_set_hexpand(button, TRUE);
gtk_widget_set_halign(button, GTK_ALIGN_FILL);
gtk_widget_set_vexpand(button, TRUE);
gtk_widget_set_halign(button, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
button, NULL,
GTK_POS_BOTTOM, 1, 1);
foreground = gtk_color_button_new();
g_signal_connect(foreground, "color-set", G_CALLBACK(changeColor), NULL);
gtk_widget_set_hexpand(foreground, TRUE);
gtk_widget_set_halign(foreground, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
foreground, button,
GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid),
gtk_label_new("Foreground"), foreground,
GTK_POS_LEFT, 1, 1);
background = gtk_color_button_new();
g_signal_connect(background, "color-set", G_CALLBACK(changeColor), NULL);
gtk_widget_set_hexpand(background, TRUE);
gtk_widget_set_halign(background, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
background, foreground,
GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid),
gtk_label_new("Background"), background,
GTK_POS_LEFT, 1, 1);
gtk_widget_show_all(mainwin);
gtk_main();
return 0;
}
GtkWidget *create_button_with_stock_image(const gchar *text, const gchar *stock_id)
{
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *align;
hbox = gtk_hbox_new(FALSE, 2);
image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(text);
#if USE_GTK_GRID
gtk_grid_attach_next_to (GTK_BOX (hbox), label, image, GTK_POS_RIGHT, 1, 1);
#else
gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
#endif
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_add(GTK_CONTAINER(align), hbox);
button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button), align);
gtk_widget_show_all(button);
return button;
}
static int lua_register_selection(lua_State *L)
{
lua_settop(L,3);
dt_lib_module_t *self = lua_touserdata(L, lua_upvalueindex(1));
dt_lua_module_entry_push(L,"lib",self->plugin_name);
lua_getuservalue(L,-1);
const char* key = luaL_checkstring(L,1);
luaL_checktype(L,2,LUA_TFUNCTION);
lua_getfield(L,-1,"callbacks");
lua_pushstring(L,key);
lua_pushvalue(L,2);
lua_settable(L,-3);
GtkWidget* button = gtk_button_new_with_label(key);
const char * tooltip = lua_tostring(L,3);
if(tooltip) {
gtk_widget_set_tooltip_text(button, tooltip);
}
gtk_grid_attach_next_to(GTK_GRID(self->widget), button, NULL, GTK_POS_BOTTOM, 2, 1);
lua_callback_data * data = malloc(sizeof(lua_callback_data));
data->key = strdup(key);
data->self = self;
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(lua_button_clicked), data);
gtk_widget_show_all(self->widget);
return 0;
}
static void
ekiga_window_init_dialpad (EkigaWindow *mw)
{
GtkWidget *dialpad = NULL;
GtkWidget *grid = NULL;
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 18);
gtk_container_set_border_width (GTK_CONTAINER (grid), 18);
dialpad = ekiga_dialpad_new (mw->priv->accel);
gtk_widget_set_hexpand (dialpad, FALSE);
gtk_widget_set_vexpand (dialpad, FALSE);
gtk_widget_set_halign (dialpad, GTK_ALIGN_CENTER);
gtk_widget_set_valign (dialpad, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), dialpad, 0, 0, 1, 1);
g_signal_connect (dialpad, "button-clicked",
G_CALLBACK (dialpad_button_clicked_cb), mw);
mw->priv->entry = ekiga_window_uri_entry_new (mw);
gtk_widget_set_hexpand (dialpad, TRUE);
gtk_widget_set_vexpand (dialpad, TRUE);
gtk_widget_set_halign (mw->priv->entry, GTK_ALIGN_FILL);
gtk_widget_set_valign (mw->priv->entry, GTK_ALIGN_END);
gtk_grid_attach_next_to (GTK_GRID (grid), mw->priv->entry, dialpad,
GTK_POS_BOTTOM, 1, 1);
gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), grid, "dialpad");
gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
grid,
"icon-name", "input-dialpad-symbolic", NULL);
g_signal_connect (mw, "key-press-event",
G_CALLBACK (key_press_event_cb), mw);
}
static void
append_item (NemoImagePropertiesPage *page,
const char *name,
const char *value)
{
GtkWidget *name_label;
GtkWidget *label;
PangoAttrList *attrs;
name_label = gtk_label_new (name);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (name_label), attrs);
pango_attr_list_unref (attrs);
gtk_misc_set_alignment (GTK_MISC (name_label), 0, 0);
gtk_container_add (GTK_CONTAINER (page->details->grid), name_label);
gtk_widget_show (name_label);
if (value != NULL) {
label = gtk_label_new (value);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_grid_attach_next_to (GTK_GRID (page->details->grid), label,
name_label, GTK_POS_RIGHT,
1, 1);
gtk_widget_show (label);
}
}
static void
photos_properties_dialog_get_camera (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosPropertiesDialog *self;
g_autofree gchar *camera = NULL;
{
g_autoptr (GError) error = NULL;
camera = photos_camera_cache_get_camera_finish (PHOTOS_CAMERA_CACHE (source_object), res, &error);
if (error != NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to get camera: %s", error->message);
return;
}
}
/* Now we know that self has not been destroyed. */
self = PHOTOS_PROPERTIES_DIALOG (user_data);
if (camera != NULL)
{
GtkWidget *camera_data;
camera_data = gtk_label_new (camera);
gtk_widget_set_halign (camera_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), camera_data, self->camera_w, GTK_POS_RIGHT, 2, 1);
gtk_widget_show (camera_data);
}
}
static void
append_row_to_table (GtkWidget *table,
const gchar *key,
const gchar *value)
{
GtkWidget *key_label;
GtkWidget *value_label;
if (!value)
return;
key_label = gtk_label_new (NULL);
g_object_set (G_OBJECT (key_label), "xalign", 0.0, NULL);
gtk_label_set_markup (GTK_LABEL (key_label), key);
gtk_container_add (GTK_CONTAINER (table), key_label);
gtk_widget_show (key_label);
value_label = gtk_label_new (value);
g_object_set (G_OBJECT (value_label),
"xalign", 0.0,
"selectable", TRUE,
"ellipsize", PANGO_ELLIPSIZE_END,
"hexpand", TRUE,
NULL);
gtk_grid_attach_next_to (GTK_GRID (table),
value_label,
key_label,
GTK_POS_RIGHT,
1, 1);
gtk_widget_show (value_label);
}
struct gui *gui_alloc(const char *builder_file, struct world *w,
int ws_x, int ws_y)
{
struct gui *g;
/* struct gui */
g = (struct gui *)malloc(sizeof(struct gui));
if (!g)
return NULL;
/* builder */
g->builder = gtk_builder_new();
if (!gtk_builder_add_from_file(g->builder, builder_file, NULL))
return NULL;
/* GObjects */
g->window = GTK_WIDGET(gtk_builder_get_object(g->builder, "window"));
g->btn_quit = GTK_WIDGET(gtk_builder_get_object(g->builder, "btn_quit"));
g->btn_step = GTK_WIDGET(gtk_builder_get_object(g->builder, "btn_step"));
g->btn_pause = GTK_WIDGET(gtk_builder_get_object(g->builder, "btn_pause"));
g->grid = GTK_GRID(gtk_builder_get_object(g->builder, "grid"));
if (!(g->window && g->btn_quit && g->btn_step && g->btn_pause &&
g->grid)) {
errno = EINVAL;
return NULL;
}
/* drawing area */
g->drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(g->drawing_area, ws_x, ws_y);
gtk_widget_set_events(g->drawing_area,
gtk_widget_get_events(g->drawing_area) | GDK_BUTTON_PRESS_MASK);
gtk_grid_attach_next_to(g->grid, g->drawing_area, g->btn_quit,
GTK_POS_BOTTOM, 1, 1);
/* Signals */
g_signal_connect(g->window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(g->btn_quit, "clicked", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(g->btn_step, "clicked", G_CALLBACK(step_cb), g);
g_signal_connect(g->btn_pause, "clicked", G_CALLBACK(pause_cb), g);
g_signal_connect(g->drawing_area, "draw", G_CALLBACK(draw_cb), g);
g_signal_connect(g->drawing_area, "button-press-event", G_CALLBACK(mouse_btn_cb), g);
gtk_builder_connect_signals(g->builder, NULL);
if (!w) {
errno = EINVAL;
return NULL;
}
g->world = w;
g->cell_size.x = ws_x / world_get_sizex(g->world);
g->cell_size.y = ws_y / world_get_sizey(g->world);
g->run = false;
gtk_widget_show_all(g->window);
return g;
}
void new_view_horizontal(GObject *object, gpointer user_data)
{
struct _view *view = create_view();
chrome->views = g_list_append(chrome->views, view);
gtk_grid_attach_next_to(GTK_GRID(chrome->grid), view->view, chrome->selected_view->view,
GTK_POS_RIGHT, 1, 1);
chrome->selected_view = view;
gtk_widget_show_all(chrome->grid);
}
static void
gog_polynom_reg_curve_populate_editor (GogRegCurve *reg_curve, gpointer table)
{
GtkWidget *l, *w;
GogLinRegCurve *lin = GOG_LIN_REG_CURVE (reg_curve);
((GogRegCurveClass*) gog_polynom_reg_curve_parent_klass)->populate_editor (reg_curve, table);
l = gtk_label_new (_("Order:"));
gtk_misc_set_alignment (GTK_MISC (l), 0., 0.5);
gtk_label_set_justify (GTK_LABEL (l), GTK_JUSTIFY_LEFT);
gtk_widget_show (l);
gtk_grid_attach_next_to (table, l, NULL, GTK_POS_BOTTOM, 1, 1);
w = gtk_spin_button_new_with_range (2, 10, 1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 0);
gtk_widget_show (w);
gtk_grid_attach_next_to (table, w, l, GTK_POS_RIGHT, 1, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), lin->dims);
g_signal_connect (G_OBJECT (w), "value-changed", G_CALLBACK (order_changed_cb), lin);
}
static int lua_register_info(lua_State *L)
{
dt_lib_module_t *self = lua_touserdata(L, lua_upvalueindex(1));
dt_lua_module_entry_push(L,"lib",self->plugin_name);
lua_getuservalue(L,-1);
const char* key = luaL_checkstring(L,1);
luaL_checktype(L,2,LUA_TFUNCTION);
{
lua_getfield(L,-1,"callbacks");
lua_pushstring(L,key);
lua_pushvalue(L,2);
lua_settable(L,5);
lua_pop(L,1);
}
{
lua_getfield(L,-1,"values");
lua_pushstring(L,key);
lua_pushstring(L,"-");
lua_settable(L,5);
lua_pop(L,1);
}
{
GtkWidget *evb = gtk_event_box_new();
gtk_widget_set_name(evb, "brightbg");
GtkLabel *name = GTK_LABEL(gtk_label_new(key));
GtkLabel *value = GTK_LABEL(gtk_label_new("-"));
gtk_label_set_selectable(value, TRUE);
gtk_container_add(GTK_CONTAINER(evb), GTK_WIDGET(value));
gtk_widget_set_halign(GTK_WIDGET(name), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(name), NULL, GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(evb), GTK_WIDGET(name), GTK_POS_RIGHT, 1, 1);
gtk_widget_show_all(self->widget);
{
lua_getfield(L,-1,"widgets");
lua_pushstring(L,key);
lua_pushlightuserdata(L,value);
lua_settable(L,5);
lua_pop(L,1);
}
}
return 0;
}
void addInputSection(char *text, GtkGrid *grid, void (*entryChangedFuncPtr) (GtkEditable *editable, gpointer),
int col, int row, int* index) {
GtkGrid *childGrid;
GtkWidget *label;
GtkWidget *textBox;
childGrid = gtk_grid_new();
label = gtk_label_new_with_mnemonic(text);
textBox = gtk_entry_new();
if(entryChangedFuncPtr != NULL){
g_signal_connect(textBox, "changed", G_CALLBACK(entryChangedFuncPtr), index);
}
gtk_grid_attach_next_to(childGrid, label, NULL, GTK_POS_RIGHT,1,1);
gtk_grid_attach_next_to(childGrid, textBox, label, GTK_POS_RIGHT,1,1);
gtk_grid_attach(grid, childGrid, col, row, 1, 1);
gtk_widget_show(childGrid);
gtk_widget_show(textBox);
gtk_widget_show(label);
}
static GtkButton *
g_paste_settings_ui_panel_add_confirm_button (GPasteSettingsUiPanel *self,
const gchar *label,
GtkWidget *attach_to)
{
GtkWidget *button = gtk_button_new_with_label (label);
gtk_grid_attach_next_to (GTK_GRID (self), button, GTK_WIDGET (attach_to), GTK_POS_RIGHT, 1, 1);
return GTK_BUTTON (button);
}
static void _lib_property_add_to_gui(dt_lib_camera_property_t *prop, dt_lib_camera_t *lib)
{
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_grid_attach(lib->gui.main_grid, GTK_WIDGET(prop->label), 0, lib->gui.prop_end, 1, 1);
gtk_grid_attach_next_to(lib->gui.main_grid, GTK_WIDGET(hbox), GTK_WIDGET(prop->label), GTK_POS_RIGHT, 1, 1);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
gtk_widget_show_all(GTK_WIDGET(prop->label));
gtk_widget_show_all(GTK_WIDGET(hbox));
lib->gui.rows++;
lib->gui.prop_end++;
}
void SourceEditor::setupPreferencesEditor(GtkGrid *grid)
{
const PropertyTree &prefs =
Application::instance().preferences().child(TEXT_EDITOR);
GtkWidget *fold = gtk_check_button_new_with_mnemonic(
_("Fol_d structured text"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fold),
prefs.get<bool>(FOLD_STRUCTURED_TEXT));
g_signal_connect(fold, "toggled",
G_CALLBACK(onFoldToggled), NULL);
gtk_grid_attach_next_to(grid, fold, NULL,
GTK_POS_BOTTOM, 1, 1);
gtk_widget_show_all(fold);
}
static GtkWidget *
grid_attach_spin_button_with_label (GtkWidget *grid, const gchar* text_label, gint left, gint top)
{
GtkWidget *label;
GtkWidget *spin_button;
label = gtk_label_new_with_mnemonic (text_label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
spin_button = gtk_spin_button_new_with_range (0, 100, 0.01);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spin_button), 2);
gtk_entry_set_width_chars (GTK_ENTRY (spin_button), 6);
gtk_grid_attach (GTK_GRID (grid), label, left, top, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (grid), spin_button, label, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
return spin_button;
}
/**
* g_paste_settings_ui_panel_add_text_setting:
* @self: a #GPasteSettingsUiPanel instance
* @label: the label to display
* @value: the deafault value
* @on_value_changed: (closure user_data) (scope notified): the callback to call when the value changes
*
* Add a new text settings to the current pane
*
* Returns: (transfer none): the #GtkEntry we just added
*/
G_PASTE_VISIBLE GtkEntry *
g_paste_settings_ui_panel_add_text_setting (GPasteSettingsUiPanel *self,
const gchar *label,
const gchar *value,
GPasteTextCallback on_value_changed,
gpointer user_data)
{
GtkLabel *entry_label = g_paste_settings_ui_panel_add_label (self, label);
GtkWidget *entry = gtk_entry_new ();
GtkEntry *e = GTK_ENTRY (entry);
CALLBACK_DATA_DEFAULT (entry)
gtk_entry_set_text (e, value);
_data->signal = g_signal_connect (entry, "changed", G_CALLBACK (text_wrapper), data);
gtk_grid_attach_next_to (GTK_GRID (self), entry, GTK_WIDGET (entry_label), GTK_POS_RIGHT, 1, 1);
return e;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_metadata_view_t *d = (dt_lib_metadata_view_t *)g_malloc0(sizeof(dt_lib_metadata_view_t));
self->data = (void *)d;
_lib_metatdata_view_init_labels();
self->widget = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
// GtkWidget *last = NULL;
/* initialize the metadata name/value labels */
for(int k = 0; k < md_size; k++)
{
GtkWidget *evb = gtk_event_box_new();
gtk_widget_set_name(evb, "brightbg");
GtkLabel *name = GTK_LABEL(gtk_label_new(_md_labels[k]));
d->metadata[k] = GTK_LABEL(gtk_label_new("-"));
gtk_label_set_selectable(d->metadata[k], TRUE);
gtk_container_add(GTK_CONTAINER(evb), GTK_WIDGET(d->metadata[k]));
if(k == md_internal_filmroll)
{
// film roll jump to:
g_signal_connect(G_OBJECT(evb), "button-press-event", G_CALLBACK(_filmroll_clicked), NULL);
}
gtk_widget_set_halign(GTK_WIDGET(name), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(d->metadata[k]), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(name), 0, k, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(evb), GTK_WIDGET(name), GTK_POS_RIGHT, 1, 1);
}
/* lets signup for mouse over image change signals */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
G_CALLBACK(_mouse_over_image_callback), self);
/* lets signup for develop image changed signals */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED,
G_CALLBACK(_mouse_over_image_callback), self);
/* signup for develop initialize to update info of current
image in darkroom when enter */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_INITIALIZE,
G_CALLBACK(_mouse_over_image_callback), self);
}
/**
* g_paste_settings_ui_panel_add_range_setting:
* @self: a #GPasteSettingsUiPanel instance
* @label: the label to display
* @value: the deafault value
* @min: the minimal authorized value
* @max: the maximal authorized value
* @step: the step between proposed values
* @on_value_changed: (closure user_data) (scope notified): the callback to call when the value changes
*
* Add a new boolean settings to the current pane
*
* Returns: (transfer none): the #GtkSpinButton we just added
*/
G_PASTE_VISIBLE GtkSpinButton *
g_paste_settings_ui_panel_add_range_setting (GPasteSettingsUiPanel *self,
const gchar *label,
gdouble value,
gdouble min,
gdouble max,
gdouble step,
GPasteRangeCallback on_value_changed,
gpointer user_data)
{
GtkLabel *button_label = g_paste_settings_ui_panel_add_label (self, label);
GtkWidget *button = gtk_spin_button_new_with_range (min, max, step);
GtkSpinButton *b = GTK_SPIN_BUTTON (button);
CALLBACK_DATA_DEFAULT (button)
gtk_spin_button_set_value (b, value);
_data->signal = g_signal_connect (button, "value-changed", G_CALLBACK (range_wrapper), data);
gtk_grid_attach_next_to (GTK_GRID (self), button, GTK_WIDGET (button_label), GTK_POS_RIGHT, 1, 1);
return b;
}
void ask_node_ip_address( GtkWidget *w,
gpointer data )
{
gchar addrstr[64];
gulong myaddr = ntohl(node_ip_addr);
GtkWidget *dialog, *hbox, *label, *address;
sprintf(addrstr, "%ld.%ld.%ld.%ld",
(myaddr>>24)&0xff, (myaddr>>16)&0xff,
(myaddr>>8)&0xff, (myaddr)&0xff);
dialog = gtk_dialog_new_with_buttons (_("Address of the communication node"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
label = gtk_label_new(_("IP address:"));
address = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(address), addrstr);
#if (GTKVER == 3)
hbox = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
gtk_grid_attach(GTK_GRID(hbox), label, 0, 0, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(hbox), address, label, GTK_POS_RIGHT, 1, 1);
#else
hbox = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
gtk_box_pack_start_defaults(GTK_BOX(hbox), address);
#endif
if (connection_ok && node_ip_addr == 0) {
gulong myaddr = ntohl(tmp_node_addr);
g_snprintf(addrstr, sizeof(addrstr), "%s: %ld.%ld.%ld.%ld", _("(Connection OK)"),
(myaddr>>24)&0xff, (myaddr>>16)&0xff,
(myaddr>>8)&0xff, (myaddr)&0xff);
label = gtk_label_new(addrstr);
} else if (connection_ok)
static void
photos_properties_dialog_location_reverse_resolve (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosPropertiesDialog *self;
g_autoptr (GeocodePlace) place = NULL;
GeocodeReverse *reverse = GEOCODE_REVERSE (source_object);
GtkWidget *location_data;
const gchar *location_area;
const gchar *location_country;
const gchar *location_town;
g_autofree gchar *location_str = NULL;
{
g_autoptr (GError) error = NULL;
place = geocode_reverse_resolve_finish (reverse, res, &error);
if (error != NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to resolve latitude and longitude: %s", error->message);
goto out;
}
}
self = PHOTOS_PROPERTIES_DIALOG (user_data);
location_area = geocode_place_get_area (place);
location_town = geocode_place_get_town (place);
location_country = geocode_place_get_country (place);
location_str = g_strdup_printf ("%s, %s, %s", location_area, location_town, location_country);
location_data = gtk_label_new (location_str);
gtk_widget_set_halign (location_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), location_data, self->location_w, GTK_POS_RIGHT, 2, 1);
gtk_widget_show (location_data);
out:
return;
}
static void
simple_grid (void)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *test1, *test2, *test3, *test4, *test5, *test6;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Orientation");
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
g_signal_connect (window, "button-press-event", G_CALLBACK (toggle_orientation), grid);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
test1 = test_widget ("1", "red");
gtk_container_add (GTK_CONTAINER (grid), test1);
test2 = test_widget ("2", "green");
gtk_container_add (GTK_CONTAINER (grid), test2);
test3 = test_widget ("3", "blue");
gtk_container_add (GTK_CONTAINER (grid), test3);
test4 = test_widget ("4", "green");
gtk_grid_attach (GTK_GRID (grid), test4, 0, 1, 1, 1);
gtk_widget_set_vexpand (test4, TRUE);
test5 = test_widget ("5", "blue");
gtk_grid_attach_next_to (GTK_GRID (grid), test5, test4, GTK_POS_RIGHT, 2, 1);
test6 = test_widget ("6", "yellow");
gtk_grid_attach (GTK_GRID (grid), test6, -1, 0, 1, 2);
gtk_widget_set_hexpand (test6, TRUE);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), 0, -1) == NULL);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), 0, 0) == test1);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), 1, 0) == test2);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), 0, 1) == test4);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), -1, 0) == test6);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), -1, 1) == test6);
g_assert (gtk_grid_get_child_at (GTK_GRID (grid), -1, 2) == NULL);
gtk_widget_show_all (window);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
void module_setup_window_create (GtkButton *button, gpointer data_hime_setup_window_type_utility)
{
gboolean bWriteMode = TRUE;
chewing_config_open (bWriteMode);
chewing_config_load (&g_chewingConfig);
if (hime_chewing_window)
{
gtk_window_present (GTK_WINDOW (hime_chewing_window));
return;
}
hime_chewing_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (data_hime_setup_window_type_utility)
gtk_window_set_type_hint(GTK_WINDOW(hime_chewing_window), GDK_WINDOW_TYPE_HINT_UTILITY);
/* main setup win setting */
gtk_window_set_position (GTK_WINDOW (hime_chewing_window),
GTK_WIN_POS_MOUSE);
gtk_window_set_has_resize_grip (GTK_WINDOW (hime_chewing_window), FALSE);
g_signal_connect (G_OBJECT (hime_chewing_window), "delete_event",
G_CALLBACK (cb_close_window),
NULL);
gtk_window_set_title (GTK_WINDOW (hime_chewing_window),
_("新酷音設定"));
gtk_container_set_border_width (GTK_CONTAINER (hime_chewing_window), 1);
vbox_top = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (hime_chewing_window), vbox_top);
// cand per page
g_pHBoxCandPerPage = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxCandPerPage, TRUE, TRUE, 1);
g_pLabelCandPerPage = gtk_label_new (_("每頁候選字數"));
gtk_box_pack_start (GTK_BOX (g_pHBoxCandPerPage), g_pLabelCandPerPage, TRUE, TRUE, 0);
g_pGtkAdj = (GtkAdjustment *)gtk_adjustment_new (g_chewingConfig.candPerPage, 1, 10, 1.0, 1.0, 0.0);
g_pSpinButtonCandPerPage = gtk_spin_button_new (g_pGtkAdj, 0, 0);
gtk_box_pack_start (GTK_BOX (g_pHBoxCandPerPage), g_pSpinButtonCandPerPage, FALSE, FALSE, 0);
// space as selection
g_pHBoxSpaceAsSelection = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxSpaceAsSelection, TRUE, TRUE, 1);
g_pCheckButtonSpaceAsSelection = gtk_check_button_new_with_label(_("空白鍵選字"));
gtk_box_pack_start (GTK_BOX (g_pHBoxSpaceAsSelection), g_pCheckButtonSpaceAsSelection, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonSpaceAsSelection), g_chewingConfig.bSpaceAsSelection);
// esc clean buf
g_pHBoxEscCleanAllBuf = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxEscCleanAllBuf, TRUE, TRUE, 1);
g_pCheckButtonEscCleanAllBuf = gtk_check_button_new_with_label (_("ESC 鍵清空緩衝區"));
gtk_box_pack_start (GTK_BOX (g_pHBoxEscCleanAllBuf), g_pCheckButtonEscCleanAllBuf, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonEscCleanAllBuf), g_chewingConfig.bEscCleanAllBuf);
// auto shift cursor
g_pHBoxAutoShiftCur = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxAutoShiftCur, TRUE, TRUE, 1);
g_pCheckButtonAutoShiftCur = gtk_check_button_new_with_label (_("選字完畢自動跳字"));
gtk_box_pack_start (GTK_BOX (g_pHBoxAutoShiftCur), g_pCheckButtonAutoShiftCur, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonAutoShiftCur), g_chewingConfig.bAutoShiftCur);
// add phrase forward
g_pHBoxAddPhraseForward = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxAddPhraseForward, TRUE, TRUE, 1);
g_pCheckButtonAddPhraseForward = gtk_check_button_new_with_label (_("向後加詞"));
gtk_box_pack_start (GTK_BOX (g_pHBoxAddPhraseForward), g_pCheckButtonAddPhraseForward, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonAddPhraseForward), g_chewingConfig.bAddPhraseForward);
// cancel & ok buttons
hbox_cancel_ok = gtk_hbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok , FALSE, FALSE, 5);
button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gboolean button_order;
g_object_get(gtk_settings_get_default(), "gtk-alternative-button-order", &button_order, NULL);
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
button_ok = gtk_button_new_from_stock (GTK_STOCK_OK);
#if !GTK_CHECK_VERSION(2,91,2)
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
#else
if (button_order)
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1);
else
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1);
#endif
g_signal_connect (G_OBJECT (button_cancel), "clicked",
G_CALLBACK (cb_close_window),
G_OBJECT (hime_chewing_window));
g_signal_connect (G_OBJECT (button_ok), "clicked",
G_CALLBACK (cb_update_setting),
G_OBJECT (hime_chewing_window));
gtk_widget_show_all (hime_chewing_window);
}
void
lorem_ipsum_dialog(Tbfwin * bfwin)
{
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget *child, *dialog, *grid, *spin1, *spin2, *combo;
#else
GtkWidget *dialog, *spin1, *spin2, *combo, *table;
#endif
gint result, i;
GList *poplist;
gchar *command;
dialog = gtk_dialog_new_with_buttons(_("Lorem Ipsum generator"),
GTK_WINDOW(bfwin->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
#if GTK_CHECK_VERSION(3,0,0)
grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
gtk_container_set_border_width(GTK_CONTAINER(grid), 6);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), grid, FALSE, FALSE, 0);
spin1 = dialog_spin_button_new(0, 5000, 1);
gtk_container_add(GTK_CONTAINER(grid), spin1);
gtk_grid_insert_column(GTK_GRID(grid), 0);
gtk_grid_attach(GTK_GRID(grid), dialog_mnemonic_label_new(_("Number of _paragraphs:"), spin1), 0, 0, 1,
1);
spin2 = dialog_spin_button_new(0, 5000, 0);
gtk_grid_attach_next_to(GTK_GRID(grid), spin2, spin1, GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), dialog_mnemonic_label_new(_("Number of _sentences:"), spin2),
spin2, GTK_POS_LEFT, 1, 1);
poplist = list_from_arglist(FALSE, _("Insert plain text"), _("Insert in <li>"), _("Insert in <p>"), NULL);
combo = combobox_with_popdown(NULL, poplist, FALSE);
child = gtk_grid_get_child_at(GTK_GRID(grid), 0, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), combo, child, GTK_POS_BOTTOM, 2, 1);
g_list_free(poplist);
gtk_grid_insert_next_to(GTK_GRID(grid), combo, GTK_POS_BOTTOM);
#else
table = dialog_table_in_vbox_defaults(3, 2, 6, gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
spin1 = dialog_spin_button_in_table(0, 5000, 1, table, 1, 2, 0, 1);
dialog_mnemonic_label_in_table(_("Number of paragraphs"), spin1, table, 0, 1, 0, 1);
spin2 = dialog_spin_button_in_table(0, 5000, 0, table, 1, 2, 1, 2);
dialog_mnemonic_label_in_table(_("Number of sentences"), spin2, table, 0, 1, 1, 2);
poplist = list_from_arglist(FALSE, _("Insert plain text"), _("Insert in <li>"), _("Insert in <p>"), NULL);
combo = combobox_with_popdown(NULL, poplist, FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), combo, 0, 2, 2, 3);
g_list_free(poplist);
#endif
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
case GTK_RESPONSE_ACCEPT:
i = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
#ifdef WIN32
command = g_strdup_printf("python " PKGDATADIR "/lorem-ipsum-generator -l -p %d -s %d %s|",
(gint) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin1)),
(gint) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin2)),
i == 0 ? "" : (i == 1 ? "-f html-li" : "-f html-p")
);
#else
command = g_strdup_printf(PKGDATADIR "/lorem-ipsum-generator -l -p %d -s %d %s|",
(gint) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin1)),
(gint) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin2)),
i == 0 ? "" : (i == 1 ? "-f html-li" : "-f html-p")
);
#endif
custom_command(bfwin, command, (CustomCommandCallback) lorem_ipsum_command_callback, NULL);
g_free(command);
break;
default:
break;
}
gtk_widget_destroy(dialog);
}
void
jsbeautify_dialog(Tbfwin * bfwin)
{
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget *dialog, *grid, *hbox, *inselection, *usetabs, *tabsize, *nopreservenewline, *jslinthappy,
*unescape_encoded_chars;
#else
GtkWidget *dialog, *table, *inselection, *usetabs, *tabsize, *nopreservenewline, *jslinthappy,
*unescape_encoded_chars;
#endif
gint result, begin, end;
gchar *command;
dialog = gtk_dialog_new_with_buttons(_("Javascript Beautify"),
GTK_WINDOW(bfwin->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
#if GTK_CHECK_VERSION(3,0,0)
grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
gtk_container_set_border_width(GTK_CONTAINER(grid), 6);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), grid, FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
tabsize = dialog_spin_button_labeled(1, 99, 3, _("_Indent size:"), hbox, 12);
gtk_container_add(GTK_CONTAINER(grid), hbox);
usetabs = dialog_check_button_new(_("Use _tabs to indent, not spaces"), TRUE);
gtk_grid_attach_next_to(GTK_GRID(grid), usetabs, hbox, GTK_POS_BOTTOM, 1, 1);
nopreservenewline = dialog_check_button_new(_("Do not _preserve existing line breaks"), FALSE);
gtk_grid_attach_next_to(GTK_GRID(grid), nopreservenewline, usetabs, GTK_POS_BOTTOM, 1, 1);
jslinthappy = dialog_check_button_new(_("More _jslint-compatible output"), FALSE);
gtk_grid_attach_next_to(GTK_GRID(grid), jslinthappy, nopreservenewline, GTK_POS_BOTTOM, 1, 1);
unescape_encoded_chars =
dialog_check_button_new(_("_Decode printable chars encoded in \\\\xNN notation"), FALSE);
gtk_grid_attach_next_to(GTK_GRID(grid), unescape_encoded_chars, jslinthappy, GTK_POS_BOTTOM, 1, 1);
/* TODO: Is this a bug? Altering the option doesn't change anything */
if (doc_get_selection(DOCUMENT(bfwin->current_document), &begin, &end)) {
inselection = dialog_check_button_new(_("Beautify only in _selection"), TRUE);
gtk_grid_attach_next_to(GTK_GRID(grid), inselection, unescape_encoded_chars, GTK_POS_BOTTOM, 1, 1);
} else {
begin = 0;
end = -1;
}
#else
table = dialog_table_in_vbox_defaults(3, 2, 6, gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
if (doc_get_selection(DOCUMENT(bfwin->current_document), &begin, &end)) {
inselection = dialog_check_button_in_table(_("Beautify only in _selection"), TRUE, table, 0, 2, 0, 1);
} else {
begin = 0;
end = -1;
}
usetabs = dialog_check_button_in_table(_("Use _tabs to indent, not spaces"), TRUE, table, 0, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("_Indent size")), 0, 1, 2, 3);
tabsize = dialog_spin_button_in_table(1, 99, 3, table, 1, 2, 2, 3);
nopreservenewline =
dialog_check_button_in_table(_("Do not _preserve existing line breaks"), FALSE, table, 0, 2, 3, 4);
jslinthappy = dialog_check_button_in_table(_("More _jslint-compatible output"), FALSE, table, 0, 2, 4, 5);
unescape_encoded_chars =
dialog_check_button_in_table(_("_Decode printable chars encoded in \\\\xNN notation"), FALSE, table, 0,
2, 5, 6);
#endif
/* in selection or all text
-s, --indent-size=NUMBER indentation size. (default 4).
-c, --indent-char=CHAR character to indent with. (default space).
-t, --indent-with-tabs Indent with tabs, overrides -s and -c
-d, --disable-preserve-newlines do not preserve existing line breaks.
-j, --jslint-happy more jslint-compatible output
-b, --brace-style=collapse brace style (collapse, expand, end-expand)
-k, --keep-array-indentation keep array indentation.
-o, --outfile=FILE specify a file to output to (default stdout)
-f, --keep-function-indentation Do not re-indent function bodies defined in var lines.
-x, --unescape-strings Decode printable chars encoded in \\xNN notation. */
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
case GTK_RESPONSE_ACCEPT:
#ifdef WIN32
command = g_strdup_printf("|python " PKGDATADIR "/jsbeautify %s -s %d %s %s %s -|",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(usetabs)) ? "-t" : "",
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tabsize)),
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nopreservenewline)) ? "-d" :
"",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(jslinthappy)) ? "-j" : "",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(unescape_encoded_chars)) ?
"-x" : "");
#else
command = g_strdup_printf("|" PKGDATADIR "/jsbeautify %s -s %d %s %s %s -|",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(usetabs)) ? "-t" : "",
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tabsize)),
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nopreservenewline)) ? "-d" :
"",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(jslinthappy)) ? "-j" : "",
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(unescape_encoded_chars)) ?
"-x" : "");
#endif
filter_command(bfwin, command, begin, end);
g_free(command);
break;
default:
break;
}
gtk_widget_destroy(dialog);
}
void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
{
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *text;
GtkWidget *button;
GSList *tmp;
int list_count = 0;
int combo_count = 0;
int i = 0;
zen_data = data;
builder = zenity_util_load_ui_file("zenity_forms_dialog", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals(builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
g_signal_connect (G_OBJECT(dialog), "response",
G_CALLBACK (zenity_forms_dialog_response), forms_data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
text = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_text"));
if (forms_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (forms_data->dialog_text));
grid = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_grid"));
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
GtkWidget *label;
gchar **values = g_strsplit_set (zenity_value->option_value, "|", 2);
gchar *label_text = values[0];
gchar *prefill_text = values[1];
label = gtk_label_new(label_text);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid),
label,
0, i,
1, 1);
switch(zenity_value->type)
{
case ZENITY_FORMS_ENTRY:
zenity_value->forms_widget = gtk_entry_new();
if (prefill_text) {
gtk_entry_set_text(GTK_ENTRY(zenity_value->forms_widget),
prefill_text);
}
break;
case ZENITY_FORMS_PASSWORD:
zenity_value->forms_widget = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(zenity_value->forms_widget),
FALSE);
break;
case ZENITY_FORMS_CALENDAR:
zenity_value->forms_widget = gtk_calendar_new();
break;
case ZENITY_FORMS_LIST:
zenity_value->forms_widget = zenity_forms_create_and_fill_list (forms_data, list_count,
zenity_value->option_value);
list_count++;
break;
case ZENITY_FORMS_COMBO:
zenity_value->forms_widget = zenity_forms_create_and_fill_combo (forms_data, combo_count);
combo_count++;
break;
default:
zenity_value->forms_widget = gtk_entry_new();
break;
}
g_strfreev(values);
gtk_grid_attach_next_to (GTK_GRID (grid),
GTK_WIDGET (zenity_value->forms_widget),
label,
GTK_POS_RIGHT,
1, 1);
i++;
}
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
gtk_main();
}
