/**
* gimp_grid_attach_aligned:
* @grid: The #GtkGrid the widgets will be attached to.
* @left: The column to start with.
* @top: The row to attach the widgets.
* @label_text: The text for the #GtkLabel which will be attached left of
* the widget.
* @xalign: The horizontal alignment of the #GtkLabel.
* @yalign: The vertical alignment of the #GtkLabel.
* @widget: The #GtkWidget to attach right of the label.
* @columns: The number of columns the widget will use.
*
* Note that the @label_text can be %NULL and that the widget will be
* attached starting at (@column + 1) in this case, too.
*
* Returns: The created #GtkLabel.
**/
GtkWidget *
gimp_grid_attach_aligned (GtkGrid *grid,
gint left,
gint top,
const gchar *label_text,
gfloat xalign,
gfloat yalign,
GtkWidget *widget,
gint columns)
{
GtkWidget *label = NULL;
if (label_text)
{
GtkWidget *mnemonic_widget;
label = gtk_label_new_with_mnemonic (label_text);
gtk_label_set_xalign (GTK_LABEL (label), xalign);
gtk_label_set_yalign (GTK_LABEL (label), yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_grid_attach (grid, label, left, top, 1, 1);
gtk_widget_show (label);
mnemonic_widget = find_mnemonic_widget (widget, 0);
if (mnemonic_widget)
gtk_label_set_mnemonic_widget (GTK_LABEL (label), mnemonic_widget);
}
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (grid, widget, left + 1, top, columns, 1);
gtk_widget_show (widget);
return label;
}
static void
caja_x_content_bar_init (CajaXContentBar *bar)
{
GtkWidget *hbox;
bar->priv = CAJA_X_CONTENT_BAR_GET_PRIVATE (bar);
hbox = GTK_WIDGET (bar);
bar->priv->label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (bar->priv->label), PANGO_ELLIPSIZE_END);
gtk_orientable_set_orientation (GTK_ORIENTABLE (bar), GTK_ORIENTATION_HORIZONTAL);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (bar->priv->label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (bar->priv->label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (bar), bar->priv->label, TRUE, TRUE, 0);
bar->priv->button = gtk_button_new ();
gtk_box_pack_end (GTK_BOX (hbox), bar->priv->button, FALSE, FALSE, 0);
g_signal_connect (bar->priv->button,
"clicked",
G_CALLBACK (button_clicked_callback),
bar);
}
static gboolean
gimp_message_box_update (gpointer data)
{
GimpMessageBox *box = data;
gchar *message;
box->idle_id = 0;
message = g_strdup_printf (ngettext ("Message repeated once.",
"Message repeated %d times.",
box->repeat),
box->repeat);
if (box->label[2])
{
gtk_label_set_text (GTK_LABEL (box->label[2]), message);
}
else
{
GtkWidget *label = box->label[2] = gtk_label_new (message);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_STYLE, PANGO_STYLE_OBLIQUE,
-1);
gtk_box_pack_end (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
g_free (message);
return G_SOURCE_REMOVE;
}
static void
open_cb (GtkWidget *w, gpointer d)
{
GtkWidget *dlg, *cnt, *lbl, *entry;
dlg = gtk_dialog_new_with_buttons (_("Open URI"),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_default_size (GTK_WINDOW (dlg), 350, -1);
cnt = gtk_dialog_get_content_area (GTK_DIALOG (dlg));
lbl = gtk_label_new (_("Enter URI or file name:"));
gtk_label_set_xalign (GTK_LABEL (lbl), 0);
gtk_widget_show (lbl);
gtk_box_pack_start (GTK_BOX (cnt), lbl, TRUE, FALSE, 2);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "gtk-directory");
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (cnt), entry, TRUE, FALSE, 2);
g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (select_file_cb), NULL);
g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (do_open_cb), dlg);
if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_ACCEPT)
load_uri (gtk_entry_get_text (GTK_ENTRY (entry)));
gtk_widget_destroy (dlg);
}
static void
gimp_perspective_tool_dialog (GimpTransformTool *tr_tool)
{
GimpPerspectiveTool *perspective = GIMP_PERSPECTIVE_TOOL (tr_tool);
GtkWidget *frame;
GtkWidget *table;
gint x, y;
frame = gimp_frame_new (_("Transformation Matrix"));
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), frame,
FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
{
GtkWidget *label = gtk_label_new (" ");
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_label_set_width_chars (GTK_LABEL (label), 12);
gtk_table_attach (GTK_TABLE (table), label,
x, x + 1, y, y + 1, GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (label);
perspective->label[y][x] = label;
}
}
void
eel_gtk_message_dialog_set_details_label (GtkMessageDialog *dialog,
const gchar *details_text)
{
GtkWidget *content_area, *expander, *label;
content_area = gtk_message_dialog_get_message_area (dialog);
expander = gtk_expander_new_with_mnemonic (_("Show more _details"));
gtk_expander_set_spacing (GTK_EXPANDER (expander), 6);
label = gtk_label_new (details_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_container_add (GTK_CONTAINER (expander), label);
gtk_box_pack_start (GTK_BOX (content_area), expander, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (expander);
}
/* Function taken from gtkprintunixdialog.c */
static GtkWidget *
photos_print_setup_wrap_in_frame (const gchar *label, GtkWidget *child)
{
GtkWidget *frame;
GtkWidget *label_widget;
gchar *bold_text;
label_widget = gtk_label_new ("");
gtk_label_set_xalign (GTK_LABEL (label_widget), 0.0);
gtk_widget_show (label_widget);
bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
g_free (bold_text);
frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
gtk_widget_set_margin_start (child, 12);
gtk_widget_set_halign (child, GTK_ALIGN_FILL);
gtk_widget_set_valign (child, GTK_ALIGN_FILL);
gtk_box_pack_start (GTK_BOX (frame), child, FALSE, FALSE, 0);
gtk_widget_show (frame);
return frame;
}
/* Hack to make the plugin-provided editor widget fit in better with
* the control center by changing
*
* Foo: [__________]
* Bar baz: [__________]
*
* to
*
* Foo [__________]
* Bar baz [__________]
*/
static void
vpn_gnome3ify_editor (GtkWidget *widget)
{
if (GTK_IS_CONTAINER (widget)) {
GList *children, *iter;
children = gtk_container_get_children (GTK_CONTAINER (widget));
for (iter = children; iter; iter = iter->next)
vpn_gnome3ify_editor (iter->data);
g_list_free (children);
} else if (GTK_IS_LABEL (widget)) {
const char *text;
gfloat xalign;
char *newtext;
int len;
xalign = gtk_label_get_xalign (GTK_LABEL (widget));
if (xalign != 0.0)
return;
text = gtk_label_get_text (GTK_LABEL (widget));
len = strlen (text);
if (len < 2 || text[len - 1] != ':')
return;
newtext = g_strndup (text, len - 1);
gtk_label_set_text (GTK_LABEL (widget), newtext);
g_free (newtext);
gtk_label_set_xalign (GTK_LABEL (widget), 1.0);
}
}
static void
add_new_filechooser_button (const gchar *mnemonic,
const gchar *chooser_title,
GtkFileChooserAction action,
GtkWidget *group_box,
GtkSizeGroup *label_group)
{
GtkWidget *hbox, *label, *chooser, *button;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox);
label = gtk_label_new_with_mnemonic (mnemonic);
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label);
chooser = gtk_file_chooser_button_new (g_strconcat(chooser_title,
" - testfilechooserbutton", NULL),
action);
gtk_widget_set_hexpand (chooser, TRUE);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button);
}
static gboolean
gimp_help_menu_item_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip)
{
GtkWidget *vbox;
GtkWidget *label;
gchar *text;
gboolean use_markup = TRUE;
text = gtk_widget_get_tooltip_markup (widget);
if (! text)
{
text = gtk_widget_get_tooltip_text (widget);
use_markup = FALSE;
}
if (! text)
return FALSE;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
label = gtk_label_new (text);
gtk_label_set_use_markup (GTK_LABEL (label), use_markup);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
g_free (text);
label = gtk_label_new (_("Press F1 for more help"));
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_tooltip_set_custom (tooltip, vbox);
return TRUE;
}
void GtkLabel_::set_xalign(Php::Parameters ¶meters)
{
double d_xalign = parameters[0];
gfloat xalign = (float)d_xalign;
gtk_label_set_xalign (GTK_LABEL(instance), xalign);
}
void label_align_text(GtkLabel *label, gfloat xalign, gfloat yalign)
{
gtk_label_set_line_wrap(label, TRUE);
gtk_label_set_justify(label, GTK_JUSTIFY_LEFT);
#if (GTK_MAJOR_VERSION > 3) || (GTK_MINOR_VERSION >= 16)
if(xalign >= 0)
gtk_label_set_xalign(label, xalign);
if(yalign >= 0)
gtk_label_set_xalign(label, yalign);
#else
/* deprecated at 3.14, but above only implemented at 3.16 */
if(xalign < 0)
gtk_misc_get_alignment(GTK_MISC(label), &xalign, NULL);
if(yalign < 0)
gtk_misc_get_alignment(GTK_MISC(label), NULL, &yalign);
gtk_misc_set_alignment(GTK_MISC(label), xalign, yalign);
#endif
}
/********************************************************************\
* Sets the alignament of a Label Widget, GTK3 version specific. *
* *
* Args: widget - the label widget to set alignment on *
* xalign - x alignment *
* yalign - y alignment *
* Returns: nothing *
\********************************************************************/
void
gnc_label_set_alignment (GtkWidget *widget, gfloat xalign, gfloat yalign)
{
#if GTK_CHECK_VERSION(3,16,0)
gtk_label_set_xalign (GTK_LABEL (widget), xalign);
gtk_label_set_yalign (GTK_LABEL (widget), yalign);
#else
gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign);
#endif
}
void align_label_left(GtkLabel *label)
{
#if GTK_CHECK_VERSION(3,16,0)
gtk_label_set_xalign(label, 0.0);
#elif GTK_CHECK_VERSION(3,14,0)
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
#else
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
#endif
}
/**
* gimp_table_attach_aligned:
* @table: The #GtkTable the widgets will be attached to.
* @column: The column to start with.
* @row: The row to attach the widgets.
* @label_text: The text for the #GtkLabel which will be attached left of
* the widget.
* @xalign: The horizontal alignment of the #GtkLabel.
* @yalign: The vertical alignment of the #GtkLabel.
* @widget: The #GtkWidget to attach right of the label.
* @colspan: The number of columns the widget will use.
* @left_align: %TRUE if the widget should be left-aligned.
*
* Note that the @label_text can be %NULL and that the widget will be
* attached starting at (@column + 1) in this case, too.
*
* Returns: The created #GtkLabel.
**/
GtkWidget *
gimp_table_attach_aligned (GtkTable *table,
gint column,
gint row,
const gchar *label_text,
gfloat xalign,
gfloat yalign,
GtkWidget *widget,
gint colspan,
gboolean left_align)
{
GtkWidget *label = NULL;
if (label_text)
{
GtkWidget *mnemonic_widget;
label = gtk_label_new_with_mnemonic (label_text);
gtk_label_set_xalign (GTK_LABEL (label), xalign);
gtk_label_set_yalign (GTK_LABEL (label), yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (table, label,
column, column + 1,
row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
mnemonic_widget = find_mnemonic_widget (widget, 0);
if (mnemonic_widget)
gtk_label_set_mnemonic_widget (GTK_LABEL (label), mnemonic_widget);
}
if (left_align)
{
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = hbox;
}
gtk_table_attach (table, widget,
column + 1, column + 1 + colspan,
row, row + 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (widget);
return label;
}
static WidgetInfo *
create_frame (void)
{
GtkWidget *frame;
GtkWidget *content;
frame = gimp_frame_new ("Frame");
content = gtk_label_new ("Frame Content\nThis Frame is HIG compliant");
gtk_label_set_xalign (GTK_LABEL (content), 0.0);
gtk_label_set_yalign (GTK_LABEL (content), 0.0);
gtk_container_add (GTK_CONTAINER (frame), content);
return new_widget_info ("gimp-widget-frame", frame, MEDIUM);
}
static SeahorseKeyserverResultsRow*
seahorse_keyserver_results_row_new (GObject *item)
{
g_autoptr(SeahorseKeyserverResultsRow) row = NULL;
g_autoptr(GtkWidget) grid = NULL;
g_autoptr(GtkWidget) label = NULL;
g_autoptr(GtkWidget) import_button = NULL;
gchar *item_label;
gboolean item_exportable;
g_object_get (item, "markup", &item_label, "exportable", &item_exportable,
NULL);
row = g_object_new (SEAHORSE_TYPE_KEYSERVER_RESULTS_ROW, NULL);
gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (row), item_exportable);
gtk_widget_show (GTK_WIDGET (row));
row->key = item;
grid = gtk_grid_new ();
g_object_set (grid, "margin", 6, NULL);
gtk_widget_show (grid);
label = gtk_label_new (item_label);
gtk_widget_set_hexpand (label, TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&label), 0, 0, 1, 1);
import_button = gtk_button_new_from_icon_name ("document-save-symbolic",
GTK_ICON_SIZE_BUTTON);
row->import_button = GTK_BUTTON (import_button);
g_signal_connect_object (import_button, "clicked",
G_CALLBACK (on_import_button_clicked), row, 0);
gtk_widget_set_visible (import_button, TRUE);
gtk_widget_set_valign (import_button, GTK_ALIGN_START);
gtk_widget_set_halign (import_button, GTK_ALIGN_END);
gtk_style_context_add_class (gtk_widget_get_style_context (import_button),
"flat");
if (item_exportable)
gtk_widget_set_tooltip_text (import_button, _("Import"));
else
gtk_widget_set_tooltip_text (import_button, _("Can’t import key"));
gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&import_button), 1, 0, 1, 1);
gtk_container_add (GTK_CONTAINER (row), g_steal_pointer (&grid));
return g_steal_pointer (&row);
}
void
mate_metacity_config_tool ()
{
GSettings *settings;
GtkDialog *dialog;
GtkWidget *vbox;
GtkWidget *widget;
gchar *str;
settings = g_settings_new (METACITY_SCHEMA);
dialog = GTK_DIALOG (gtk_dialog_new_with_buttons(_("Metacity Preferences"),
NULL,
GTK_DIALOG_MODAL,
#if GTK_CHECK_VERSION (3, 10, 0)
_("_Close"),
#else
GTK_STOCK_CLOSE,
#endif
GTK_RESPONSE_CLOSE,
NULL));
gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-system-windows");
gtk_window_set_default_size (GTK_WINDOW (dialog), 350, 150);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
str = g_strdup_printf ("<b>%s</b>", _("Compositing Manager"));
widget = gtk_label_new (str);
g_free (str);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label (_("Enable software _compositing window manager"));
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_settings_bind (settings, COMPOSITING_KEY, widget, "active", G_SETTINGS_BIND_DEFAULT);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (dialog)), vbox, TRUE, TRUE, 0);
g_signal_connect (dialog, "response", G_CALLBACK (gtk_main_quit), dialog);
gtk_widget_show_all (GTK_WIDGET (dialog));
gtk_main ();
g_object_unref (settings);
}
static void set_item_text_angle_and_alignment(GtkWidget* item, double text_angle, float xalign, float yalign)
{
GtkWidget *label;
label = gtk_bin_get_child (GTK_BIN (item));
gtk_label_set_angle (GTK_LABEL (label), text_angle);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), xalign);
gtk_label_set_yalign (GTK_LABEL (label), yalign);
#else
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
#endif
}
static GtkWidget *
menu_item_new (MenuItem *menuitem, int workspace_id)
{
unsigned int key;
MetaVirtualModifier mods;
const char *i18n_label;
GtkWidget *mi;
GtkWidget *accel_label;
if (menuitem->type == MENU_ITEM_NORMAL)
{
mi = gtk_menu_item_new ();
}
else if (menuitem->type == MENU_ITEM_CHECKBOX)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi),
TRUE);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
return NULL;
else
return gtk_separator_menu_item_new ();
i18n_label = _(menuitem->label);
meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);
accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
gtk_label_set_xalign (GTK_LABEL (accel_label), 0.0);
gtk_container_add (GTK_CONTAINER (mi), accel_label);
gtk_widget_show (accel_label);
meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label),
key, mods);
return mi;
}
void addOutputLabel(GtkGrid *grid, char* text, int col, int row, int width) {
GtkWidget* label = gtk_grid_get_child_at(grid, col, row);
if(label == NULL){
label = gtk_label_new(NULL);
gtk_label_set_xalign(GTK_LABEL(label), 0);
gtk_grid_attach(grid,label,col,row,width,1);
gtk_widget_show(label);
}
const char *format = "<b>\%s</b>";
char *markup;
markup = g_markup_printf_escaped (format, text);
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
}
static void
gimp_viewable_dialog_init (GimpViewableDialog *dialog)
{
GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *vbox;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
dialog->icon = gtk_image_new ();
gtk_misc_set_alignment (GTK_MISC (dialog->icon), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), dialog->icon, FALSE, FALSE, 0);
gtk_widget_show (dialog->icon);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
dialog->desc_label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (dialog->desc_label), 0.0);
gimp_label_set_attributes (GTK_LABEL (dialog->desc_label),
PANGO_ATTR_SCALE, PANGO_SCALE_LARGE,
PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
-1);
gtk_box_pack_start (GTK_BOX (vbox), dialog->desc_label, FALSE, FALSE, 0);
gtk_widget_show (dialog->desc_label);
dialog->viewable_label = g_object_new (GTK_TYPE_LABEL,
"xalign", 0.0,
"yalign", 0.5,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gimp_label_set_attributes (GTK_LABEL (dialog->viewable_label),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_box_pack_start (GTK_BOX (vbox), dialog->viewable_label, FALSE, FALSE, 0);
gtk_widget_show (dialog->viewable_label);
}
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;
}
static GtkWidget* create_hig_category(GtkWidget* main_box, gchar* title)
{
GtkWidget* vbox;
GtkWidget* vbox2;
GtkWidget* hbox;
GtkWidget*label;
gchar* tmp;
#if GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", title);
label = gtk_label_new (NULL);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox2 = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
return vbox2;
}
GtkWidget *
make_title_label (const char *text)
{
GtkWidget *label;
char *full;
full = g_strdup_printf ("<span weight=\"bold\">%s</span>", text);
label = gtk_label_new (full);
g_free (full);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
return label;
}
static void
gimp_dynamics_editor_add_output_row (GObject *config,
const gchar *row_label,
GtkGrid *grid,
gint row)
{
GtkWidget *label;
gint column = 1;
label = gtk_label_new (row_label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (grid, label, 0, row, 1, 1);
gtk_widget_show (label);
dynamics_check_button_new (config, "use-pressure",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-velocity",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-direction",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-tilt",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-wheel",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-random",
grid, column, row);
column++;
dynamics_check_button_new (config, "use-fade",
grid, column, row);
column++;
}
void
setup_menuitem (GtkWidget *menuitem,
GtkIconSize icon_size,
GtkWidget *image,
const char *title)
{
GtkWidget *label;
char *_title;
/* this creates a label with an invisible mnemonic */
label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
_title = menu_escape_underscores_and_prepend (title);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _title);
g_free (_title);
gtk_label_set_pattern (GTK_LABEL (label), "");
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuitem);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (menuitem), label);
if (image) {
gint icon_height = PANEL_DEFAULT_MENU_ICON_SIZE;
gtk_icon_size_lookup (icon_size, NULL, &icon_height);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
gtk_image_set_pixel_size (GTK_IMAGE(image), icon_height);
}
gtk_widget_show (menuitem);
}
GtkWidget*
title_label_new (const char* title)
{
GtkWidget *widget;
gchar *str;
str = g_strdup_printf ("<b>%s</b>", _(title));
widget = gtk_label_new (str);
g_free (str);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 0.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
#endif
return widget;
}
/* shortcut */
static void
doLabel (GtkWidget *vbox,
const gchar *format,
...)
{
GtkWidget *label;
gchar *text;
va_list args;
va_start (args, format);
text = g_strdup_vprintf (format, args);
va_end (args);
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (text);
}
static GtkWidget *
add_section (GtkWidget *box,
const gchar *heading)
{
GtkWidget *label;
GtkWidget *section;
label = gtk_label_new (heading);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_margin_top (label, 10);
gtk_widget_set_margin_bottom (label, 10);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
section = gtk_flow_box_new ();
gtk_widget_set_halign (section, GTK_ALIGN_START);
gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (section), GTK_SELECTION_NONE);
gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (section), 2);
gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (section), 20);
gtk_box_pack_start (GTK_BOX (box), section, FALSE, TRUE, 0);
return section;
}
