void
nsLookAndFeel::InitLookAndFeel()
{
GtkStyle *style;
// tooltip foreground and background
style = gtk_rc_get_style_by_paths(gtk_settings_get_default(),
"gtk-tooltips", "GtkWindow",
GTK_TYPE_WINDOW);
if (style) {
sInfoBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
sInfoText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
// menu foreground & menu background
GtkWidget *accel_label = gtk_accel_label_new("M");
GtkWidget *menuitem = gtk_menu_item_new();
GtkWidget *menu = gtk_menu_new();
g_object_ref_sink(menu);
gtk_container_add(GTK_CONTAINER(menuitem), accel_label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_set_style(accel_label, NULL);
gtk_widget_set_style(menu, NULL);
gtk_widget_realize(menu);
gtk_widget_realize(accel_label);
style = gtk_widget_get_style(accel_label);
if (style) {
sMenuText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menu);
if (style) {
sMenuBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menuitem);
if (style) {
sMenuHover = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_PRELIGHT]);
sMenuHoverText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_PRELIGHT]);
}
g_object_unref(menu);
// button styles
GtkWidget *parent = gtk_fixed_new();
GtkWidget *button = gtk_button_new();
GtkWidget *label = gtk_label_new("M");
GtkWidget *combobox = gtk_combo_box_new();
GtkWidget *comboboxLabel = gtk_label_new("M");
GtkWidget *window = gtk_window_new(GTK_WINDOW_POPUP);
GtkWidget *treeView = gtk_tree_view_new();
GtkWidget *linkButton = gtk_link_button_new("http://example.com/");
GtkWidget *menuBar = gtk_menu_bar_new();
GtkWidget *entry = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(button), label);
gtk_container_add(GTK_CONTAINER(combobox), comboboxLabel);
gtk_container_add(GTK_CONTAINER(parent), button);
gtk_container_add(GTK_CONTAINER(parent), treeView);
gtk_container_add(GTK_CONTAINER(parent), linkButton);
gtk_container_add(GTK_CONTAINER(parent), combobox);
gtk_container_add(GTK_CONTAINER(parent), menuBar);
gtk_container_add(GTK_CONTAINER(window), parent);
gtk_container_add(GTK_CONTAINER(parent), entry);
gtk_widget_set_style(button, NULL);
gtk_widget_set_style(label, NULL);
gtk_widget_set_style(treeView, NULL);
gtk_widget_set_style(linkButton, NULL);
gtk_widget_set_style(combobox, NULL);
gtk_widget_set_style(comboboxLabel, NULL);
gtk_widget_set_style(menuBar, NULL);
gtk_widget_set_style(entry, NULL);
gtk_widget_realize(button);
gtk_widget_realize(label);
gtk_widget_realize(treeView);
gtk_widget_realize(linkButton);
gtk_widget_realize(combobox);
gtk_widget_realize(comboboxLabel);
gtk_widget_realize(menuBar);
gtk_widget_realize(entry);
style = gtk_widget_get_style(label);
if (style) {
sButtonText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(comboboxLabel);
if (style) {
sComboBoxText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(combobox);
if (style) {
sComboBoxBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
}
style = gtk_widget_get_style(menuBar);
if (style) {
sMenuBarText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_NORMAL]);
sMenuBarHoverText = GDK_COLOR_TO_NS_RGB(style->fg[GTK_STATE_SELECTED]);
}
// Some themes have a unified menu bar, and support window dragging on it
gboolean supports_menubar_drag = FALSE;
GParamSpec *param_spec =
gtk_widget_class_find_style_property(GTK_WIDGET_GET_CLASS(menuBar),
"window-dragging");
if (param_spec) {
if (g_type_is_a(G_PARAM_SPEC_VALUE_TYPE(param_spec), G_TYPE_BOOLEAN)) {
gtk_widget_style_get(menuBar,
"window-dragging", &supports_menubar_drag,
NULL);
}
}
sMenuSupportsDrag = supports_menubar_drag;
// GTK's guide to fancy odd row background colors:
// 1) Check if a theme explicitly defines an odd row color
// 2) If not, check if it defines an even row color, and darken it
// slightly by a hardcoded value (gtkstyle.c)
// 3) If neither are defined, take the base background color and
// darken that by a hardcoded value
GdkColor colorValue;
GdkColor *colorValuePtr = NULL;
gtk_widget_style_get(treeView,
"odd-row-color", &colorValuePtr,
NULL);
if (colorValuePtr) {
colorValue = *colorValuePtr;
} else {
gtk_widget_style_get(treeView,
"even-row-color", &colorValuePtr,
NULL);
if (colorValuePtr)
darken_gdk_color(colorValuePtr, &colorValue);
else
darken_gdk_color(&treeView->style->base[GTK_STATE_NORMAL], &colorValue);
}
sOddCellBackground = GDK_COLOR_TO_NS_RGB(colorValue);
if (colorValuePtr)
gdk_color_free(colorValuePtr);
style = gtk_widget_get_style(button);
if (style) {
sButtonBackground = GDK_COLOR_TO_NS_RGB(style->bg[GTK_STATE_NORMAL]);
sButtonOuterLightBorder =
GDK_COLOR_TO_NS_RGB(style->light[GTK_STATE_NORMAL]);
sButtonInnerDarkBorder =
GDK_COLOR_TO_NS_RGB(style->dark[GTK_STATE_NORMAL]);
}
colorValuePtr = NULL;
gtk_widget_style_get(linkButton, "link-color", &colorValuePtr, NULL);
if (colorValuePtr) {
colorValue = *colorValuePtr; // we can't pass deref pointers to GDK_COLOR_TO_NS_RGB
sNativeHyperLinkText = GDK_COLOR_TO_NS_RGB(colorValue);
gdk_color_free(colorValuePtr);
} else {
sNativeHyperLinkText = NS_RGB(0x00,0x00,0xEE);
}
// invisible character styles
guint value;
g_object_get (entry, "invisible-char", &value, NULL);
sInvisibleCharacter = PRUnichar(value);
// caret styles
gtk_widget_style_get(entry,
"cursor-aspect-ratio", &sCaretRatio,
NULL);
gtk_widget_destroy(window);
}
static void
greeter_menu_bar_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
GList* item;
GList* shell_children;
GList* expand_nums = NULL;
guint visible_count = 0, expand_count = 0;
g_return_if_fail(allocation != NULL);
g_return_if_fail(GREETER_IS_MENU_BAR(widget));
gtk_widget_set_allocation(widget, allocation);
GtkPackDirection pack_direction = gtk_menu_bar_get_pack_direction(GTK_MENU_BAR(widget));
g_return_if_fail(pack_direction == GTK_PACK_DIRECTION_LTR || pack_direction == GTK_PACK_DIRECTION_RTL);
shell_children = gtk_container_get_children(GTK_CONTAINER(widget));
for(item = shell_children; item; item = g_list_next(item))
if(gtk_widget_get_visible(item->data))
{
if(gtk_widget_compute_expand(item->data, GTK_ORIENTATION_HORIZONTAL))
{
expand_nums = g_list_prepend(expand_nums, GINT_TO_POINTER(visible_count));
expand_count++;
}
visible_count++;
}
if(gtk_widget_get_realized(widget))
gdk_window_move_resize(gtk_widget_get_window(widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
if(visible_count > 0)
{
GtkAllocation remaining_space;
GtkStyleContext* context = gtk_widget_get_style_context(widget);
GtkStateFlags flags = gtk_widget_get_state_flags(widget);
GtkRequestedSize* requested_sizes = g_newa(GtkRequestedSize, visible_count);
guint border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
GtkShadowType shadow_type = GTK_SHADOW_OUT;
GtkBorder border;
gint toggle_size;
gtk_style_context_get_padding(context, flags, &border);
gtk_widget_style_get(widget, "shadow-type", &shadow_type, NULL);
remaining_space.x = (border_width + border.left);
remaining_space.y = (border_width + border.top);
remaining_space.width = allocation->width -
2 * border_width - border.left - border.right;
remaining_space.height = allocation->height -
2 * border_width - border.top - border.bottom;
if (shadow_type != GTK_SHADOW_NONE)
{
gtk_style_context_get_border(context, flags, &border);
remaining_space.x += border.left;
remaining_space.y += border.top;
remaining_space.width -= border.left + border.right;
remaining_space.height -= border.top + border.bottom;
}
GtkRequestedSize* request = requested_sizes;
int size = remaining_space.width;
gboolean ltr = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_LTR) == (pack_direction == GTK_PACK_DIRECTION_LTR);
for(item = shell_children; item; item = g_list_next(item))
{
if (!gtk_widget_get_visible(item->data))
continue;
request->data = item->data;
gtk_widget_get_preferred_width_for_height(item->data, remaining_space.height,
&request->minimum_size,
&request->natural_size);
gtk_menu_item_toggle_size_request(GTK_MENU_ITEM(item->data),
&toggle_size);
request->minimum_size += toggle_size;
request->natural_size += toggle_size;
gtk_menu_item_toggle_size_allocate(GTK_MENU_ITEM(item->data), toggle_size);
size -= request->minimum_size;
request++;
}
size = gtk_distribute_natural_allocation(size, visible_count, requested_sizes);
/* Distribution extra space for widgets with expand=True */
if(size > 0 && expand_nums)
{
expand_nums = g_list_sort_with_data(expand_nums, (GCompareDataFunc)sort_minimal_size,
requested_sizes);
GList* first_item = expand_nums;
gint needed_size = -1;
gint max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
gint total_needed_size = 0;
/* Free space that all widgets need to have the same (max_size) width
* [___max_width___][widget ][widget____ ]
* total_needed_size := [] + [ ] + [ ]
* total_needed_size = [ ]
*/
for(item = g_list_next(expand_nums); item; item = g_list_next(item))
total_needed_size += max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
while(first_item)
{
if(size >= total_needed_size)
{
/* total_needed_size is enough for all remaining widgets */
needed_size = max_size + (size - total_needed_size)/expand_count;
break;
}
/* Removing current maximal widget from list */
total_needed_size -= max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
first_item = g_list_next(first_item);
if(first_item)
max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
}
for(item = first_item; item; item = g_list_next(item))
{
request = &requested_sizes[GPOINTER_TO_INT(item->data)];
gint dsize = needed_size - request->natural_size;
if(size < dsize)
dsize = size;
size -= dsize;
request->natural_size += dsize;
}
}
gint i;
for(i = 0; i < visible_count; i++)
{
GtkAllocation child_allocation = remaining_space;
request = &requested_sizes[i];
child_allocation.width = request->natural_size;
remaining_space.width -= request->natural_size;
if (ltr)
remaining_space.x += request->natural_size;
else
child_allocation.x += remaining_space.width;
gtk_widget_size_allocate(request->data, &child_allocation);
}
g_list_free(expand_nums);
}
g_list_free(shell_children);
}
/**
* terminal_profile_edit:
* @profile: a #GSettings
* @transient_parent: a #GtkWindow, or %NULL
* @widget_name: a widget name in the profile editor's UI, or %NULL
*
* Shows the profile editor with @profile, anchored to @transient_parent.
* If @widget_name is non-%NULL, focuses the corresponding widget and
* switches the notebook to its containing page.
*/
void
terminal_profile_edit (GSettings *profile,
GtkWindow *transient_parent,
const char *widget_name)
{
TerminalSettingsList *profiles_list;
GtkBuilder *builder;
GError *error = NULL;
GtkWidget *editor, *w;
gs_free char *uuid = NULL;
guint i;
gfloat style_darkness;
editor = g_object_get_data (G_OBJECT (profile), "editor-window");
if (editor)
{
terminal_util_dialog_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
NULL);
gtk_window_present (GTK_WINDOW (editor));
return;
}
fixup_color_chooser_button ();
profiles_list = terminal_app_get_profiles_list (terminal_app_get ());
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/terminal/ui/profile-preferences.ui", &error);
g_assert_no_error (error);
editor = (GtkWidget *) gtk_builder_get_object (builder, "profile-editor-dialog");
g_object_set_data_full (G_OBJECT (editor), "builder",
builder, (GDestroyNotify) g_object_unref);
/* Store the dialogue on the profile, so we can acccess it above to check if
* there's already a profile editor for this profile.
*/
g_object_set_data (G_OBJECT (profile), "editor-window", editor);
g_signal_connect (editor, "destroy",
G_CALLBACK (profile_editor_destroyed),
profile);
w = (GtkWidget *) gtk_builder_get_object (builder, "close-button");
g_signal_connect (w, "clicked", G_CALLBACK (editor_close_button_clicked_cb), editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "help-button");
g_signal_connect (w, "clicked", G_CALLBACK (editor_help_button_clicked_cb), editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "profile-editor-notebook");
gtk_widget_add_events (w, GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK);
g_signal_connect (w, "scroll-event", G_CALLBACK (scroll_event_cb), NULL);
uuid = terminal_settings_list_dup_uuid_from_child (profiles_list, profile);
gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "profile-uuid")),
uuid);
g_signal_connect (gtk_builder_get_object (builder, "default-size-reset-button"),
"clicked",
G_CALLBACK (default_size_reset_cb),
profile);
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
init_color_scheme_menu (w);
/* Hook up the palette colorpickers and combo box */
for (i = 0; i < TERMINAL_PALETTE_SIZE; ++i)
{
char name[32];
char *text;
g_snprintf (name, sizeof (name), "palette-colorpicker-%u", i + 1);
w = (GtkWidget *) gtk_builder_get_object (builder, name);
g_object_set_data (G_OBJECT (w), "palette-entry-index", GUINT_TO_POINTER (i));
text = g_strdup_printf (_("Choose Palette Color %u"), i + 1);
gtk_color_button_set_title (GTK_COLOR_BUTTON (w), text);
g_free (text);
text = g_strdup_printf (_("Palette entry %u"), i + 1);
gtk_widget_set_tooltip_text (w, text);
g_free (text);
g_signal_connect (w, "notify::rgba",
G_CALLBACK (palette_color_notify_cb),
profile);
}
gtk_widget_style_get (GTK_WIDGET (
terminal_window_get_active (TERMINAL_WINDOW (transient_parent))),
"background-darkness", &style_darkness,
NULL);
gtk_widget_set_visible (gtk_builder_get_object (
builder,
"use-theme-transparency-checkbutton"), style_darkness >= 0);
profile_palette_notify_colorpickers_cb (profile, TERMINAL_PROFILE_PALETTE_KEY, editor);
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_PALETTE_KEY,
G_CALLBACK (profile_palette_notify_colorpickers_cb),
editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "palette-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (palette_scheme_combo_changed_cb),
profile);
profile_palette_notify_scheme_combo_cb (profile, TERMINAL_PROFILE_PALETTE_KEY, GTK_COMBO_BOX (w));
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_PALETTE_KEY,
G_CALLBACK (profile_palette_notify_scheme_combo_cb),
w);
/* Hook up the color scheme pickers and combo box */
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (color_scheme_combo_changed_cb),
profile);
profile_colors_notify_scheme_combo_cb (profile, NULL, GTK_COMBO_BOX (w));
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_FOREGROUND_COLOR_KEY,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_BACKGROUND_COLOR_KEY,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
w = GTK_WIDGET (gtk_builder_get_object (builder, "custom-command-entry"));
custom_command_entry_changed_cb (GTK_ENTRY (w));
g_signal_connect (w, "changed",
G_CALLBACK (custom_command_entry_changed_cb), NULL);
g_signal_connect (gtk_builder_get_object (builder, "reset-compat-defaults-button"),
"clicked",
G_CALLBACK (reset_compat_defaults_cb),
profile);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_VISIBLE_NAME_KEY,
editor,
"title",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_NO_SENSITIVITY,
(GSettingsBindGetMapping)
string_to_window_title, NULL, NULL, NULL);
g_settings_bind (profile,
TERMINAL_PROFILE_ALLOW_BOLD_KEY,
gtk_builder_get_object (builder, "allow-bold-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_BACKGROUND_COLOR_KEY,
gtk_builder_get_object (builder,
"background-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_BACKSPACE_BINDING_KEY,
gtk_builder_get_object (builder,
"backspace-binding-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_erase_binding_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_BOLD_COLOR_SAME_AS_FG_KEY,
gtk_builder_get_object (builder,
"bold-color-same-as-fg-checkbox"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_BOLD_COLOR_SAME_AS_FG_KEY,
gtk_builder_get_object (builder,
"bold-colorpicker-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_BOLD_COLOR_KEY,
gtk_builder_get_object (builder,
"bold-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_CURSOR_SHAPE_KEY,
gtk_builder_get_object (builder,
"cursor-shape-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_cursor_shape_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder, "custom-command-entry"),
"text", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_DEFAULT_SIZE_COLUMNS_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"default-size-columns-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_DEFAULT_SIZE_ROWS_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"default-size-rows-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_DELETE_BINDING_KEY,
gtk_builder_get_object (builder,
"delete-binding-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_erase_binding_get_type, NULL);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_EXIT_ACTION_KEY,
gtk_builder_get_object (builder,
"exit-action-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
terminal_exit_action_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_FONT_KEY,
gtk_builder_get_object (builder, "font-selector"),
"font-name", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_FOREGROUND_COLOR_KEY,
gtk_builder_get_object (builder,
"foreground-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_LOGIN_SHELL_KEY,
gtk_builder_get_object (builder,
"login-shell-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_VISIBLE_NAME_KEY,
gtk_builder_get_object (builder, "profile-name-entry"),
"text", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_LINES_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"scrollback-lines-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_UNLIMITED_KEY,
gtk_builder_get_object (builder,
"scrollback-limited-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_UNLIMITED_KEY,
gtk_builder_get_object (builder,
"scrollback-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_SCROLLBAR_POLICY_KEY,
gtk_builder_get_object (builder,
"scrollbar-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) scrollbar_policy_to_bool,
(GSettingsBindSetMapping) bool_to_scrollbar_policy,
NULL, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLL_ON_KEYSTROKE_KEY,
gtk_builder_get_object (builder,
"scroll-on-keystroke-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLL_ON_OUTPUT_KEY,
gtk_builder_get_object (builder,
"scroll-on-output-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_SYSTEM_FONT_KEY,
gtk_builder_get_object (builder,
"custom-font-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_settings_bind (profile, TERMINAL_PROFILE_USE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder,
"use-custom-command-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_COLORS_KEY,
gtk_builder_get_object (builder,
"use-theme-colors-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_AUDIBLE_BELL_KEY,
gtk_builder_get_object (builder, "bell-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder, "custom-command-box"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_SYSTEM_FONT_KEY,
gtk_builder_get_object (builder, "font-selector"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_THEME_COLORS_KEY,
gtk_builder_get_object (builder, "colors-box"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_writable (profile,
TERMINAL_PROFILE_PALETTE_KEY,
gtk_builder_get_object (builder, "palette-box"),
"sensitive",
FALSE);
g_settings_bind (profile,
TERMINAL_PROFILE_REWRAP_ON_RESIZE_KEY,
gtk_builder_get_object (builder, "rewrap-on-resize-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
/* Compatibility options */
w = (GtkWidget *) gtk_builder_get_object (builder, "encoding-combobox");
init_encodings_combo (w);
g_settings_bind (profile,
TERMINAL_PROFILE_ENCODING_KEY,
w,
"active-id", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
w = (GtkWidget *) gtk_builder_get_object (builder, "cjk-ambiguous-width-combobox");
g_settings_bind (profile, TERMINAL_PROFILE_CJK_UTF8_AMBIGUOUS_WIDTH_KEY,
w,
"active-id",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_TRANSPARENT_BACKGROUND,
gtk_builder_get_object (builder, "use-transparent-background"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_TRANSPARENT_BACKGROUND,
gtk_builder_get_object (builder, "background-transparent-scale-box"),
"sensitive", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile, TERMINAL_PROFILE_BACKGROUND_TRANSPARENCY_PERCENT,
gtk_builder_get_object (builder, "background-transparent-adjustment"),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_TRANSPARENCY,
gtk_builder_get_object (builder, "use-theme-transparency-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
if (style_darkness >= 0)
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_TRANSPARENCY,
gtk_builder_get_object (builder, "use-transparent-background-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
/* Finished! */
terminal_util_bind_mnemonic_label_sensitivity (editor);
terminal_util_dialog_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
NULL);
gtk_window_present (GTK_WINDOW (editor));
}
static void
gtk_switch_get_preferred_width (GtkWidget *widget,
gint *minimum,
gint *natural)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
gint width, slider_width, focus_width, focus_pad;
PangoLayout *layout;
PangoRectangle logical_rect;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
if (priv->is_active)
state |= GTK_STATE_FLAG_ACTIVE;
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
gtk_style_context_get_padding (context, state, &padding);
width = padding.left + padding.right;
gtk_style_context_restore (context);
gtk_widget_style_get (widget,
"slider-width", &slider_width,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
width += 2 * (focus_width + focus_pad);
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
pango_layout_get_extents (layout, NULL, &logical_rect);
pango_extents_to_pixels (&logical_rect, NULL);
width += MAX (logical_rect.width, slider_width);
/* Translators: if the "off" state label requires more than three
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
pango_layout_set_text (layout, C_("switch", "OFF"), -1);
pango_layout_get_extents (layout, NULL, &logical_rect);
pango_extents_to_pixels (&logical_rect, NULL);
width += MAX (logical_rect.width, slider_width);
g_object_unref (layout);
if (minimum)
*minimum = width;
if (natural)
*natural = width;
}
void
gimp_enum_radio_box_add (GtkBox *box,
GtkWidget *widget,
gint enum_value,
gboolean below)
{
GList *children;
GList *list;
gint pos;
g_return_if_fail (GTK_IS_BOX (box));
g_return_if_fail (GTK_IS_WIDGET (widget));
children = gtk_container_get_children (GTK_CONTAINER (box));
for (list = children, pos = 1;
list;
list = g_list_next (list), pos++)
{
if (GTK_IS_RADIO_BUTTON (list->data) &&
GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) ==
enum_value)
{
GtkWidget *radio = list->data;
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (box), hbox, pos);
if (below)
{
GtkWidget *spacer;
gint indicator_size;
gint indicator_spacing;
gint focus_width;
gint focus_padding;
gint border_width;
gtk_widget_style_get (radio,
"indicator-size", &indicator_size,
"indicator-spacing", &indicator_spacing,
"focus-line-width", &focus_width,
"focus-padding", &focus_padding,
NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (radio));
spacer = gtk_vbox_new (FALSE, 0);
gtk_widget_set_size_request (spacer,
indicator_size +
3 * indicator_spacing +
focus_width +
focus_padding +
border_width,
-1);
gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0);
gtk_widget_show (spacer);
}
else
{
GtkSizeGroup *size_group;
size_group = g_object_get_data (G_OBJECT (box), "size-group");
if (! size_group)
{
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
g_object_set_data (G_OBJECT (box), "size-group", size_group);
gtk_size_group_add_widget (size_group, radio);
g_object_unref (size_group);
}
else
{
gtk_size_group_add_widget (size_group, radio);
}
gtk_box_set_spacing (GTK_BOX (hbox), 4);
g_object_ref (radio);
gtk_container_remove (GTK_CONTAINER (box), radio);
gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0);
g_object_unref (radio);
}
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
g_object_bind_property (radio, "active",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
gtk_widget_show (hbox);
break;
}
}
g_list_free (children);
}
static void
gtk_tearoff_menu_item_paint (GtkWidget *widget,
GdkRectangle *area)
{
GtkMenuItem *menu_item;
GtkShadowType shadow_type;
gint width, height;
gint x, y;
gint right_max;
GtkArrowType arrow_type;
GtkTextDirection direction;
if (GTK_WIDGET_DRAWABLE (widget))
{
menu_item = GTK_MENU_ITEM (widget);
direction = gtk_widget_get_direction (widget);
x = widget->allocation.x + GTK_CONTAINER (menu_item)->border_width;
y = widget->allocation.y + GTK_CONTAINER (menu_item)->border_width;
width = widget->allocation.width - GTK_CONTAINER (menu_item)->border_width * 2;
height = widget->allocation.height - GTK_CONTAINER (menu_item)->border_width * 2;
right_max = x + width;
if (widget->state == GTK_STATE_PRELIGHT)
{
gint selected_shadow_type;
gtk_widget_style_get (widget,
"selected-shadow-type", &selected_shadow_type,
NULL);
gtk_paint_box (widget->style,
widget->window,
GTK_STATE_PRELIGHT,
selected_shadow_type,
area, widget, "menuitem",
x, y, width, height);
}
else
gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
if (GTK_IS_MENU (widget->parent) && GTK_MENU (widget->parent)->torn_off)
{
gint arrow_x;
if (widget->state == GTK_STATE_PRELIGHT)
shadow_type = GTK_SHADOW_IN;
else
shadow_type = GTK_SHADOW_OUT;
if (menu_item->toggle_size > ARROW_SIZE)
{
if (direction == GTK_TEXT_DIR_LTR) {
arrow_x = x + (menu_item->toggle_size - ARROW_SIZE)/2;
arrow_type = GTK_ARROW_LEFT;
}
else {
arrow_x = x + width - menu_item->toggle_size + (menu_item->toggle_size - ARROW_SIZE)/2;
arrow_type = GTK_ARROW_RIGHT;
}
x += menu_item->toggle_size + BORDER_SPACING;
}
else
{
if (direction == GTK_TEXT_DIR_LTR) {
arrow_x = ARROW_SIZE / 2;
arrow_type = GTK_ARROW_LEFT;
}
else {
arrow_x = x + width - 2 * ARROW_SIZE + ARROW_SIZE / 2;
arrow_type = GTK_ARROW_RIGHT;
}
x += 2 * ARROW_SIZE;
}
gtk_paint_arrow (widget->style, widget->window,
widget->state, shadow_type,
NULL, widget, "tearoffmenuitem",
arrow_type, FALSE,
arrow_x, y + height / 2 - 5,
ARROW_SIZE, ARROW_SIZE);
}
while (x < right_max)
{
gint x1, x2;
if (direction == GTK_TEXT_DIR_LTR) {
x1 = x;
x2 = MIN (x + TEAR_LENGTH, right_max);
}
else {
x1 = right_max - x;
x2 = MAX (right_max - x - TEAR_LENGTH, 0);
}
gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
NULL, widget, "tearoffmenuitem",
x1, x2, y + (height - widget->style->ythickness) / 2);
x += 2 * TEAR_LENGTH;
}
}
}
static void
gtk_image_menu_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GtkAllocation widget_allocation;
GtkPackDirection pack_dir;
GtkWidget *parent;
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU_BAR (parent))
pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));
else
pack_dir = GTK_PACK_DIRECTION_LTR;
GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);
if (priv->image && gtk_widget_get_visible (priv->image))
{
gint x, y, offset;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
GtkRequisition child_requisition;
GtkAllocation child_allocation;
guint toggle_spacing;
gint toggle_size;
toggle_size = GTK_MENU_ITEM (image_menu_item)->priv->toggle_size;
gtk_widget_style_get (widget,
"toggle-spacing", &toggle_spacing,
NULL);
/* Man this is lame hardcoding action, but I can't
* come up with a solution that's really better.
*/
gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL);
gtk_widget_get_allocation (widget, &widget_allocation);
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_get_padding (context, state, &padding);
offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item));
if (pack_dir == GTK_PACK_DIRECTION_LTR ||
pack_dir == GTK_PACK_DIRECTION_RTL)
{
if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
(pack_dir == GTK_PACK_DIRECTION_LTR))
x = offset + padding.left +
(toggle_size - toggle_spacing - child_requisition.width) / 2;
else
x = widget_allocation.width - offset - padding.right -
toggle_size + toggle_spacing +
(toggle_size - toggle_spacing - child_requisition.width) / 2;
y = (widget_allocation.height - child_requisition.height) / 2;
}
else
{
if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
(pack_dir == GTK_PACK_DIRECTION_TTB))
y = offset + padding.top +
(toggle_size - toggle_spacing - child_requisition.height) / 2;
else
y = widget_allocation.height - offset - padding.bottom -
toggle_size + toggle_spacing +
(toggle_size - toggle_spacing - child_requisition.height) / 2;
x = (widget_allocation.width - child_requisition.width) / 2;
}
child_allocation.width = child_requisition.width;
child_allocation.height = child_requisition.height;
child_allocation.x = widget_allocation.x + MAX (x, 0);
child_allocation.y = widget_allocation.y + MAX (y, 0);
gtk_widget_size_allocate (priv->image, &child_allocation);
}
}
static void
anjuta_tabber_draw_tab (AnjutaTabber* tabber, cairo_t* cr, GList* child)
{
GtkWidget* widget = GTK_WIDGET (tabber);
GtkWidget* tab = GTK_WIDGET (child->data);
gboolean current;
gint focus_width;
gint focus_pad;
gint tab_curvature;
gint tab_overlap;
gint focus_space;
gint tab_begin;
gint tab_end;
GtkStateFlags state;
GtkRegionFlags region_flags;
GtkBorder tab_padding;
GtkAllocation alloc;
GtkAllocation widget_alloc;
GtkStyleContext* context = gtk_widget_get_style_context (widget);
current = g_list_position (tabber->priv->children, child) == tabber->priv->active_page;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
focus_space = focus_pad + focus_width;
/* Get border/padding for tab */
gtk_style_context_save (context);
anjuta_tabber_setup_style_context (tabber, context, child, &state, ®ion_flags);
gtk_style_context_get_padding (context, state, &tab_padding);
gtk_widget_get_allocation (widget, &widget_alloc);
gtk_widget_get_allocation (tab, &alloc);
tab_begin = tab_curvature - tab_overlap;
tab_end = tab_curvature - tab_overlap;
if (region_flags | GTK_REGION_FIRST)
tab_begin += tab_overlap;
if (region_flags | GTK_REGION_LAST)
tab_end += tab_overlap;
alloc.x -= widget_alloc.x;
alloc.x -= tab_begin;
alloc.x -= focus_space + tab_padding.left;
alloc.y -= widget_alloc.y;
alloc.y -= focus_space + tab_padding.top;
alloc.width += 2 * focus_space + tab_padding.left + tab_padding.right
+ tab_begin + tab_end;
alloc.height += 2 * focus_space + tab_padding.top + tab_padding.bottom;
gtk_render_extension (context,
cr,
alloc.x,
alloc.y,
alloc.width,
alloc.height,
GTK_POS_BOTTOM);
if (gtk_widget_has_focus (widget) &&
current)
{
GtkAllocation allocation;
gtk_widget_get_allocation (tab, &allocation);
gtk_render_focus (context, cr,
allocation.x - focus_space,
allocation.y - focus_space,
allocation.width + 2 * focus_space,
allocation.height + 2 * focus_space);
}
gtk_style_context_restore (context);
}
static void update_icon(ShowDesktopData* sdd)
{
GtkStyle* style;
int width, height;
GdkPixbuf* icon;
GdkPixbuf* scaled;
int icon_size;
GError* error;
int focus_width = 0;
int focus_pad = 0;
int thickness = 0;
if (!sdd->icon_theme)
return;
gtk_widget_style_get (sdd->button, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL);
style = gtk_widget_get_style(sdd->button);
switch (sdd->orient)
{
case GTK_ORIENTATION_HORIZONTAL:
thickness = style->ythickness;
break;
case GTK_ORIENTATION_VERTICAL:
thickness = style->xthickness;
break;
}
icon_size = sdd->size - 2 * (focus_width + focus_pad + thickness);
if (icon_size < 22)
icon_size = 16;
else if (icon_size < 32)
icon_size = 22;
else if (icon_size < 48)
icon_size = 32;
error = NULL;
icon = gtk_icon_theme_load_icon (sdd->icon_theme, SHOW_DESKTOP_ICON, icon_size, 0, &error);
if (icon == NULL)
{
g_printerr(_("Failed to load %s: %s\n"), SHOW_DESKTOP_ICON, error ? error->message : _("Icon not found"));
if (error)
{
g_error_free(error);
error = NULL;
}
gtk_image_set_from_stock(GTK_IMAGE (sdd->image), GTK_STOCK_MISSING_IMAGE, GTK_ICON_SIZE_SMALL_TOOLBAR);
return;
}
width = gdk_pixbuf_get_width(icon);
height = gdk_pixbuf_get_height(icon);
scaled = NULL;
/* Make it fit on the given panel */
switch (sdd->orient)
{
case GTK_ORIENTATION_HORIZONTAL:
width = (icon_size * width) / height;
height = icon_size;
break;
case GTK_ORIENTATION_VERTICAL:
height = (icon_size * height) / width;
width = icon_size;
break;
}
scaled = gdk_pixbuf_scale_simple(icon, width, height, GDK_INTERP_BILINEAR);
if (scaled != NULL)
{
gtk_image_set_from_pixbuf(GTK_IMAGE(sdd->image), scaled);
g_object_unref(scaled);
}
else
{
gtk_image_set_from_pixbuf (GTK_IMAGE (sdd->image), icon);
}
g_object_unref (icon);
}
static void
anjuta_tabber_render_tab (GtkWidget* widget,
GtkWidget* tab,
cairo_t* cr,
gboolean current,
GtkRegionFlags region_flags)
{
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
GtkAllocation alloc;
GtkAllocation widget_alloc;
gint focus_width;
gint tab_curvature;
gint tab_overlap;
gint tab_begin;
gint tab_end;
gint xpadding;
gint ypadding;
GtkStyleContext* context = gtk_widget_get_style_context (widget);
if (current)
gtk_widget_set_state_flags (tab, GTK_STATE_FLAG_ACTIVE, TRUE);
else
gtk_widget_unset_state_flags (tab, GTK_STATE_FLAG_ACTIVE);
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
/* Get border/padding for tab */
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_NOTEBOOK);
gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB,
region_flags);
if (current)
gtk_style_context_set_state (context, GTK_STATE_FLAG_ACTIVE);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
gtk_style_context_set_junction_sides (context,
GTK_JUNCTION_CORNER_TOPLEFT);
else
gtk_style_context_set_junction_sides (context,
GTK_JUNCTION_CORNER_TOPRIGHT);
gtk_widget_get_allocation (widget, &widget_alloc);
gtk_widget_get_allocation (tab, &alloc);
xpadding = focus_width + tabber->priv->tab_hborder;
ypadding = focus_width + tabber->priv->tab_vborder;
tab_begin = tab_curvature - tab_overlap;
tab_end = tab_curvature - tab_overlap;
if (region_flags | GTK_REGION_FIRST)
tab_begin += tab_overlap;
if (region_flags | GTK_REGION_LAST)
tab_end += tab_overlap;
alloc.x -= widget_alloc.x;
alloc.x -= tab_begin;
alloc.x -= xpadding;
alloc.y -= widget_alloc.y;
alloc.y -= ypadding;
alloc.width += 2 * (xpadding) + tab_begin + tab_end;
alloc.height += 2 * ypadding;
gtk_render_extension (context,
cr,
alloc.x,
alloc.y,
alloc.width,
alloc.height,
GTK_POS_BOTTOM);
if (gtk_widget_has_focus (widget) &&
current)
{
GtkAllocation allocation;
gtk_widget_get_allocation (tab, &allocation);
gtk_render_focus (context, cr,
allocation.x - focus_width,
allocation.y - focus_width,
allocation.width + 2 * focus_width,
allocation.height + 2 * focus_width);
}
gtk_style_context_restore (context);
}
static void
anjuta_tabber_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
g_return_if_fail (ANJUTA_IS_TABBER (widget));
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
GtkStyleContext* context;
GList* child;
gint focus_width;
gint focus_pad;
gint tab_curvature;
gint tab_overlap;
gint n_children = g_list_length (tabber->priv->children);
gint x;
gint focus_space;
gint tab_space;
context = gtk_widget_get_style_context (widget);
gtk_widget_style_get (GTK_WIDGET (tabber),
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
focus_space = focus_width + focus_pad;
tab_space = tab_curvature - tab_overlap;
gtk_widget_set_allocation (widget, allocation);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
x = allocation->x + allocation->width;
break;
case GTK_TEXT_DIR_LTR:
default:
x = allocation->x;
}
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (tabber->priv->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (gtk_widget_get_mapped (widget))
gdk_window_show_unraised (tabber->priv->event_window);
}
if (n_children > 0)
{
gint total_space;
gint total_width;
gboolean use_natural = FALSE;
gint child_equal;
gint extra_space = 0;
gint real_width = allocation->width;
/* Calculate the total space that is used for padding/overlap */
total_space = 2 * tab_curvature
+ 2 * tab_space * (n_children - 1)
+ 2 * focus_space * n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkStateFlags state;
GtkBorder tab_padding;
/* Get the padding of the tab */
gtk_style_context_save (context);
anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL);
gtk_style_context_get_padding (context, state, &tab_padding);
gtk_style_context_restore (context);
total_space += tab_padding.left + tab_padding.right;
}
/* Check if we have enough space for all widgets natural size */
child_equal = (real_width - total_space) / n_children;
if (child_equal < 0)
return;
/* Calculate the total width of the tabs */
total_width = total_space;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
gint natural;
gtk_widget_get_preferred_width (child_widget, NULL,
&natural);
total_width += natural;
if (natural < child_equal)
extra_space += child_equal - natural;
}
use_natural = (total_width <= real_width);
child_equal += extra_space / n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
GtkStateFlags state;
GtkBorder tab_padding, active_padding;
GtkAllocation child_alloc;
gint natural;
gint minimal;
gint begin_tab = tab_space;
gint end_tab = tab_space;
/* Get the padding of the tab */
gtk_style_context_save (context);
anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL);
gtk_style_context_get_padding (context, state, &tab_padding);
gtk_style_context_get_padding (context, state | GTK_STATE_ACTIVE, &active_padding);
gtk_style_context_restore (context);
if (child->prev == NULL)
begin_tab = tab_curvature;
if (child->next == NULL)
end_tab = tab_curvature;
gtk_widget_get_preferred_width (child_widget, &minimal,
&natural);
if (use_natural)
{
child_alloc.width = natural;
}
else
{
if (natural < child_equal)
child_alloc.width = natural;
else
child_alloc.width = child_equal;
}
/* The active pad is by definition at least the same height
* as the inactive one. Therefore we always use the padding of the
* active tab to calculate the height and y position of the child.
*/
child_alloc.height = allocation->height - 2 * focus_space
- active_padding.top - active_padding.bottom;
child_alloc.y = allocation->y + focus_space + active_padding.top;
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
child_alloc.x = x - focus_space - tab_padding.right
- begin_tab - child_alloc.width;
x = child_alloc.x - focus_space - tab_padding.left - end_tab;
break;
case GTK_TEXT_DIR_LTR:
default:
child_alloc.x = x + focus_space + tab_padding.left + begin_tab;
x = child_alloc.x + child_alloc.width + focus_space
+ tab_padding.right + end_tab;
}
gtk_widget_size_allocate (child_widget, &child_alloc);
}
}
}
static void
anjuta_tabber_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
g_return_if_fail (ANJUTA_IS_TABBER (widget));
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
GList* child;
gint focus_width;
gint tab_curvature;
gint tab_overlap;
gint n_children = g_list_length (tabber->priv->children);
gint x;
gint padding;
gint tab_space;
gtk_widget_style_get (GTK_WIDGET (tabber),
"focus-line-width", &focus_width,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
padding = focus_width + tabber->priv->tab_hborder;
tab_space = tab_curvature - tab_overlap;
gtk_widget_set_allocation (widget, allocation);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
x = allocation->x + allocation->width;
break;
case GTK_TEXT_DIR_LTR:
default:
x = allocation->x;
}
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (tabber->priv->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (gtk_widget_get_mapped (widget))
gdk_window_show_unraised (tabber->priv->event_window);
}
if (n_children > 0)
{
gint total_width = 2 * tab_overlap;
gboolean use_natural = FALSE;
gint child_equal;
gint extra_space = 0;
gint real_width = allocation->width;
/* Check if we have enough space for all widgets natural size */
child_equal = real_width / n_children -
n_children * 2 * (padding + tab_space) - 2 * tab_overlap;
if (child_equal < 0)
return;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
gint natural;
gtk_widget_get_preferred_width (child_widget, NULL,
&natural);
total_width += natural + 2 * (padding + tab_space);
if (natural < child_equal)
extra_space += child_equal - natural;
}
use_natural = (total_width <= real_width);
child_equal += extra_space / n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
GtkAllocation child_alloc;
gint natural;
gint minimal;
gint begin_tab = tab_space;
gint end_tab = tab_space;
if (child == g_list_first (tabber->priv->children))
begin_tab += tab_overlap;
if (child == g_list_last (tabber->priv->children))
end_tab += tab_overlap;
gtk_widget_get_preferred_width (child_widget, &minimal,
&natural);
if (use_natural)
{
child_alloc.width = natural;
}
else
{
if (natural < child_equal)
child_alloc.width = natural;
else
child_alloc.width = child_equal;
}
child_alloc.height = allocation->height
- 2 * (focus_width + tabber->priv->tab_vborder);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
child_alloc.x = x - padding - begin_tab - child_alloc.width;
x = child_alloc.x - padding - end_tab;
break;
case GTK_TEXT_DIR_LTR:
default:
child_alloc.x = x + padding + begin_tab;
x = child_alloc.x + child_alloc.width + padding + end_tab;
}
child_alloc.y = allocation->y +
tabber->priv->tab_vborder + focus_width;
gtk_widget_size_allocate (GTK_WIDGET (child->data), &child_alloc);
}
}
}
/* Builds a menu item representing a running application in the
messaging menu */
static gboolean
new_application_item (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client)
{
gchar *cName = g_strdup (dbusmenu_menuitem_property_get(newitem, APPLICATION_MENUITEM_PROP_NAME));
const gchar *sIconName = dbusmenu_menuitem_property_get (newitem, APPLICATION_MENUITEM_PROP_ICON);
cd_debug ("%s (\"%s\")", __func__, cName);
#ifdef FORCE_REMOVE_DOUBLE_ENTRIES
#if (INDICATOR_OLD_NAMES == 0)
if (newitem == NULL || !dbusmenu_menuitem_property_get_bool(newitem, DBUSMENU_MENUITEM_PROP_VISIBLE)
#if INDICATOR_MESSAGES_HAS_LOZENGE == 1
&& sIconName != NULL && *sIconName != '\0' // these menu
#endif
)
{
dbusmenu_menuitem_child_delete (parent, newitem);
cd_debug ("Not visible: %s", cName);
g_free (cName);
return TRUE;
}
#endif
#endif
GtkMenuItem * gmi = GTK_MENU_ITEM(gtk_image_menu_item_new());
gint padding = 4;
gtk_widget_style_get(GTK_WIDGET(gmi), "toggle-spacing", &padding, NULL);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, padding);
// Added for Cairo-Dock
#if INDICATOR_MESSAGES_HAS_LOZENGE == 1 // we add a left margin
if (! dbusmenu_menuitem_property_get_bool(newitem, DBUSMENU_MENUITEM_PROP_VISIBLE)
&& (sIconName == NULL || *sIconName == '\0'))
{
gint width, height;
gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
gtk_widget_set_size_request(GTK_WIDGET (gmi), -1, height + 4);
gtk_widget_set_margin_left (hbox, width + padding);
}
#endif
// end
GtkWidget * icon = gtk_image_new_from_icon_name(sIconName, GTK_ICON_SIZE_MENU);
gtk_misc_set_alignment(GTK_MISC(icon), 1.0 /* right aligned */, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
/* Application name in a label */
GtkWidget * label = gtk_label_new(cName);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(gmi), hbox);
gtk_widget_show_all (GTK_WIDGET (gmi));
/* Attach some of the standard GTK stuff */
dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, gmi, parent);
/* Make sure we can handle the label changing */
g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(application_prop_change_cb), label);
g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(application_icon_change_cb), icon);
g_signal_connect_after(G_OBJECT (gmi), "draw", G_CALLBACK (application_triangle_draw_cb), newitem);
g_free (cName);
return TRUE;
}
static void
gtk_real_check_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
cairo_t *cr)
{
GtkCheckMenuItemPrivate *priv = check_menu_item->priv;
GtkWidget *widget;
gint x, y;
widget = GTK_WIDGET (check_menu_item);
if (gtk_widget_is_drawable (widget))
{
GtkAllocation allocation;
GtkStyleContext *context;
guint border_width;
guint offset;
guint toggle_size;
guint toggle_spacing;
guint horizontal_padding;
guint indicator_size;
GtkStateFlags state;
GtkBorder padding;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_get_padding (context, state, &padding);
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_style_get (widget,
"toggle-spacing", &toggle_spacing,
"horizontal-padding", &horizontal_padding,
"indicator-size", &indicator_size,
NULL);
toggle_size = GTK_MENU_ITEM (check_menu_item)->priv->toggle_size;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
offset = border_width + padding.left + 2;
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
{
x = offset + horizontal_padding +
(toggle_size - toggle_spacing - indicator_size) / 2;
}
else
{
x = allocation.width -
offset - horizontal_padding - toggle_size + toggle_spacing +
(toggle_size - toggle_spacing - indicator_size) / 2;
}
y = (allocation.height - indicator_size) / 2;
gtk_style_context_save (context);
if (priv->inconsistent)
state |= GTK_STATE_FLAG_INCONSISTENT;
else if (priv->active)
state |= GTK_STATE_FLAG_ACTIVE;
gtk_style_context_set_state (context, state);
if (priv->draw_as_radio)
{
gtk_style_context_add_class (context, GTK_STYLE_CLASS_RADIO);
gtk_render_option (context, cr, x, y,
indicator_size, indicator_size);
}
else
{
gtk_style_context_add_class (context, GTK_STYLE_CLASS_CHECK);
gtk_render_check (context, cr, x, y,
indicator_size, indicator_size);
}
gtk_style_context_restore (context);
}
}
static void
draw_expander (ECellTreeView *ectv,
cairo_t *cr,
GtkExpanderStyle expander_style,
GtkStateType state,
GdkRectangle *rect)
{
GtkStyleContext *style_context;
GtkWidget *tree;
GtkStateFlags flags = 0;
gint exp_size;
tree = gtk_widget_get_parent (GTK_WIDGET (ectv->canvas));
style_context = gtk_widget_get_style_context (tree);
gtk_style_context_save (style_context);
gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_EXPANDER);
switch (state) {
case GTK_STATE_PRELIGHT:
flags |= GTK_STATE_FLAG_PRELIGHT;
break;
case GTK_STATE_SELECTED:
flags |= GTK_STATE_FLAG_SELECTED;
break;
case GTK_STATE_INSENSITIVE:
flags |= GTK_STATE_FLAG_INSENSITIVE;
break;
default:
break;
}
/* XXX GTK 3.13.7 broke backward-compat on which state flag controls
* how an expander is drawn.
*
* Older versions used GTK_STATE_FLAG_ACTIVE, 3.13.7 and later
* changed it to GTK_STATE_FLAG_CHECKED.
*
* See https://bugzilla.gnome.org/733967 for details. */
if (expander_style == GTK_EXPANDER_EXPANDED) {
#if GTK_CHECK_VERSION(3,13,7)
flags |= GTK_STATE_FLAG_CHECKED;
#else
flags |= GTK_STATE_FLAG_ACTIVE;
#endif
}
gtk_style_context_set_state (style_context, flags);
gtk_widget_style_get (tree, "expander_size", &exp_size, NULL);
cairo_save (cr);
gtk_render_expander (
style_context, cr,
(gdouble) rect->x + rect->width - exp_size,
(gdouble) (rect->y + rect->height / 2) - (exp_size / 2),
(gdouble) exp_size,
(gdouble) exp_size);
cairo_restore (cr);
gtk_style_context_restore (style_context);
}
static void
setup_main_window (UmUserPanelPrivate *d)
{
GtkWidget *userlist;
GtkTreeModel *model;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GtkWidget *button;
GtkTreeIter iter;
gint expander_size;
gchar *title;
GIcon *icon;
gchar *names[3];
userlist = get_widget (d, "list-treeview");
store = gtk_list_store_new (NUM_USER_LIST_COLS,
UM_TYPE_USER,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT,
G_TYPE_BOOLEAN);
model = (GtkTreeModel *)store;
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), sort_users, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (userlist), model);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (userlist), USER_COL);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (userlist),
match_user, NULL, NULL);
g_object_unref (model);
g_signal_connect (d->um, "users-loaded", G_CALLBACK (users_loaded), d);
gtk_widget_style_get (userlist, "expander-size", &expander_size, NULL);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (userlist), - (expander_size + 6));
title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("My Account"));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
TITLE_COL, title,
HEADING_ROW_COL, TRUE,
SORT_KEY_COL, 0,
AUTOLOGIN_COL, FALSE,
-1);
g_free (title);
title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("Other Accounts"));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
TITLE_COL, title,
HEADING_ROW_COL, TRUE,
SORT_KEY_COL, 2,
AUTOLOGIN_COL, FALSE,
-1);
g_free (title);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "pixbuf", FACE_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", NAME_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", TITLE_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", HEADING_ROW_COL);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
gtk_tree_view_column_set_cell_data_func (column,
cell,
(GtkTreeCellDataFunc) autologin_cell_data_func,
d,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (userlist), column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (userlist));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed", G_CALLBACK (selected_user_changed), d);
gtk_tree_selection_set_select_function (selection, dont_select_headings, NULL, NULL);
gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (get_widget (d, "list-scrolledwindow")), 300);
gtk_widget_set_size_request (get_widget (d, "list-scrolledwindow"), 200, -1);
button = get_widget (d, "add-user-toolbutton");
g_signal_connect (button, "clicked", G_CALLBACK (add_user), d);
button = get_widget (d, "remove-user-toolbutton");
g_signal_connect (button, "clicked", G_CALLBACK (delete_user), d);
button = get_widget (d, "user-icon-nonbutton");
add_unlock_tooltip (button);
button = get_widget (d, "full-name-entry");
g_signal_connect (button, "editing-done", G_CALLBACK (change_name_done), d);
button = get_widget (d, "account-type-combo");
g_signal_connect (button, "editing-done", G_CALLBACK (account_type_changed), d);
button = get_widget (d, "account-password-button");
g_signal_connect (button, "start-editing", G_CALLBACK (change_password), d);
button = get_widget (d, "account-language-combo");
g_signal_connect (button, "editing-done", G_CALLBACK (language_changed), d);
button = get_widget (d, "autologin-switch");
g_signal_connect (button, "notify::active", G_CALLBACK (autologin_changed), d);
button = get_widget (d, "account-fingerprint-button");
g_signal_connect (button, "clicked",
G_CALLBACK (change_fingerprint), d);
d->permission = (GPermission *)polkit_permission_new_sync ("org.freedesktop.accounts.user-administration", NULL, NULL, NULL);
g_signal_connect (d->permission, "notify",
G_CALLBACK (on_permission_changed), d);
on_permission_changed (d->permission, NULL, d);
button = get_widget (d, "add-user-toolbutton");
names[0] = "changes-allow-symbolic";
names[1] = "changes-allow";
names[2] = NULL;
icon = (GIcon *)g_themed_icon_new_from_names (names, -1);
setup_tooltip_with_embedded_icon (button,
_("To create a user account,\nclick the * icon first"),
"*",
icon);
button = get_widget (d, "remove-user-toolbutton");
setup_tooltip_with_embedded_icon (button,
_("To delete the selected user account,\nclick the * icon first"),
"*",
icon);
g_object_unref (icon);
}
static void
ect_print (ECellView *ecell_view,
GtkPrintContext *context,
gint model_col,
gint view_col,
gint row,
gdouble width,
gdouble height)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
cairo_t *cr = gtk_print_context_get_cairo_context (context);
cairo_save (cr);
if (E_CELL_TREE (tree_view->cell_view.ecell)->grouped_view) {
ETreeModel *tree_model = e_cell_tree_get_tree_model (ecell_view->e_table_model, row);
ETreeTableAdapter *tree_table_adapter = e_cell_tree_get_tree_table_adapter (ecell_view->e_table_model, row);
ETreePath node = e_cell_tree_get_node (ecell_view->e_table_model, row);
gint offset = offset_of_node (ecell_view->e_table_model, row);
gint subcell_offset = offset;
gboolean expandable = e_tree_model_node_is_expandable (tree_model, node);
/* draw our lines */
if (E_CELL_TREE (tree_view->cell_view.ecell)->draw_lines) {
gint depth;
if (!e_tree_model_node_is_root (tree_model, node)
|| e_tree_model_node_get_n_children (tree_model, node) > 0) {
cairo_move_to (
cr,
offset - INDENT_AMOUNT / 2,
height / 2);
cairo_line_to (cr, offset, height / 2);
}
if (visible_depth_of_node (ecell_view->e_table_model, row) != 0) {
cairo_move_to (
cr,
offset - INDENT_AMOUNT / 2, height);
cairo_line_to (
cr,
offset - INDENT_AMOUNT / 2,
e_tree_table_adapter_node_get_next
(tree_table_adapter, node) ? 0 :
height / 2);
}
/* now traverse back up to the root of the tree, checking at
* each level if the node has siblings, and drawing the
* correct vertical pipe for it's configuration. */
node = e_tree_model_node_get_parent (tree_model, node);
depth = visible_depth_of_node (ecell_view->e_table_model, row) - 1;
offset -= INDENT_AMOUNT;
while (node && depth != 0) {
if (e_tree_table_adapter_node_get_next (tree_table_adapter, node)) {
cairo_move_to (
cr,
offset - INDENT_AMOUNT / 2,
height);
cairo_line_to (
cr,
offset - INDENT_AMOUNT / 2, 0);
}
node = e_tree_model_node_get_parent (tree_model, node);
depth--;
offset -= INDENT_AMOUNT;
}
}
/* now draw our icon if we're expandable */
if (expandable) {
gboolean expanded;
GdkRectangle r;
gint exp_size = 0;
gtk_widget_style_get (GTK_WIDGET (gtk_widget_get_parent (GTK_WIDGET (tree_view->canvas))), "expander_size", &exp_size, NULL);
node = e_cell_tree_get_node (ecell_view->e_table_model, row);
expanded = e_tree_table_adapter_node_is_expanded (tree_table_adapter, node);
r.x = 0;
r.y = 0;
r.width = MIN (width, exp_size);
r.height = height;
draw_expander (tree_view, cr, expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED, GTK_STATE_NORMAL, &r);
}
cairo_stroke (cr);
cairo_translate (cr, subcell_offset, 0);
width -= subcell_offset;
}
cairo_restore (cr);
e_cell_print (tree_view->subcell_view, context, model_col, view_col, row, width, height);
}
void wxAuiGtkTabArt::DrawTab(wxDC& dc, wxWindow* wnd, const wxAuiNotebookPage& page,
const wxRect& in_rect, int close_button_state, wxRect* out_tab_rect,
wxRect* out_button_rect, int* x_extent)
{
GtkWidget *widget = wnd->GetHandle();
GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());
wxRect const &window_rect = wnd->GetRect();
int focus_width = 0;
gtk_widget_style_get(wxGTKPrivate::GetNotebookWidget(),
"focus-line-width", &focus_width,
NULL);
int tab_pos;
if (m_flags &wxAUI_NB_BOTTOM)
tab_pos = wxAUI_NB_BOTTOM;
else //if (m_flags & wxAUI_NB_TOP) {}
tab_pos = wxAUI_NB_TOP;
// TODO: else if (m_flags &wxAUI_NB_LEFT) {}
// TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
// figure out the size of the tab
wxSize tab_size = GetTabSize(dc, wnd, page.caption, page.bitmap,
page.active, close_button_state, x_extent);
wxRect tab_rect = in_rect;
tab_rect.width = tab_size.x;
tab_rect.height = tab_size.y;
tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
if (page.active)
tab_rect.height += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
// if no bitmap is set, we need a tiny correction
if (! page.bitmap.IsOk())
tab_rect.height += 1;
int gap_rect_height = 6 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
int gap_rect_x = 1, gap_start = 0, gap_width = 0;
int gap_rect_y = tab_rect.y - gap_rect_height;
int gap_rect_width = window_rect.width;
switch (tab_pos)
{
case wxAUI_NB_TOP:
tab_rect.y -= 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
if (!page.active)
tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
gap_rect_y = tab_rect.y + tab_rect.height - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
// fall through
case wxAUI_NB_BOTTOM:
gap_start = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder / 2;
gap_width = tab_rect.width;
break;
// TODO: case wxAUI_NB_LEFT: break;
// TODO: case wxAUI_NB_RIGHT: break;
}
tab_rect.y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
gap_rect_y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
int padding = focus_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
int clip_width = tab_rect.width;
if (tab_rect.x + tab_rect.width > in_rect.x + in_rect.width)
clip_width = (in_rect.x + in_rect.width) - tab_rect.x;
dc.SetClippingRegion(tab_rect.x, tab_rect.y - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder, clip_width, tab_rect.height + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder);
GdkRectangle area;
area.x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
area.y = tab_rect.y - 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
area.width = clip_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
area.height = tab_rect.height + 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
GdkWindow* window = impldc->GetGDKWindow();
if (tab_pos == wxAUI_NB_BOTTOM)
{
if (page.active)
{
gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height,
GTK_POS_BOTTOM, gap_start , gap_width);
}
gtk_paint_extension(style_notebook, window,
page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
&area, widget,
const_cast<char*>("tab"),
tab_rect.x, tab_rect.y,
tab_rect.width, tab_rect.height,
GTK_POS_TOP);
}
else
{
if (page.active)
{
gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height,
GTK_POS_TOP, gap_start , gap_width);
}
gtk_paint_extension(style_notebook, window,
page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
&area, widget,
const_cast<char*>("tab"),
tab_rect.x, tab_rect.y,
tab_rect.width, tab_rect.height,
GTK_POS_BOTTOM);
}
wxCoord textX = tab_rect.x + padding + style_notebook->xthickness;
int bitmap_offset = 0;
if (page.bitmap.IsOk())
{
bitmap_offset = textX;
// draw bitmap
int bitmapY = tab_rect.y +(tab_rect.height - page.bitmap.GetHeight()) / 2;
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
bitmapY += style_notebook->ythickness / 2;
else
bitmapY -= style_notebook->ythickness / 2;
}
dc.DrawBitmap(page.bitmap,
bitmap_offset,
bitmapY,
true);
textX += page.bitmap.GetWidth() + padding;
}
wxCoord textW, textH, textY;
dc.SetFont(m_normalFont);
dc.GetTextExtent(page.caption, &textW, &textH);
textY = tab_rect.y + (tab_rect.height - textH) / 2;
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
textY += style_notebook->ythickness / 2;
else
textY -= style_notebook->ythickness / 2;
}
// draw tab text
GdkColor text_colour = page.active ? style_notebook->fg[GTK_STATE_NORMAL] : style_notebook->fg[GTK_STATE_ACTIVE];
dc.SetTextForeground(wxColor(text_colour));
GdkRectangle focus_area;
int padding_focus = padding - focus_width;
focus_area.x = tab_rect.x + padding_focus;
focus_area.y = textY - focus_width;
focus_area.width = tab_rect.width - 2 * padding_focus;
focus_area.height = textH + 2 * focus_width;
if(page.active && (wnd->FindFocus() == wnd) && focus_area.x <= (area.x + area.width))
{
// clipping seems not to work here, so we we have to recalc the focus-area manually
if((focus_area.x + focus_area.width) > (area.x + area.width))
focus_area.width = area.x + area.width - focus_area.x + focus_width - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
gtk_paint_focus (style_notebook, window,
GTK_STATE_ACTIVE, NULL, widget, "tab",
focus_area.x, focus_area.y, focus_area.width, focus_area.height);
}
dc.DrawText(page.caption, textX, textY);
// draw close-button on tab (if enabled)
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
wxRect rect(tab_rect.x, tab_rect.y, tab_rect.width - style_notebook->xthickness, tab_rect.height);
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
rect.y += style_notebook->ythickness / 2;
else
rect.y -= style_notebook->ythickness / 2;
}
*out_button_rect = DrawCloseButton(dc, widget, close_button_state, rect, wxRIGHT, &area);
}
tab_rect.width = std::min(tab_rect.width, clip_width);
*out_tab_rect = tab_rect;
dc.DestroyClippingRegion();
}
void
gimp_enum_radio_frame_add (GtkFrame *frame,
GtkWidget *widget,
gint enum_value)
{
GtkWidget *vbox;
GList *children;
GList *list;
gint pos;
g_return_if_fail (GTK_IS_FRAME (frame));
g_return_if_fail (GTK_IS_WIDGET (widget));
vbox = gtk_bin_get_child (GTK_BIN (frame));
g_return_if_fail (GTK_IS_VBOX (vbox));
children = gtk_container_get_children (GTK_CONTAINER (vbox));
for (list = children, pos = 1;
list;
list = g_list_next (list), pos++)
{
if (GTK_IS_RADIO_BUTTON (list->data) &&
GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) ==
enum_value)
{
GtkWidget *radio = list->data;
GtkWidget *hbox;
GtkWidget *spacer;
gint indicator_size;
gint indicator_spacing;
gint focus_width;
gint focus_padding;
gtk_widget_style_get (radio,
"indicator-size", &indicator_size,
"indicator-spacing", &indicator_spacing,
"focus-line-width", &focus_width,
"focus-padding", &focus_padding,
NULL);
hbox = gtk_hbox_new (FALSE, 0);
spacer = gtk_vbox_new (FALSE, 0);
gtk_widget_set_size_request (spacer,
indicator_size +
3 * indicator_spacing +
focus_width +
focus_padding +
GTK_CONTAINER (radio)->border_width,
-1);
gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0);
gtk_widget_show (spacer);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
g_object_set_data (G_OBJECT (radio), "set_sensitive", hbox);
g_signal_connect (radio, "toggled",
G_CALLBACK (gimp_toggle_button_sensitive_update),
NULL);
gtk_widget_set_sensitive (hbox,
GTK_TOGGLE_BUTTON (list->data)->active);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (vbox), hbox, pos);
gtk_widget_show (hbox);
break;
}
}
g_list_free (children);
}
static int button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
DEBUG_FUNCTION ("button_press_cb");
DEBUG_ASSERT (data != NULL);
VteTerminal *terminal;
tilda_term *tt;
gchar *match;
gint tag;
gint xpad, ypad;
gchar *cmd;
gchar *web_browser_cmd;
gboolean ret = FALSE;
tt = TILDA_TERM(data);
switch (event->button)
{
case 3: /* Right Click */
popup_menu (tt->tw, tt);
break;
case 2: /* Middle Click */
break;
case 1: /* Left Click */
terminal = VTE_TERMINAL(tt->vte_term);
GtkBorder border;
gtk_widget_style_get (GTK_WIDGET (terminal),
"inner-border", &border, NULL);
xpad = border.left;
ypad = border.bottom;
match = vte_terminal_match_check (terminal,
(event->x - ypad) /
vte_terminal_get_char_width (terminal),
(event->y - ypad) /
vte_terminal_get_char_height (terminal),
&tag);
/* Check if we can launch a web browser, and do so if possible */
if ((event->state & GDK_CONTROL_MASK) && match != NULL)
{
#if DEBUG
g_print ("Got a Ctrl+Left Click -- Matched: `%s' (%d)\n", match, tag);
#endif
web_browser_cmd = g_strescape (config_getstr ("web_browser"), NULL);
cmd = g_strdup_printf ("%s %s", web_browser_cmd, match);
#if DEBUG
g_print ("Launching command: `%s'\n", cmd);
#endif
ret = g_spawn_command_line_async(cmd, NULL);
/* Check that the command launched */
if (!ret)
{
g_printerr (_("Failed to launch the web browser. The command was `%s'\n"), cmd);
TILDA_PERROR ();
}
g_free (cmd);
}
/* Always free match if it is non NULL */
if (match)
g_free (match);
break;
default:
break;
}
return FALSE;
}
static void
gimp_tag_popup_constructed (GObject *object)
{
GimpTagPopup *popup = GIMP_TAG_POPUP (object);
GimpTaggedContainer *container;
GtkWidget *entry;
GtkAllocation entry_allocation;
GtkStyle *frame_style;
gint x;
gint y;
gint width;
gint height;
gint popup_height;
GHashTable *tag_hash;
GList *tag_list;
GList *tag_iterator;
gint i;
gint max_height;
gint screen_height;
gchar **current_tags;
gint current_count;
GdkRectangle popup_rects[2]; /* variants of popup placement */
GdkRectangle popup_rect; /* best popup rect in screen coordinates */
G_OBJECT_CLASS (parent_class)->constructed (object);
entry = GTK_WIDGET (popup->combo_entry);
gtk_window_set_screen (GTK_WINDOW (popup), gtk_widget_get_screen (entry));
popup->context = gtk_widget_create_pango_context (GTK_WIDGET (popup));
popup->layout = pango_layout_new (popup->context);
gtk_widget_get_allocation (entry, &entry_allocation);
gtk_widget_style_get (GTK_WIDGET (popup),
"scroll-arrow-vlength", &popup->scroll_arrow_height,
NULL);
pango_layout_set_attributes (popup->layout,
popup->combo_entry->normal_item_attr);
current_tags = gimp_tag_entry_parse_tags (GIMP_TAG_ENTRY (popup->combo_entry));
current_count = g_strv_length (current_tags);
container = GIMP_TAG_ENTRY (popup->combo_entry)->container;
tag_hash = container->tag_ref_counts;
tag_list = g_hash_table_get_keys (tag_hash);
tag_list = g_list_sort (tag_list, gimp_tag_compare_func);
popup->tag_count = g_list_length (tag_list);
popup->tag_data = g_new0 (PopupTagData, popup->tag_count);
for (i = 0, tag_iterator = tag_list;
i < popup->tag_count;
i++, tag_iterator = g_list_next (tag_iterator))
{
PopupTagData *tag_data = &popup->tag_data[i];
gint j;
tag_data->tag = tag_iterator->data;
tag_data->state = GTK_STATE_NORMAL;
g_object_ref (tag_data->tag);
for (j = 0; j < current_count; j++)
{
if (! gimp_tag_compare_with_string (tag_data->tag, current_tags[j]))
{
tag_data->state = GTK_STATE_SELECTED;
break;
}
}
}
g_list_free (tag_list);
g_strfreev (current_tags);
if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{
for (i = 0; i < popup->tag_count; i++)
{
if (popup->tag_data[i].state != GTK_STATE_SELECTED)
{
popup->tag_data[i].state = GTK_STATE_INSENSITIVE;
}
}
gimp_container_foreach (GIMP_CONTAINER (container),
(GFunc) gimp_tag_popup_check_can_toggle,
popup);
}
frame_style = gtk_widget_get_style (popup->frame);
width = (entry_allocation.width -
2 * frame_style->xthickness);
height = (gimp_tag_popup_layout_tags (popup, width) +
2 * frame_style->ythickness);
gdk_window_get_origin (gtk_widget_get_window (entry), &x, &y);
max_height = entry_allocation.height * 10;
screen_height = gdk_screen_get_height (gtk_widget_get_screen (entry));
popup_height = MIN (height, max_height);
popup_rects[0].x = x;
popup_rects[0].y = 0;
popup_rects[0].width = entry_allocation.width;
popup_rects[0].height = y + entry_allocation.height;
popup_rects[1].x = x;
popup_rects[1].y = y;
popup_rects[1].width = popup_rects[0].width;
popup_rects[1].height = screen_height - popup_rects[0].height;
if (popup_rects[0].height >= popup_height)
{
popup_rect = popup_rects[0];
popup_rect.y += popup_rects[0].height - popup_height;
popup_rect.height = popup_height;
}
else if (popup_rects[1].height >= popup_height)
{
popup_rect = popup_rects[1];
popup_rect.height = popup_height;
}
else
{
if (popup_rects[0].height >= popup_rects[1].height)
{
popup_rect = popup_rects[0];
popup_rect.y += popup->scroll_arrow_height + frame_style->ythickness;
}
else
{
popup_rect = popup_rects[1];
popup_rect.y -= popup->scroll_arrow_height + frame_style->ythickness;
}
popup_height = popup_rect.height;
}
if (popup_height < height)
{
popup->arrows_visible = TRUE;
popup->upper_arrow_state = GTK_STATE_INSENSITIVE;
gtk_alignment_set_padding (GTK_ALIGNMENT (popup->alignment),
popup->scroll_arrow_height + 2,
popup->scroll_arrow_height + 2, 0, 0);
popup_height -= 2 * popup->scroll_arrow_height + 4;
popup->scroll_height = height - popup_height;
popup->scroll_y = 0;
popup->scroll_step = 0;
}
gtk_widget_set_size_request (popup->tag_area, width, popup_height);
gtk_window_move (GTK_WINDOW (popup), popup_rect.x, popup_rect.y);
gtk_window_resize (GTK_WINDOW (popup), popup_rect.width, popup_rect.height);
}
static void
get_expander_bounds (GtkExpander *expander,
GdkRectangle *rect)
{
GtkWidget *widget;
GtkExpanderPrivate *priv;
gint border_width;
gint expander_size;
gint expander_spacing;
gboolean interior_focus;
gint focus_width;
gint focus_pad;
gboolean ltr;
widget = GTK_WIDGET (expander);
priv = expander->priv;
border_width = GTK_CONTAINER (expander)->border_width;
gtk_widget_style_get (widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"expander-size", &expander_size,
"expander-spacing", &expander_spacing,
NULL);
ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
rect->x = widget->allocation.x + border_width;
rect->y = widget->allocation.y + border_width;
if (ltr)
rect->x += expander_spacing;
else
rect->x += widget->allocation.width - 2 * border_width -
expander_spacing - expander_size;
if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation;
label_allocation = priv->label_widget->allocation;
if (expander_size < label_allocation.height)
rect->y += focus_width + focus_pad + (label_allocation.height - expander_size) / 2;
else
rect->y += expander_spacing;
}
else
{
rect->y += expander_spacing;
}
if (!interior_focus)
{
if (ltr)
rect->x += focus_width + focus_pad;
else
rect->x -= focus_width + focus_pad;
rect->y += focus_width + focus_pad;
}
rect->width = rect->height = expander_size;
}
static gboolean
gtk_switch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkStyleContext *context;
GdkRectangle handle;
PangoLayout *layout;
PangoFontDescription *desc;
const PangoFontDescription *style_desc;
PangoRectangle rect;
gint label_x, label_y;
GtkStateFlags state;
GtkBorder padding;
gint focus_width, focus_pad;
gint x, y, width, height;
gint font_size, style_font_size;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
if (priv->is_active)
state |= GTK_STATE_FLAG_ACTIVE;
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
gtk_style_context_get_padding (context, state, &padding);
gtk_style_context_restore (context);
x = 0;
y = 0;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
if (gtk_widget_has_focus (widget))
gtk_render_focus (context, cr, x, y, width, height);
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TROUGH);
gtk_style_context_set_state (context, state);
gtk_render_background (context, cr, x, y, width, height);
gtk_render_frame (context, cr, x, y, width, height);
width -= padding.left + padding.right;
height -= padding.top + padding.bottom;
x += padding.left;
y += padding.top;
handle.y = y;
handle.width = width / 2;
handle.height = height;
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
/* FIXME: this should be really done in the theme, but overriding font size
* from it doesn't currently work. So we have to hardcode this here and
* below for the "OFF" label.
*/
desc = pango_font_description_new ();
style_desc = gtk_style_context_get_font (context, state);
style_font_size = pango_font_description_get_size (style_desc);
font_size = MAX (style_font_size - 1 * PANGO_SCALE, ceil (style_font_size * PANGO_SCALE_SMALL));
pango_font_description_set_size (desc, font_size);
pango_layout_set_font_description (layout, desc);
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
/* Translators: if the "off" state label requires more than three
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "OFF"));
pango_layout_set_font_description (layout, desc);
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + (width / 2) + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
if (priv->is_dragging)
handle.x = x + priv->handle_x;
else if (priv->is_active)
handle.x = x + width - handle.width;
else
handle.x = x;
gtk_style_context_restore (context);
gtk_switch_paint_handle (widget, cr, &handle);
pango_font_description_free (desc);
return FALSE;
}
static void
gtk_expander_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkExpander *expander;
GtkBin *bin;
GtkExpanderPrivate *priv;
GtkRequisition child_requisition;
gboolean child_visible = FALSE;
gint border_width;
gint expander_size;
gint expander_spacing;
gboolean interior_focus;
gint focus_width;
gint focus_pad;
gint label_height;
expander = GTK_EXPANDER (widget);
bin = GTK_BIN (widget);
priv = expander->priv;
border_width = GTK_CONTAINER (widget)->border_width;
gtk_widget_style_get (widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"expander-size", &expander_size,
"expander-spacing", &expander_spacing,
NULL);
child_requisition.width = 0;
child_requisition.height = 0;
if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
{
child_visible = TRUE;
gtk_widget_get_child_requisition (bin->child, &child_requisition);
}
widget->allocation = *allocation;
if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation;
GtkRequisition label_requisition;
gboolean ltr;
gtk_widget_get_child_requisition (priv->label_widget, &label_requisition);
ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
if (priv->label_fill)
label_allocation.x = (widget->allocation.x +
border_width + focus_width + focus_pad +
expander_size + 2 * expander_spacing);
else if (ltr)
label_allocation.x = (widget->allocation.x +
border_width + focus_width + focus_pad +
expander_size + 2 * expander_spacing);
else
label_allocation.x = (widget->allocation.x + widget->allocation.width -
(label_requisition.width +
border_width + focus_width + focus_pad +
expander_size + 2 * expander_spacing));
label_allocation.y = widget->allocation.y + border_width + focus_width + focus_pad;
if (priv->label_fill)
label_allocation.width = allocation->width - 2 * border_width -
expander_size - 2 * expander_spacing -
2 * focus_width - 2 * focus_pad;
else
label_allocation.width = MIN (label_requisition.width,
allocation->width - 2 * border_width -
expander_size - 2 * expander_spacing -
2 * focus_width - 2 * focus_pad);
label_allocation.width = MAX (label_allocation.width, 1);
label_allocation.height = MIN (label_requisition.height,
allocation->height - 2 * border_width -
2 * focus_width - 2 * focus_pad -
(child_visible ? priv->spacing : 0));
label_allocation.height = MAX (label_allocation.height, 1);
gtk_widget_size_allocate (priv->label_widget, &label_allocation);
label_height = label_allocation.height;
}
else
{
label_height = 0;
}
if (gtk_widget_get_realized (widget))
{
GdkRectangle rect;
get_expander_bounds (expander, &rect);
gdk_window_move_resize (priv->event_window,
allocation->x + border_width,
allocation->y + border_width,
MAX (allocation->width - 2 * border_width, 1),
MAX (rect.height, label_height - 2 * border_width));
}
if (child_visible)
{
GtkAllocation child_allocation;
gint top_height;
top_height = MAX (2 * expander_spacing + expander_size,
label_height +
(interior_focus ? 2 * focus_width + 2 * focus_pad : 0));
child_allocation.x = widget->allocation.x + border_width;
child_allocation.y = widget->allocation.y + border_width + top_height + priv->spacing;
if (!interior_focus)
child_allocation.y += 2 * focus_width + 2 * focus_pad;
child_allocation.width = MAX (allocation->width - 2 * border_width, 1);
child_allocation.height = allocation->height - top_height -
2 * border_width - priv->spacing -
(!interior_focus ? 2 * focus_width + 2 * focus_pad : 0);
child_allocation.height = MAX (child_allocation.height, 1);
gtk_widget_size_allocate (bin->child, &child_allocation);
}
}
static void
gtk_tool_button_construct_contents (GtkToolItem *tool_item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
GtkWidget *label = NULL;
GtkWidget *icon = NULL;
GtkToolbarStyle style;
gboolean need_label = FALSE;
gboolean need_icon = FALSE;
GtkIconSize icon_size;
GtkWidget *box = NULL;
guint icon_spacing;
GtkOrientation text_orientation = GTK_ORIENTATION_HORIZONTAL;
GtkSizeGroup *size_group = NULL;
button->priv->contents_invalid = FALSE;
gtk_widget_style_get (GTK_WIDGET (tool_item),
"icon-spacing", &icon_spacing,
NULL);
if (button->priv->icon_widget && button->priv->icon_widget->parent)
{
gtk_container_remove (GTK_CONTAINER (button->priv->icon_widget->parent),
button->priv->icon_widget);
}
if (button->priv->label_widget && button->priv->label_widget->parent)
{
gtk_container_remove (GTK_CONTAINER (button->priv->label_widget->parent),
button->priv->label_widget);
}
if (GTK_BIN (button->priv->button)->child)
{
/* Note: we are not destroying the label_widget or icon_widget
* here because they were removed from their containers above
*/
gtk_widget_destroy (GTK_BIN (button->priv->button)->child);
}
style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
if (style != GTK_TOOLBAR_TEXT)
need_icon = TRUE;
if (style != GTK_TOOLBAR_ICONS && style != GTK_TOOLBAR_BOTH_HORIZ)
need_label = TRUE;
if (style == GTK_TOOLBAR_BOTH_HORIZ &&
(gtk_tool_item_get_is_important (GTK_TOOL_ITEM (button)) ||
gtk_tool_item_get_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL ||
gtk_tool_item_get_text_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL))
{
need_label = TRUE;
}
if (style == GTK_TOOLBAR_ICONS && button->priv->icon_widget == NULL &&
button->priv->stock_id == NULL && button->priv->icon_name == NULL)
{
need_label = TRUE;
need_icon = FALSE;
style = GTK_TOOLBAR_TEXT;
}
if (style == GTK_TOOLBAR_TEXT && button->priv->label_widget == NULL &&
button->priv->stock_id == NULL && button->priv->label_text == NULL)
{
need_label = FALSE;
need_icon = TRUE;
style = GTK_TOOLBAR_ICONS;
}
if (need_label)
{
if (button->priv->label_widget)
{
label = button->priv->label_widget;
}
else
{
GtkStockItem stock_item;
gboolean elide;
gchar *label_text;
if (button->priv->label_text)
{
label_text = button->priv->label_text;
elide = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label_text = stock_item.label;
elide = TRUE;
}
else
{
label_text = "";
elide = FALSE;
}
if (elide)
label_text = _gtk_toolbar_elide_underscores (label_text);
else
label_text = g_strdup (label_text);
label = gtk_label_new (label_text);
g_free (label_text);
gtk_widget_show (label);
}
gtk_label_set_ellipsize (GTK_LABEL (label),
gtk_tool_item_get_ellipsize_mode (GTK_TOOL_ITEM (button)));
text_orientation = gtk_tool_item_get_text_orientation (GTK_TOOL_ITEM (button));
if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_label_set_angle (GTK_LABEL (label), 0);
gtk_misc_set_alignment (GTK_MISC (label),
gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button)),
0.5);
}
else
{
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_NONE);
if (gtk_widget_get_direction (GTK_WIDGET (tool_item)) == GTK_TEXT_DIR_RTL)
gtk_label_set_angle (GTK_LABEL (label), -90);
else
gtk_label_set_angle (GTK_LABEL (label), 90);
gtk_misc_set_alignment (GTK_MISC (label),
0.5,
1 - gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button)));
}
}
icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
if (need_icon)
{
if (button->priv->icon_widget)
{
icon = button->priv->icon_widget;
if (GTK_IS_IMAGE (icon))
{
g_object_set (button->priv->icon_widget,
"icon-size", icon_size,
NULL);
}
}
else if (button->priv->stock_id &&
gtk_icon_factory_lookup_default (button->priv->stock_id))
{
icon = gtk_image_new_from_stock (button->priv->stock_id, icon_size);
gtk_widget_show (icon);
}
else if (button->priv->icon_name)
{
icon = gtk_image_new_from_icon_name (button->priv->icon_name, icon_size);
gtk_widget_show (icon);
}
if (icon && text_orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_misc_set_alignment (GTK_MISC (icon),
1.0 - gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button)),
0.5);
else if (icon)
gtk_misc_set_alignment (GTK_MISC (icon),
0.5,
gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button)));
if (icon)
{
size_group = gtk_tool_item_get_text_size_group (GTK_TOOL_ITEM (button));
if (size_group != NULL)
gtk_size_group_add_widget (size_group, icon);
}
}
switch (style)
{
case GTK_TOOLBAR_ICONS:
if (icon)
gtk_container_add (GTK_CONTAINER (button->priv->button), icon);
break;
case GTK_TOOLBAR_BOTH:
if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
box = gtk_vbox_new (FALSE, icon_spacing);
else
box = gtk_hbox_new (FALSE, icon_spacing);
if (icon)
gtk_box_pack_start (GTK_BOX (box), icon, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (box), label, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (button->priv->button), box);
break;
case GTK_TOOLBAR_BOTH_HORIZ:
if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
{
box = gtk_hbox_new (FALSE, icon_spacing);
if (icon)
gtk_box_pack_start (GTK_BOX (box), icon, label? FALSE : TRUE, TRUE, 0);
if (label)
gtk_box_pack_end (GTK_BOX (box), label, TRUE, TRUE, 0);
}
else
{
box = gtk_vbox_new (FALSE, icon_spacing);
if (icon)
gtk_box_pack_end (GTK_BOX (box), icon, label ? FALSE : TRUE, TRUE, 0);
if (label)
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
}
gtk_container_add (GTK_CONTAINER (button->priv->button), box);
break;
case GTK_TOOLBAR_TEXT:
gtk_container_add (GTK_CONTAINER (button->priv->button), label);
break;
}
if (box)
gtk_widget_show (box);
gtk_button_set_relief (GTK_BUTTON (button->priv->button),
gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (button)));
gtk_tool_item_rebuild_menu (tool_item);
gtk_widget_queue_resize (GTK_WIDGET (button));
}
static void
gtk_expander_paint_focus (GtkExpander *expander,
GdkRectangle *area)
{
GtkWidget *widget;
GtkExpanderPrivate *priv;
GdkRectangle rect;
gint x, y, width, height;
gboolean interior_focus;
gint border_width;
gint focus_width;
gint focus_pad;
gint expander_size;
gint expander_spacing;
gboolean ltr;
widget = GTK_WIDGET (expander);
priv = expander->priv;
border_width = GTK_CONTAINER (widget)->border_width;
gtk_widget_style_get (widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"expander-size", &expander_size,
"expander-spacing", &expander_spacing,
NULL);
ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
width = height = 0;
if (priv->label_widget)
{
if (gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation = priv->label_widget->allocation;
width = label_allocation.width;
height = label_allocation.height;
}
width += 2 * focus_pad + 2 * focus_width;
height += 2 * focus_pad + 2 * focus_width;
x = widget->allocation.x + border_width;
y = widget->allocation.y + border_width;
if (ltr)
{
if (interior_focus)
x += expander_spacing * 2 + expander_size;
}
else
{
x += widget->allocation.width - 2 * border_width
- expander_spacing * 2 - expander_size - width;
}
if (!interior_focus)
{
width += expander_size + 2 * expander_spacing;
height = MAX (height, expander_size + 2 * expander_spacing);
}
}
else
{
get_expander_bounds (expander, &rect);
x = rect.x - focus_pad;
y = rect.y - focus_pad;
width = rect.width + 2 * focus_pad;
height = rect.height + 2 * focus_pad;
}
gtk_paint_focus (widget->style, widget->window, gtk_widget_get_state (widget),
area, widget, "expander",
x, y, width, height);
}
static void
gtk_image_menu_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkImageMenuItem *image_menu_item;
GtkPackDirection pack_dir;
if (GTK_IS_MENU_BAR (widget->parent))
pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent));
else
pack_dir = GTK_PACK_DIRECTION_LTR;
image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);
if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image))
{
gint x, y, offset;
GtkRequisition child_requisition;
GtkAllocation child_allocation;
guint horizontal_padding, toggle_spacing;
gtk_widget_style_get (widget,
"horizontal-padding", &horizontal_padding,
"toggle-spacing", &toggle_spacing,
NULL);
/* Man this is lame hardcoding action, but I can't
* come up with a solution that's really better.
*/
gtk_widget_get_child_requisition (image_menu_item->image,
&child_requisition);
if (pack_dir == GTK_PACK_DIRECTION_LTR ||
pack_dir == GTK_PACK_DIRECTION_RTL)
{
offset = GTK_CONTAINER (image_menu_item)->border_width +
widget->style->xthickness;
if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
(pack_dir == GTK_PACK_DIRECTION_LTR))
x = offset + horizontal_padding +
(GTK_MENU_ITEM (image_menu_item)->toggle_size -
toggle_spacing - child_requisition.width) / 2;
else
x = widget->allocation.width - offset - horizontal_padding -
GTK_MENU_ITEM (image_menu_item)->toggle_size + toggle_spacing +
(GTK_MENU_ITEM (image_menu_item)->toggle_size -
toggle_spacing - child_requisition.width) / 2;
y = (widget->allocation.height - child_requisition.height) / 2;
}
else
{
offset = GTK_CONTAINER (image_menu_item)->border_width +
widget->style->ythickness;
if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
(pack_dir == GTK_PACK_DIRECTION_TTB))
y = offset + horizontal_padding +
(GTK_MENU_ITEM (image_menu_item)->toggle_size -
toggle_spacing - child_requisition.height) / 2;
else
y = widget->allocation.height - offset - horizontal_padding -
GTK_MENU_ITEM (image_menu_item)->toggle_size + toggle_spacing +
(GTK_MENU_ITEM (image_menu_item)->toggle_size -
toggle_spacing - child_requisition.height) / 2;
x = (widget->allocation.width - child_requisition.width) / 2;
}
child_allocation.width = child_requisition.width;
child_allocation.height = child_requisition.height;
child_allocation.x = widget->allocation.x + MAX (x, 0);
child_allocation.y = widget->allocation.y + MAX (y, 0);
gtk_widget_size_allocate (image_menu_item->image, &child_allocation);
}
}
static void
he_check_button_construct_child (HeCheckButton *button)
{
HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (button);
GtkWidget *child;
gint image_spacing;
const gchar *title, *value;
/* Don't do anything if the button is not constructed yet */
if (G_UNLIKELY (priv->label_box == NULL))
return;
/* Don't do anything if the button has no contents */
title = gtk_label_get_text (priv->title);
value = gtk_label_get_text (priv->value);
if (!title[0] && !value[0])
return;
/* Remove the parent if there is one */
if (priv->cell_view) {
g_object_ref (priv->cell_view);
if (priv->cell_view->parent != NULL)
gtk_container_remove (GTK_CONTAINER (priv->cell_view->parent), priv->cell_view);
}
if (priv->label_box->parent != NULL) {
gtk_container_remove (GTK_CONTAINER (priv->label_box->parent), priv->label_box);
}
/* Remove the child from the container and add priv->alignment */
child = gtk_bin_get_child (GTK_BIN (button));
if (child != NULL && child != priv->alignment) {
gtk_container_remove (GTK_CONTAINER (button), child);
child = NULL;
}
if (child == NULL) {
gtk_container_add (GTK_CONTAINER (button), GTK_WIDGET (priv->alignment));
}
/* Create a new hbox */
if (priv->hbox) {
gtk_container_remove (GTK_CONTAINER (priv->alignment), GTK_WIDGET (priv->hbox));
}
gtk_widget_style_get (GTK_WIDGET (button), "image-spacing", &image_spacing, NULL);
priv->hbox = GTK_BOX (gtk_hbox_new (FALSE, image_spacing));
gtk_container_add (GTK_CONTAINER (priv->alignment), GTK_WIDGET (priv->hbox));
/* All left align */
gtk_alignment_set(GTK_ALIGNMENT(priv->alignment), 0, 0.5, -1, -1);
/* Add check box and box with labels */
gtk_box_pack_start (priv->hbox, priv->cell_view, FALSE, FALSE, 0);
gtk_box_pack_start (priv->hbox, priv->label_box, TRUE, TRUE, 0);
/* Remove the ref */
g_object_unref (priv->cell_view);
/* Show everything */
gtk_widget_show_all (GTK_WIDGET (priv->alignment));
}
void conterm_init(void)
{
GtkWidget *console;
#ifdef G_OS_UNIX
gchar *error = NULL;
int pty_master;
char *pty_name;
#endif
last_console_fd = -1;
#ifdef G_OS_UNIX
pty_slave = -1;
slave_pty_name = NULL;
program_window = get_widget("program_window");
console = vte_terminal_new();
gtk_widget_show(console);
program_terminal = VTE_TERMINAL(console);
g_object_ref(program_terminal);
gtk_container_add(GTK_CONTAINER(program_window), console);
g_signal_connect_after(program_terminal, "realize", G_CALLBACK(on_vte_realize), NULL);
terminal_parent = get_widget("terminal_parent");
g_signal_connect(terminal_parent, "delete-event", G_CALLBACK(on_terminal_parent_delete),
NULL);
terminal_window = get_widget("terminal_window");
terminal_show = GTK_CHECK_MENU_ITEM(get_widget("terminal_show"));
if (pref_terminal_padding)
{
gint vte_border_x, vte_border_y;
#if VTE_CHECK_VERSION(0, 24, 0)
GtkBorder *border = NULL;
gtk_widget_style_get(console, "inner-border", &border, NULL);
if (border)
{
vte_border_x = border->left + border->right;
vte_border_y = border->top + border->bottom;
gtk_border_free(border);
}
else
vte_border_x = vte_border_y = 2;
#else /* VTE 0.24.0 */
/* VTE manual says "deprecated since 0.26", but it's since 0.24 */
vte_terminal_get_padding(program_terminal, &vte_border_x, &vte_border_y);
#endif /* VTE 0.24.0 */
pref_terminal_width += vte_border_x;
pref_terminal_height += vte_border_y;
pref_terminal_padding = FALSE;
}
if (openpty(&pty_master, &pty_slave, NULL, NULL, NULL) == 0 &&
grantpt(pty_master) == 0 && unlockpt(pty_master) == 0 &&
(pty_name = ttyname(pty_slave)) != NULL)
{
#if VTE_CHECK_VERSION(0, 25, 0)
GError *gerror = NULL;
VtePty *pty = vte_pty_new_foreign(pty_master, &gerror);
if (pty)
{
vte_terminal_set_pty_object(program_terminal, pty);
slave_pty_name = g_strdup(pty_name);
}
else
{
error = g_strdup(gerror->message);
g_error_free(gerror);
}
#else /* VTE 0.25.0 */
vte_terminal_set_pty(program_terminal, pty_master);
slave_pty_name = g_strdup(pty_name);
#endif /* VTE 0.25.0 */
}
else
error = g_strdup_printf("pty: %s", g_strerror(errno));
if (error)
{
gtk_widget_set_sensitive(program_window, FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(terminal_show), FALSE);
msgwin_status_add(_("Scope: %s."), error);
g_free(error);
}
else
menu_connect("terminal_menu", &terminal_menu_info, GTK_WIDGET(program_terminal));
#else /* G_OS_UNIX */
gtk_widget_hide(get_widget("program_window"));
#endif /* G_OS_UNIX */
#ifdef G_OS_UNIX
if (pref_debug_console_vte)
{
console = vte_terminal_new();
gtk_widget_show(console);
debug_console = VTE_TERMINAL(console);
dc_output = console_output;
dc_output_nl = console_output_nl;
g_signal_connect_after(debug_console, "realize", G_CALLBACK(on_vte_realize), NULL);
menu_connect("console_menu", &console_menu_info, console);
}
else
#endif /* G_OS_UNIX */
{
static const char *const colors[NFD] = { "#00C0C0", "#C0C0C0", "#C00000",
"#C0C0C0", "#C000C0" };
guint i;
#ifdef G_OS_UNIX
debug_console = NULL;
#endif
dc_chars = 0;
console = get_widget("debug_context");
context_apply_config(console);
debug_context = GTK_TEXT_VIEW(console);
dc_output = context_output;
dc_output_nl = context_output_nl;
context = gtk_text_view_get_buffer(debug_context);
for (i = 0; i < NFD; i++)
{
fd_tags[i] = gtk_text_buffer_create_tag(context, NULL, "foreground",
colors[i], NULL);
}
g_signal_connect(console, "button-press-event",
G_CALLBACK(on_console_button_3_press),
menu_connect("console_menu", &console_menu_info, NULL));
}
gtk_container_add(GTK_CONTAINER(get_widget("debug_window")), console);
g_signal_connect(console, "key-press-event", G_CALLBACK(on_console_key_press), NULL);
}
static PRInt32 CheckWidgetStyle(GtkWidget* aWidget, const char* aStyle, PRInt32 aResult) {
gboolean value = FALSE;
gtk_widget_style_get(aWidget, aStyle, &value, NULL);
return value ? aResult : 0;
}
