// This API exists since gtk+ 3.10
extern void gtk_window_set_titlebar (GtkWindow *window, GtkWidget *titlebar) {
if(!is_compatible_gtk_version() || !are_csd_disabled()) {
orig_gtk_window_set_titlebar(window, titlebar);
return;
}
if (titlebar && is_gtk_version_larger_or_equal (3, 16, 1)) {
/* We have to reimplement gtk_window_set_titlebar ourselves, since
* those Gtk versions don't support turning CSD off anymore.
* This mainly does the same things as the original function
* (consisting of adding the title bar widget + connecting signals),
* but it will not enable CSD and not set the client_decorated flag
* in the window private space. (We wouldn't know which bit it is
* anyway.) */
gtk_window_private_info_t private_info = gtk_window_private_info ();
char *priv = G_TYPE_INSTANCE_GET_PRIVATE (window, gtk_window_type, char);
gboolean was_mapped = FALSE;
GtkWidget *widget = GTK_WIDGET (window);
GtkWidget **title_box_ptr = NULL;
/* Something went wrong, so just stick with the original
* implementation. */
if (private_info.title_box_offset < 0 || !priv)
goto orig_impl;
title_box_ptr = (GtkWidget **) &priv[private_info.title_box_offset];
if (!*title_box_ptr) {
was_mapped = gtk_widget_get_mapped (widget);
if (gtk_widget_get_realized (widget)) {
g_warning ("gtk_window_set_titlebar() called on a realized window");
gtk_widget_unrealize (widget);
}
}
/* Remove any potential old title bar. We can't call
* the static unset_titlebar() directly (not available),
* so we call the full function; that shouldn't have
* any side effects. */
orig_gtk_window_set_titlebar (window, NULL);
/* The solid-csd class is not removed when the titlebar
* is unset in Gtk (it's probably a bug), so unset it
* here explicitly, in case it's set. */
gtk_style_context_remove_class (gtk_widget_get_style_context (widget), "solid-csd");
/* We need to store the titlebar in priv->title_box,
* which is where title_box_ptr points to. Then we
* need to reparent the title bar and connect signals
* if it's a GtkHeaderBar. Apart from CSD enablement,
* this is what the original function boils down to.
*/
*title_box_ptr = titlebar;
gtk_widget_set_parent (*title_box_ptr, widget);
if (GTK_IS_HEADER_BAR (titlebar)) {
g_signal_connect (titlebar, "notify::title",
G_CALLBACK (private_info.on_titlebar_title_notify), window);
private_info.on_titlebar_title_notify (GTK_HEADER_BAR (titlebar), NULL, window);
}
gtk_style_context_add_class (gtk_widget_get_style_context (titlebar),
GTK_STYLE_CLASS_TITLEBAR);
if (was_mapped)
gtk_widget_map (widget);
return;
}
static void
panel_applet_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
PanelApplet *applet;
GtkAllocation child_allocation;
GtkAllocation widget_allocation;
GtkBin *bin;
GtkWidget *child;
GdkWindow *window;
int border_width;
int focus_width = 0;
applet = PANEL_APPLET (widget);
bin = GTK_BIN (widget);
gtk_widget_get_allocation (widget, &widget_allocation);
if (!panel_applet_can_focus (widget) && !applet->priv->has_handle) {
GTK_WIDGET_CLASS (panel_applet_parent_class)->size_allocate (widget, allocation);
} else {
gtk_widget_set_allocation (widget, allocation);
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
window = gtk_widget_get_window (widget);
/*
* We are deliberately ignoring focus-padding here to
* save valuable panel real estate.
*/
gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
child_allocation.x = allocation->x;
child_allocation.y = allocation->y;
child_allocation.width = allocation->width;
child_allocation.height = allocation->height;
if (applet->priv->has_handle) {
applet->priv->handle_rect.x = 0;
applet->priv->handle_rect.y = 0;
switch (panel_applet_get_orient (applet)) {
case PANEL_APPLET_ORIENT_UP:
case PANEL_APPLET_ORIENT_DOWN:
applet->priv->handle_rect.width = HANDLE_SIZE;
applet->priv->handle_rect.height = allocation->height;
if (gtk_widget_get_direction (GTK_WIDGET (applet)) != GTK_TEXT_DIR_RTL) {
applet->priv->handle_rect.x = 0;
child_allocation.x = HANDLE_SIZE;
} else {
applet->priv->handle_rect.x = allocation->width - HANDLE_SIZE;
child_allocation.x = 0;
}
child_allocation.y = 0;
child_allocation.width = allocation->width - HANDLE_SIZE;
child_allocation.height = allocation->height;
break;
case PANEL_APPLET_ORIENT_LEFT:
case PANEL_APPLET_ORIENT_RIGHT:
applet->priv->handle_rect.width = allocation->width;
applet->priv->handle_rect.height = HANDLE_SIZE;
child_allocation.x = 0;
child_allocation.y = HANDLE_SIZE;
child_allocation.width = allocation->width;
child_allocation.height = allocation->height - HANDLE_SIZE;
break;
default:
g_assert_not_reached ();
break;
}
child_allocation.width = MAX (1, child_allocation.width);
child_allocation.height = MAX (1, child_allocation.height);
}
if (panel_applet_can_focus (widget)) {
child_allocation.x += focus_width;
child_allocation.y += focus_width;
}
child_allocation.width = MAX (child_allocation.width - border_width * 2, 0);
child_allocation.height = MAX (child_allocation.height - border_width * 2, 0);
if (gtk_widget_get_realized (widget)) {
gdk_window_move_resize (window,
allocation->x + border_width,
allocation->y + border_width,
MAX (allocation->width - border_width * 2, 0),
MAX (allocation->height - border_width * 2, 0));
}
if (panel_applet_can_focus (widget)) {
child_allocation.width = MAX (child_allocation.width - 2 * focus_width, 0);
child_allocation.height = MAX (child_allocation.height - 2 * focus_width, 0);
}
child = gtk_bin_get_child (bin);
if (child && gtk_widget_get_visible (child))
gtk_widget_size_allocate (child, &child_allocation);
}
}
bool wxGLCanvas::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name,
const int *attribList,
const wxPalette& palette)
{
#if wxUSE_PALETTE
wxASSERT_MSG( !palette.IsOk(), wxT("palettes not supported") );
#endif // wxUSE_PALETTE
wxUnusedVar(palette); // Unused when wxDEBUG_LEVEL==0
m_exposed = false;
m_noExpose = true;
m_nativeSizeEvent = true;
#ifdef __WXGTK3__
m_cairoPaintContext = NULL;
m_backgroundStyle = wxBG_STYLE_PAINT;
#endif
if ( !InitVisual(attribList) )
return false;
// watch for the "parent-set" signal on m_wxwindow so we can set colormap
// before m_wxwindow is realized (which will occur before
// wxWindow::Create() returns if parent is already visible)
unsigned sig_id = g_signal_lookup("parent-set", GTK_TYPE_WIDGET);
g_signal_add_emission_hook(sig_id, 0, parent_set_hook, this, NULL);
wxWindow::Create( parent, id, pos, size, style, name );
gtk_widget_set_double_buffered(m_wxwindow, false);
#if WXWIN_COMPATIBILITY_2_8
g_signal_connect(m_wxwindow, "realize", G_CALLBACK(gtk_glwindow_realized_callback), this);
#endif // WXWIN_COMPATIBILITY_2_8
#ifdef __WXGTK3__
g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this);
#else
g_signal_connect(m_wxwindow, "map", G_CALLBACK(gtk_glwindow_map_callback), this);
g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(gtk_glwindow_expose_callback), this);
#endif
g_signal_connect(m_widget, "size_allocate", G_CALLBACK(gtk_glcanvas_size_callback), this);
#if WXWIN_COMPATIBILITY_2_8
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (gtk_widget_get_realized(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
#endif // WXWIN_COMPATIBILITY_2_8
#ifndef __WXGTK3__
if (gtk_widget_get_mapped(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
#endif
return true;
}
static void
ddb_tabstrip_realize (GtkWidget *widget) {
DdbTabStrip *darea = DDB_TABSTRIP (widget);
GdkWindowAttr attributes;
gint attributes_mask;
if (!gtk_widget_get_has_window (widget))
{
GTK_WIDGET_CLASS (ddb_tabstrip_parent_class)->realize (widget);
}
else
{
gtk_widget_set_realized (widget, TRUE);
attributes.window_type = GDK_WINDOW_CHILD;
GtkAllocation a;
gtk_widget_get_allocation (widget, &a);
attributes.x = a.x;
attributes.y = a.y;
attributes.width = a.width;
attributes.height = a.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
#if !GTK_CHECK_VERSION(3,0,0)
attributes.colormap = gtk_widget_get_colormap (widget);
#endif
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
#if !GTK_CHECK_VERSION(3,0,0)
attributes_mask |= GDK_WA_COLORMAP;
#endif
gtk_widget_set_window(widget, gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask));
gdk_window_set_user_data (gtk_widget_get_window(widget), darea);
gtk_widget_set_style (widget, gtk_style_attach (gtk_widget_get_style (widget), gtk_widget_get_window(widget)));
gtk_style_set_background (gtk_widget_get_style (widget), gtk_widget_get_window(widget), GTK_STATE_NORMAL);
}
ddb_tabstrip_send_configure (DDB_TABSTRIP (widget));
GtkTargetEntry entry = {
.target = "STRING",
.flags = GTK_TARGET_SAME_APP,
TARGET_SAMEWIDGET
};
gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, &entry, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_uri_targets (widget);
gtk_drag_dest_set_track_motion (widget, TRUE);
}
static void
ddb_tabstrip_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
g_return_if_fail (DDB_IS_TABSTRIP (widget));
g_return_if_fail (allocation != NULL);
gtk_widget_set_allocation (widget, allocation);
if (gtk_widget_get_realized (widget))
{
if (gtk_widget_get_has_window (widget))
gdk_window_move_resize (gtk_widget_get_window(widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
ddb_tabstrip_send_configure (DDB_TABSTRIP (widget));
}
}
/* serverside */
static void
on_message_received (const char *message,
gpointer data)
{
const PlumaEncoding *encoding = NULL;
gchar **commands;
gchar **params;
gint workspace;
gint viewport_x;
gint viewport_y;
gchar *display_name;
gint screen_number;
gint i;
PlumaApp *app;
PlumaWindow *window;
GdkDisplay *display;
GdkScreen *screen;
g_return_if_fail (message != NULL);
pluma_debug_message (DEBUG_APP, "Received message:\n%s\n", message);
commands = g_strsplit (message, "\v", -1);
/* header */
params = g_strsplit (commands[0], "\t", 6);
startup_timestamp = atoi (params[0]);
display_name = params[1];
screen_number = atoi (params[2]);
workspace = atoi (params[3]);
viewport_x = atoi (params[4]);
viewport_y = atoi (params[5]);
display = display_open_if_needed (display_name);
if (display == NULL)
{
g_warning ("Could not open display %s\n", display_name);
g_strfreev (params);
goto out;
}
screen = gdk_display_get_screen (display, screen_number);
g_strfreev (params);
/* body */
for (i = 1; commands[i] != NULL; i++)
{
params = g_strsplit (commands[i], "\t", -1);
if (strcmp (params[0], "NEW-WINDOW") == 0)
{
new_window_option = TRUE;
}
else if (strcmp (params[0], "NEW-DOCUMENT") == 0)
{
new_document_option = TRUE;
}
else if (strcmp (params[0], "OPEN-URIS") == 0)
{
gint n_uris, j;
gchar **uris;
line_position = atoi (params[1]);
if (params[2] != '\0')
encoding = pluma_encoding_get_from_charset (params[2]);
n_uris = atoi (params[3]);
uris = g_strsplit (params[4], " ", n_uris);
for (j = 0; j < n_uris; j++)
{
GFile *file;
file = g_file_new_for_uri (uris[j]);
file_list = g_slist_prepend (file_list, file);
}
file_list = g_slist_reverse (file_list);
/* the list takes ownerhip of the strings,
* only free the array */
g_free (uris);
}
else
{
g_warning ("Unexpected bacon command");
}
g_strfreev (params);
}
/* execute the commands */
app = pluma_app_get_default ();
if (new_window_option)
{
window = pluma_app_create_window (app, screen);
}
else
{
/* get a window in the current workspace (if exists) and raise it */
window = _pluma_app_get_window_in_viewport (app,
screen,
workspace,
viewport_x,
viewport_y);
}
if (file_list != NULL)
{
_pluma_cmd_load_files_from_prompt (window,
file_list,
encoding,
line_position);
if (new_document_option)
pluma_window_create_tab (window, TRUE);
}
else
{
PlumaDocument *doc;
doc = pluma_window_get_active_document (window);
if (doc == NULL ||
!pluma_document_is_untouched (doc) ||
new_document_option)
pluma_window_create_tab (window, TRUE);
}
/* set the proper interaction time on the window.
* Fall back to roundtripping to the X server when we
* don't have the timestamp, e.g. when launched from
* terminal. We also need to make sure that the window
* has been realized otherwise it will not work. lame.
*/
if (!gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_widget_realize (GTK_WIDGET (window));
if (startup_timestamp <= 0)
startup_timestamp = gdk_x11_get_server_time (gtk_widget_get_window (GTK_WIDGET (window)));
gdk_x11_window_set_user_time (gtk_widget_get_window (GTK_WIDGET (window)),
startup_timestamp);
gtk_window_present (GTK_WINDOW (window));
out:
g_strfreev (commands);
free_command_line_data ();
}
bool wxTopLevelWindowGTK::Show( bool show )
{
wxCHECK_MSG(m_widget, false, "invalid frame");
#ifdef GDK_WINDOWING_X11
bool deferShow = show && !m_isShown && m_deferShow;
if (deferShow)
{
deferShow = m_deferShowAllowed &&
gs_requestFrameExtentsStatus != RFE_STATUS_BROKEN &&
!gtk_widget_get_realized(m_widget) &&
GDK_IS_X11_DISPLAY(gtk_widget_get_display(m_widget)) &&
g_signal_handler_find(m_widget,
GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
0, NULL, NULL, this);
if (deferShow)
{
GdkScreen* screen = gtk_widget_get_screen(m_widget);
GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
// If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
// to m_decorSize, it breaks saving/restoring window size with
// GetSize()/SetSize() because it makes window bigger between each
// restore and save.
m_updateDecorSize = deferShow;
}
m_deferShow = deferShow;
}
if (deferShow)
{
// Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
// calling gtk_widget_show() until _NET_FRAME_EXTENTS property
// notification is received, so correct frame extents are known.
// This allows resizing m_widget to keep the overall size in sync with
// what wxWidgets expects it to be without an obvious change in the
// window size immediately after it becomes visible.
// Realize m_widget, so m_widget->window can be used. Realizing normally
// causes the widget tree to be size_allocated, which generates size
// events in the wrong order. However, the size_allocates will not be
// done if the allocation is not the default (1,1).
GtkAllocation alloc;
gtk_widget_get_allocation(m_widget, &alloc);
const int alloc_width = alloc.width;
if (alloc_width == 1)
{
alloc.width = 2;
gtk_widget_set_allocation(m_widget, &alloc);
}
gtk_widget_realize(m_widget);
if (alloc_width == 1)
{
alloc.width = 1;
gtk_widget_set_allocation(m_widget, &alloc);
}
// send _NET_REQUEST_FRAME_EXTENTS
XClientMessageEvent xevent;
memset(&xevent, 0, sizeof(xevent));
xevent.type = ClientMessage;
GdkWindow* window = gtk_widget_get_window(m_widget);
xevent.window = GDK_WINDOW_XID(window);
xevent.message_type = gdk_x11_atom_to_xatom_for_display(
gdk_window_get_display(window),
gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
xevent.format = 32;
Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
XSendEvent(display, DefaultRootWindow(display), false,
SubstructureNotifyMask | SubstructureRedirectMask,
(XEvent*)&xevent);
if (gs_requestFrameExtentsStatus == RFE_STATUS_UNKNOWN)
{
// if WM does not respond to request within 1 second,
// we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
m_netFrameExtentsTimerId =
g_timeout_add(1000, request_frame_extents_timeout, this);
}
// defer calling gtk_widget_show()
m_isShown = true;
return true;
}
#endif // GDK_WINDOWING_X11
if (show && !gtk_widget_get_realized(m_widget))
{
// size_allocate signals occur in reverse order (bottom to top).
// Things work better if the initial wxSizeEvents are sent (from the
// top down), before the initial size_allocate signals occur.
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
#ifdef __WXGTK3__
GTKSizeRevalidate();
#endif
}
bool change = base_type::Show(show);
if (change && !show)
{
// make sure window has a non-default position, so when it is shown
// again, it won't be repositioned by WM as if it were a new window
// Note that this must be done _after_ the window is hidden.
gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
}
return change;
}
static gboolean accessx_status_applet_fill(MatePanelApplet* applet)
{
AccessxStatusApplet* sapplet;
AtkObject* atk_object;
GtkActionGroup* action_group;
gchar* ui_path;
gboolean was_realized = FALSE;
sapplet = create_applet(applet);
if (!gtk_widget_get_realized(sapplet->box))
{
g_signal_connect_after(G_OBJECT(sapplet->box), "realize", G_CALLBACK(accessx_status_applet_realize), sapplet);
}
else
{
accessx_status_applet_initialize(sapplet);
was_realized = TRUE;
}
g_object_connect(sapplet->applet,
"signal::destroy", accessx_status_applet_destroy, sapplet,
"signal::change_orient", accessx_status_applet_reorient, sapplet,
"signal::change_size", accessx_status_applet_resize, sapplet,
#if !GTK_CHECK_VERSION (3, 0, 0)
"signal::change_background", accessx_status_applet_background, sapplet,
#endif
NULL);
g_signal_connect(sapplet->applet, "button_press_event", G_CALLBACK(button_press_cb), sapplet);
g_signal_connect(sapplet->applet, "key_press_event", G_CALLBACK(key_press_cb), sapplet);
action_group = gtk_action_group_new("Accessx Applet Actions");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions(action_group, accessx_status_applet_menu_actions, G_N_ELEMENTS(accessx_status_applet_menu_actions), sapplet);
ui_path = g_build_filename(ACCESSX_MENU_UI_DIR, "accessx-status-applet-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file(sapplet->applet, ui_path, action_group);
g_free(ui_path);
if (mate_panel_applet_get_locked_down(sapplet->applet))
{
GtkAction* action = gtk_action_group_get_action(action_group, "Dialog");
gtk_action_set_visible(action, FALSE);
}
g_object_unref(action_group);
gtk_widget_set_tooltip_text(GTK_WIDGET(sapplet->applet), _("Keyboard Accessibility Status"));
atk_object = gtk_widget_get_accessible(GTK_WIDGET(sapplet->applet));
atk_object_set_name(atk_object, _("AccessX Status"));
atk_object_set_description(atk_object, _("Displays current state of keyboard accessibility features"));
gtk_widget_show_all(GTK_WIDGET(sapplet->applet));
if (was_realized)
{
accessx_status_applet_reset(sapplet);
}
mate_panel_applet_set_background_widget (sapplet->applet, GTK_WIDGET (sapplet->applet));
return TRUE;
}
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);
}
static void
widget_overlay_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
{
WidgetOverlay *ovl = WIDGET_OVERLAY (widget);
gint border_width;
gint w, h;
gtk_widget_set_allocation (widget, allocation);
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
w = allocation->width - border_width * 2;
h = allocation->height - border_width * 2;
if (gtk_widget_get_realized (widget)) {
GdkWindow *win;
win = gtk_widget_get_window (widget);
gdk_window_move_resize (win,
allocation->x + border_width,
allocation->y + border_width,
w, h);
}
GList *list;
for (list = ovl->priv->children; list; list = list->next) {
ChildData *cd = (ChildData*) list->data;
if (gtk_widget_get_visible (cd->child)){
GtkRequisition child_requisition;
GtkAllocation child_allocation;
gtk_widget_get_preferred_size (cd->child, &child_requisition, NULL);
child_allocation.x = 0;
child_allocation.y = 0;
child_allocation.height = child_requisition.height;
child_allocation.width = child_requisition.width;
if (cd->halign == WIDGET_OVERLAY_ALIGN_FILL)
child_allocation.width = w / cd->scale;
if ((cd->valign == WIDGET_OVERLAY_ALIGN_FILL) ||
(cd == ovl->priv->scale_child))
child_allocation.height = h / cd->scale;
if (cd->is_tooltip) {
cd->scale = 1.;
if ((allocation->width > 0) && (allocation->height > 0)) {
if (child_allocation.width > allocation->width)
cd->scale = (gdouble) allocation->width /
(gdouble) child_allocation.width;
if (child_allocation.height > allocation->height) {
if (cd->scale > ((gdouble) allocation->height /
(gdouble) child_allocation.height))
cd->scale = (gdouble) allocation->height /
(gdouble) child_allocation.height;
}
}
}
if (gtk_widget_get_realized (widget))
gdk_window_move_resize (cd->offscreen_window,
child_allocation.x,
child_allocation.y,
child_allocation.width,
child_allocation.height);
child_allocation.x = child_allocation.y = 0;
gtk_widget_size_allocate (cd->child, &child_allocation);
}
}
}
/* Establish the widget placement of an icon grid. */
static void panel_icon_grid_size_allocate(GtkWidget *widget,
GtkAllocation *allocation)
{
PanelIconGrid *ig = PANEL_ICON_GRID(widget);
GtkRequisition req;
GtkAllocation child_allocation;
int child_width;
int child_height;
GtkTextDirection direction;
guint border;
int x_delta;
guint next_coord;
guint x, y;
GList *ige;
GtkWidget *child;
/* Apply given allocation */
gtk_widget_set_allocation(widget, allocation);
border = gtk_container_get_border_width(GTK_CONTAINER(widget));
child_allocation.width = MAX(allocation->width - border * 2, 0);
child_allocation.height = MAX(allocation->height - border * 2, 0);
if (gtk_widget_get_realized(widget))
{
if (!gtk_widget_get_has_window(widget))
{
child_allocation.x = allocation->x + border;
child_allocation.y = allocation->y + border;
}
else
{
child_allocation.x = 0;
child_allocation.y = 0;
}
if (ig->event_window != NULL)
gdk_window_move_resize(ig->event_window,
child_allocation.x,
child_allocation.y,
child_allocation.width,
child_allocation.height);
if (gtk_widget_get_has_window(widget))
gdk_window_move_resize(gtk_widget_get_window(widget),
allocation->x + border,
allocation->y + border,
child_allocation.width,
child_allocation.height);
}
/* Get and save the desired container geometry. */
if (ig->orientation == GTK_ORIENTATION_HORIZONTAL && allocation->height > 1)
ig->target_dimension = allocation->height;
else if (ig->orientation == GTK_ORIENTATION_VERTICAL && allocation->width > 1)
ig->target_dimension = allocation->width;
child_width = ig->child_width;
child_height = ig->child_height;
/* FIXME: is there any sense to recheck rows and columns again?
GTK+ should have it done right before this call. */
/* Get the constrained child geometry if the allocated geometry is insufficient.
* All children are still the same size and share equally in the deficit. */
if ((ig->columns != 0) && (ig->rows != 0) && (child_allocation.width > 0))
{
if (ig->constrain_width &&
(x_delta = (child_allocation.width + ig->spacing) / ig->columns - ig->spacing) < child_width)
child_width = MAX(2, x_delta);
/* fill vertical space evenly in horisontal orientation */
if (ig->orientation == GTK_ORIENTATION_HORIZONTAL &&
(x_delta = (child_allocation.height + ig->spacing) / ig->rows - ig->spacing) > child_height)
child_height = MAX(2, x_delta);
}
/* Initialize parameters to control repositioning each visible child. */
direction = gtk_widget_get_direction(widget);
x = (direction == GTK_TEXT_DIR_RTL) ? allocation->width - border : border;
y = border;
x_delta = 0;
next_coord = border;
/* Reposition each visible child. */
for (ige = ig->children; ige != NULL; ige = ige->next)
{
child = ige->data;
if (gtk_widget_get_visible(child))
{
/* Do necessary operations on the child. */
gtk_widget_get_child_requisition(child, &req);
icon_grid_element_check_requisition(ig, &req);
child_allocation.width = MIN(req.width, child_width);
child_allocation.height = MIN(req.height, child_height);
/* Check this grid position */
if (ig->orientation == GTK_ORIENTATION_HORIZONTAL)
{
y = next_coord;
if (y + child_height > allocation->height - border && y > border)
{
y = border;
if (direction == GTK_TEXT_DIR_RTL)
x -= (x_delta + ig->spacing);
else
x += (x_delta + ig->spacing);
x_delta = 0;
// FIXME: if fill_width and rows = 1 then allocate whole column
}
next_coord = y + child_height + ig->spacing;
x_delta = MAX(x_delta, child_allocation.width);
}
else
{
// FIXME: if fill_width then use aspect to check delta
if (direction == GTK_TEXT_DIR_RTL)
{
next_coord = x - child_allocation.width;
if (x < allocation->width - border)
{
next_coord -= ig->spacing;
if (next_coord < border)
{
next_coord = allocation->width - border;
y += child_height + ig->spacing;
}
}
x = next_coord;
}
else
{
x = next_coord;
if (x + child_allocation.width > allocation->width - border && x > border)
{
x = border;
y += child_height + ig->spacing;
}
next_coord = x + child_allocation.width + ig->spacing;
}
}
child_allocation.x = x;
if (req.height < child_height - 1)
y += (child_height - req.height) / 2;
child_allocation.y = y;
if (!gtk_widget_get_has_window (widget))
{
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
}
// FIXME: if fill_width and rows > 1 then delay allocation
gtk_widget_size_allocate(child, &child_allocation);
}
}
}
/**
* gimp_button_menu_position:
* @button: a button widget to popup the menu from
* @menu: the menu to position
* @position: the preferred popup direction for the menu (left or right)
* @x: return location for x coordinate
* @y: return location for y coordinate
*
* Utility function to position a menu that pops up from a button.
**/
void
gimp_button_menu_position (GtkWidget *button,
GtkMenu *menu,
GtkPositionType position,
gint *x,
gint *y)
{
GdkScreen *screen;
GtkAllocation button_allocation;
GtkRequisition menu_requisition;
GdkRectangle rect;
gint monitor;
g_return_if_fail (GTK_IS_WIDGET (button));
g_return_if_fail (gtk_widget_get_realized (button));
g_return_if_fail (GTK_IS_MENU (menu));
g_return_if_fail (x != NULL);
g_return_if_fail (y != NULL);
gtk_widget_get_allocation (button, &button_allocation);
if (gtk_widget_get_direction (button) == GTK_TEXT_DIR_RTL)
{
switch (position)
{
case GTK_POS_LEFT: position = GTK_POS_RIGHT; break;
case GTK_POS_RIGHT: position = GTK_POS_LEFT; break;
default:
break;
}
}
*x = 0;
*y = 0;
if (! gtk_widget_get_has_window (button))
{
*x += button_allocation.x;
*y += button_allocation.y;
}
gdk_window_get_root_coords (gtk_widget_get_window (button), *x, *y, x, y);
gtk_widget_size_request (GTK_WIDGET (menu), &menu_requisition);
screen = gtk_widget_get_screen (button);
monitor = gdk_screen_get_monitor_at_point (screen, *x, *y);
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
gtk_menu_set_screen (menu, screen);
switch (position)
{
case GTK_POS_LEFT:
*x -= menu_requisition.width;
if (*x < rect.x)
*x += menu_requisition.width + button_allocation.width;
break;
case GTK_POS_RIGHT:
*x += button_allocation.width;
if (*x + menu_requisition.width > rect.x + rect.width)
*x -= button_allocation.width + menu_requisition.width;
break;
default:
g_warning ("%s: unhandled position (%d)", G_STRFUNC, position);
break;
}
*y += button_allocation.height / 2;
if (*y + menu_requisition.height > rect.y + rect.height)
*y -= menu_requisition.height;
if (*y < rect.y)
*y = rect.y;
}
static void
append_widget(GtkTreeStore *model,
GtkWidget *widget,
GtkTreeIter *parent_iter)
{
GtkTreeIter iter;
const char *class_name = G_OBJECT_CLASS_NAME(GTK_WIDGET_GET_CLASS(widget));
const char *name;
char *row_color = NULL;
char *window_info;
char *address;
gboolean realized;
gboolean mapped;
gboolean visible;
GList *l;
name = gtk_widget_get_name(widget);
if (name == NULL || strcmp(name, class_name) == 0) {
if (GTK_IS_LABEL(widget))
{
name = gtk_label_get_text(GTK_LABEL(widget));
}
else if (GTK_IS_BUTTON(widget))
{
name = gtk_button_get_label(GTK_BUTTON(widget));
}
else if (GTK_IS_WINDOW(widget))
{
name = gtk_window_get_title(GTK_WINDOW(widget));
}
else
{
name = "";
}
}
if (gtk_widget_get_window(widget))
{
#if HAVE_X11
window_info = g_strdup_printf("%p (XID 0x%x)", widget->window,
(int)GDK_WINDOW_XID(widget->window));
#else
window_info = g_strdup("");
#endif
}
else
{
window_info = g_strdup("");
}
address = g_strdup_printf("%p", widget);
realized = gtk_widget_get_realized(widget);
mapped = gtk_widget_get_mapped(widget);
visible = gtk_widget_get_visible(widget);
if (!realized || !mapped || !visible)
{
GtkStyle* style = gtk_widget_get_style(GTK_WIDGET(widget));
GdkColor color = style->fg[GTK_STATE_INSENSITIVE];
row_color = gdk_color_to_string(&color);
}
gtk_tree_store_append(model, &iter, parent_iter);
gtk_tree_store_set(model, &iter,
WIDGET, widget,
WIDGET_TYPE, class_name,
WIDGET_NAME, name,
WIDGET_REALIZED, realized,
WIDGET_MAPPED, mapped,
WIDGET_VISIBLE, visible,
WIDGET_WINDOW, window_info,
WIDGET_ADDRESS, address,
ROW_COLOR, row_color,
-1);
g_free(window_info);
g_free(address);
g_free(row_color);
if (GTK_IS_CONTAINER(widget))
{
GList* children = NULL;
/* Pick up all children, including those that are internal. */
gtk_container_forall(GTK_CONTAINER(widget),
on_container_forall, &children);
for (l = children; l != NULL; l = l->next)
{
append_widget(model, GTK_WIDGET(l->data), &iter);
}
g_list_free(children);
}
}
static void
gtk_notification_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkNotification *notification = GTK_NOTIFICATION (widget);
GtkNotificationPrivate *priv = notification->priv;
GtkBin *bin = GTK_BIN (widget);
GtkAllocation child_allocation;
GtkBorder padding;
GtkRequisition button_req;
GtkWidget *child;
gtk_widget_set_allocation (widget, allocation);
/* If somehow the notification changes while not hidden
and we're not animating, immediately follow the resize */
if (priv->animate_y > 0 &&
!priv->animate_timeout)
priv->animate_y = allocation->height;
get_padding_and_border (notification, &padding);
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x,
allocation->y,
allocation->width,
allocation->height);
gdk_window_move_resize (priv->bin_window,
0,
-allocation->height + priv->animate_y,
allocation->width,
allocation->height);
}
child_allocation.x = SHADOW_OFFSET_X + padding.left;
child_allocation.y = padding.top;
if (priv->show_close_button)
gtk_widget_get_preferred_size (priv->close_button, &button_req, NULL);
else
button_req.width = button_req.height = 0;
child_allocation.height = MAX (1, allocation->height - SHADOW_OFFSET_Y - padding.top - padding.bottom);
child_allocation.width = MAX (1, (allocation->width - button_req.width -
2 * SHADOW_OFFSET_X - padding.left - padding.right));
child = gtk_bin_get_child (bin);
if (child && gtk_widget_get_visible (child))
gtk_widget_size_allocate (child, &child_allocation);
if (priv->show_close_button)
{
child_allocation.x += child_allocation.width;
child_allocation.width = button_req.width;
child_allocation.y += (child_allocation.height - button_req.height) / 2;
child_allocation.height = button_req.height;
gtk_widget_size_allocate (priv->close_button, &child_allocation);
}
}
static void
attachment_paned_notify_cb (EAttachmentPaned *paned,
GParamSpec *pspec,
GtkExpander *expander)
{
GtkAllocation toplevel_allocation;
GtkWidget *toplevel;
GtkWidget *child;
GtkLabel *label;
const gchar *text;
label = GTK_LABEL (paned->priv->show_hide_label);
/* Update the expander label and set the right bottom margin around the handle. */
if (gtk_expander_get_expanded (expander)) {
gint bottom, value;
text = _("Hide Attachment _Bar");
bottom = gtk_widget_get_margin_bottom (paned->priv->controls_container);
value = bottom - paned->priv->vpaned_handle_size;
gtk_widget_set_margin_bottom (
paned->priv->controls_container, (value < 0) ? 0 : value);
} else {
gtk_widget_set_margin_bottom (paned->priv->controls_container, 6);
text = _("Show Attachment _Bar");
}
gtk_label_set_text_with_mnemonic (label, text);
/* Resize the top-level window if required conditions are met.
* This is based on gtk_expander_resize_toplevel(), but adapted
* to the fact our GtkExpander has no direct child widget. */
if (!e_attachment_paned_get_resize_toplevel (paned))
return;
if (!gtk_widget_get_realized (GTK_WIDGET (paned)))
return;
child = gtk_paned_get_child2 (GTK_PANED (paned));
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (paned));
if (toplevel == NULL)
return;
if (!gtk_widget_get_realized (GTK_WIDGET (toplevel)))
return;
gtk_widget_get_allocation (toplevel, &toplevel_allocation);
if (gtk_expander_get_expanded (expander)) {
GtkRequisition child_requisition;
gtk_widget_get_preferred_size (
child, &child_requisition, NULL);
toplevel_allocation.height += child_requisition.height;
} else {
GtkAllocation child_allocation;
gtk_widget_get_allocation (child, &child_allocation);
toplevel_allocation.height -= child_allocation.height;
}
gtk_window_resize (
GTK_WINDOW (toplevel),
toplevel_allocation.width,
toplevel_allocation.height);
}
static void
append_widget(GtkTreeStore *model,
GtkWidget *widget,
GtkTreeIter *parent_iter)
{
GtkTreeIter iter;
const char *class_name = G_OBJECT_CLASS_NAME(GTK_WIDGET_GET_CLASS(widget));
const char *name;
const char *row_color;
GdkWindow *window;
char *window_info;
char *address;
gboolean realized;
gboolean mapped;
gboolean visible;
GList *l;
name = gtk_widget_get_name(widget);
if (name == NULL || strcmp(name, class_name) == 0) {
if (GTK_IS_LABEL(widget))
{
name = gtk_label_get_text(GTK_LABEL(widget));
}
else if (GTK_IS_BUTTON(widget))
{
name = gtk_button_get_label(GTK_BUTTON(widget));
}
else if (GTK_IS_WINDOW(widget))
{
name = gtk_window_get_title(GTK_WINDOW(widget));
}
else
{
name = "";
}
}
window = gtk_widget_get_window (widget);
if (window_info)
{
#if HAVE_X11
window_info = g_strdup_printf("%p (XID 0x%x)", window,
(int)GDK_WINDOW_XID(window));
#else
window_info = g_strdup("");
#endif
}
else
{
window_info = g_strdup("");
}
address = g_strdup_printf("%p", widget);
realized = gtk_widget_get_realized (widget);
mapped = gtk_widget_get_mapped (widget);
visible = gtk_widget_get_visible (widget);
row_color = (realized && mapped && visible) ? "black" : "grey";
gtk_tree_store_append(model, &iter, parent_iter);
gtk_tree_store_set(model, &iter,
WIDGET, widget,
WIDGET_TYPE, class_name,
WIDGET_NAME, name,
WIDGET_REALIZED, realized,
WIDGET_MAPPED, mapped,
WIDGET_VISIBLE, visible,
WIDGET_WINDOW, window_info,
WIDGET_ADDRESS, address,
ROW_COLOR, row_color,
-1);
g_free(window_info);
g_free(address);
if (GTK_IS_CONTAINER(widget))
{
for (l = gtk_container_get_children(GTK_CONTAINER(widget));
l != NULL;
l = l->next)
{
append_widget(model, GTK_WIDGET(l->data), &iter);
}
}
}
gboolean
pointer_update (GtkWidget* window)
{
gint pointer_rel_x;
gint pointer_rel_y;
gint pointer_abs_x;
gint pointer_abs_y;
gint win_x;
gint win_y;
gint width;
gint height;
gboolean old_mouse_over;
gfloat old_distance = 0;
if (!GTK_IS_WINDOW (window))
return FALSE;
old_mouse_over = g_mouse_over;
if (gtk_widget_get_realized (window))
{
gint distance_x = 0;
gint distance_y = 0;
gtk_widget_get_pointer (window, &pointer_rel_x, &pointer_rel_y);
gtk_window_get_position (GTK_WINDOW (window), &win_x, &win_y);
pointer_abs_x = win_x + pointer_rel_x;
pointer_abs_y = win_y + pointer_rel_y;
gtk_window_get_size (GTK_WINDOW (window), &width, &height);
if (pointer_abs_x >= win_x &&
pointer_abs_x <= win_x + width &&
pointer_abs_y >= win_y &&
pointer_abs_y <= win_y + height)
g_mouse_over = TRUE;
else
g_mouse_over = FALSE;
if (pointer_abs_x >= win_x &&
pointer_abs_x <= win_x + width)
distance_x = 0;
else
{
if (pointer_abs_x < win_x)
distance_x = abs (pointer_rel_x);
if (pointer_abs_x > win_x + width)
distance_x = abs (pointer_rel_x - width);
}
if (pointer_abs_y >= win_y &&
pointer_abs_y <= win_y + height)
distance_y = 0;
else
{
if (pointer_abs_y < win_y)
distance_y = abs (pointer_rel_y);
if (pointer_abs_y > win_y + height)
distance_y = abs (pointer_rel_y - height);
}
old_distance = g_distance;
g_distance = sqrt (distance_x * distance_x +
distance_y * distance_y) /
(double) 40;
}
if (old_mouse_over != g_mouse_over)
set_bg_blur (window, !g_mouse_over);
if (old_distance != g_distance)
gtk_widget_queue_draw (window);
return TRUE;
}
static void
dlg_ask_password__common (FrWindow *window,
FrPasswordType pwd_type)
{
DialogData *data;
GtkWidget *label;
char *text;
char *name = NULL;
data = g_new0 (DialogData, 1);
data->builder = _gtk_builder_new_from_file ("batch-password.ui");
if (data->builder == NULL) {
g_free (data);
return;
}
data->window = window;
data->pwd_type = pwd_type;
/* Get the widgets. */
data->dialog = _gtk_builder_get_widget (data->builder, "password_dialog");
data->pw_password_entry = _gtk_builder_get_widget (data->builder, "pw_password_entry");
label = _gtk_builder_get_widget (data->builder, "pw_password_label");
/* Set widgets data. */
if (data->pwd_type == FR_PASSWORD_TYPE_MAIN)
name = g_uri_display_basename (fr_window_get_archive_uri (window));
else if (data->pwd_type == FR_PASSWORD_TYPE_PASTE_FROM)
name = g_uri_display_basename (fr_window_get_paste_archive_uri (window));
g_assert (name != NULL);
text = g_strdup_printf (_("Enter the password for the archive '%s'."), name);
gtk_label_set_label (GTK_LABEL (label), text);
g_free (text);
if (fr_window_get_password (window) != NULL)
_gtk_entry_set_locale_text (GTK_ENTRY (data->pw_password_entry),
fr_window_get_password (window));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (G_OBJECT (data->dialog),
"response",
G_CALLBACK (ask_password__response_cb),
data);
/* Run dialog. */
gtk_widget_grab_focus (data->pw_password_entry);
if (gtk_widget_get_realized (GTK_WIDGET (window))) {
gtk_window_set_transient_for (GTK_WINDOW (data->dialog),
GTK_WINDOW (window));
gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE);
}
else
gtk_window_set_title (GTK_WINDOW (data->dialog), name);
g_free (name);
gtk_widget_show (data->dialog);
}
static void
gcal_month_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GcalMonthViewPrivate *priv;
gint i;
GList *l;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
PangoLayout *layout;
gint font_height;
gdouble added_height;
priv = GCAL_MONTH_VIEW (widget)->priv;
gtk_widget_set_allocation (widget, allocation);
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (priv->event_window,
allocation->x,
allocation->y,
allocation->width,
allocation->height);
}
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_get_padding (context, state, &padding);
layout = pango_layout_new (gtk_widget_get_pango_context (widget));
pango_layout_set_font_description (layout,
gtk_style_context_get_font (context,
state));
pango_layout_get_pixel_size (layout, NULL, &font_height);
/* init values */
priv->header_font_size = 12;
priv->horizontal_step =
(allocation->width - (allocation->x + padding.left + padding.right)) / 7;
priv->vertical_step =
(allocation->height - (allocation->y + padding.top + padding.bottom + priv->header_font_size)) / 5;
for (i = 0; i < 35; i++)
{
if (priv->days[i] == NULL)
continue;
added_height = 0;
for (l = priv->days[i]; l != NULL; l = l->next)
{
gint pos_x;
gint pos_y;
gint min_height;
gint natural_height;
GtkAllocation child_allocation;
pos_x = ( i % 7 ) * priv->horizontal_step;
pos_y = ( i / 7 ) * priv->vertical_step;
gtk_widget_get_preferred_height (GTK_WIDGET (l->data),
&min_height,
&natural_height);
child_allocation.x = pos_x + allocation->x + padding.top;
child_allocation.y = pos_y + font_height + allocation->y
+ priv->header_font_size + padding.left;
child_allocation.width = priv->horizontal_step;
child_allocation.height = MIN (natural_height, priv->vertical_step);
if (added_height + font_height + child_allocation.height
> priv->vertical_step)
{
gtk_widget_hide (GTK_WIDGET (l->data));
}
else
{
gtk_widget_show (GTK_WIDGET (l->data));
child_allocation.y = child_allocation.y + added_height;
gtk_widget_size_allocate (GTK_WIDGET (l->data), &child_allocation);
added_height += child_allocation.height;
}
}
}
}
static void
label_window_composited_changed_cb (GtkWidget *widget, CcRRLabeler *labeler)
{
if (gtk_widget_get_realized (widget))
maybe_update_shape (widget);
}
gboolean
rb_missing_plugins_install (const char **details, gboolean ignore_blacklist, GClosure *closure)
{
RBPluginInstallContext *ctx;
GstInstallPluginsContext *install_ctx;
GstInstallPluginsReturn status;
int i, num;
num = g_strv_length ((char **)details);
g_return_val_if_fail (num > 0, FALSE);
ctx = g_new0 (RBPluginInstallContext, 1);
ctx->closure = g_closure_ref (closure);
ctx->details = g_strdupv ((char **)details);
num = g_strv_length (ctx->details);
for (i = 0; i < num; ++i) {
if (ignore_blacklist == FALSE && rb_plugin_install_plugin_is_blacklisted (ctx->details[i])) {
g_message ("Missing plugin: %s (ignoring)", ctx->details[i]);
g_free (ctx->details[i]);
ctx->details[i] = ctx->details[num-1];
ctx->details[num-1] = NULL;
--num;
--i;
} else {
g_message ("Missing plugin: %s", ctx->details[i]);
}
}
if (num == 0) {
g_message ("All missing plugins are blacklisted, doing nothing");
rb_plugin_install_context_free (ctx);
return FALSE;
}
install_ctx = gst_install_plugins_context_new ();
if (parent_window != NULL && gtk_widget_get_realized (GTK_WIDGET (parent_window))) {
#ifdef GDK_WINDOWING_X11
gulong xid = 0;
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET (parent_window)));
gst_install_plugins_context_set_xid (install_ctx, xid);
#endif
}
status = gst_install_plugins_async (ctx->details, install_ctx,
on_plugin_installation_done,
ctx);
gst_install_plugins_context_free (install_ctx);
rb_debug ("gst_install_plugins_async() result = %d", status);
if (status != GST_INSTALL_PLUGINS_STARTED_OK) {
if (status == GST_INSTALL_PLUGINS_HELPER_MISSING) {
g_message ("Automatic missing codec installation not supported "
"(helper script missing)");
} else {
g_warning ("Failed to start codec installation: %s",
gst_install_plugins_return_get_name (status));
}
rb_plugin_install_context_free (ctx);
return FALSE;
}
return TRUE;
}
void pCanvas::update() {
memcpy(cairo_image_surface_get_data(surface), canvas.state.data, canvas.state.width * canvas.state.height * sizeof(uint32_t));
if(gtk_widget_get_realized(gtkWidget) == false) return;
gdk_window_invalidate_rect(gtk_widget_get_window(gtkWidget), nullptr, true);
}
static void
gimp_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GimpView *view = GIMP_VIEW (widget);
gint width;
gint height;
if (view->expand)
{
width = MIN (GIMP_VIEWABLE_MAX_PREVIEW_SIZE,
allocation->width - 2 * view->renderer->border_width);
height = MIN (GIMP_VIEWABLE_MAX_PREVIEW_SIZE,
allocation->height - 2 * view->renderer->border_width);
if (view->renderer->width != width ||
view->renderer->height != height)
{
gint border_width = view->renderer->border_width;
if (view->renderer->size != -1 && view->renderer->viewable)
{
gint view_width;
gint view_height;
gint scaled_width;
gint scaled_height;
gimp_viewable_get_preview_size (view->renderer->viewable,
GIMP_VIEWABLE_MAX_PREVIEW_SIZE,
view->renderer->is_popup,
view->renderer->dot_for_dot,
&view_width,
&view_height);
gimp_viewable_calc_preview_size (view_width, view_height,
width, height,
TRUE, 1.0, 1.0,
&scaled_width, &scaled_height,
NULL);
if (scaled_width > width)
{
scaled_height = scaled_height * width / scaled_width;
scaled_width = scaled_width * width / scaled_width;
}
else if (scaled_height > height)
{
scaled_width = scaled_width * height / scaled_height;
scaled_height = scaled_height * height / scaled_height;
}
gimp_view_renderer_set_size (view->renderer,
MAX (scaled_width, scaled_height),
border_width);
}
else
{
gimp_view_renderer_set_size_full (view->renderer,
width, height,
border_width);
}
gimp_view_renderer_remove_idle (view->renderer);
}
}
width = (view->renderer->width +
2 * view->renderer->border_width);
height = (view->renderer->height +
2 * view->renderer->border_width);
if (allocation->width > width)
allocation->x += (allocation->width - width) / 2;
if (allocation->height > height)
allocation->y += (allocation->height - height) / 2;
allocation->width = width;
allocation->height = height;
gtk_widget_set_allocation (widget, allocation);
if (gtk_widget_get_realized (widget))
gdk_window_move_resize (view->event_window,
allocation->x,
allocation->y,
allocation->width,
allocation->height);
}
/*
* position within the sheet in pixel coordinates
* coordinates are clamped to grid if grid is enabled
* see snap_to_grid
* zero point : top left corner of the window (not widget!)
* x : horizontal, left to right
* y : vertical, top to bottom
* returns wether the position could be detected properly
*/
gboolean
sheet_get_pointer_pixel (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkAdjustment *hadj = NULL, *vadj = NULL;
gdouble x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
GdkDisplay *display;
GdkWindow *window;
// deprecated gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);
// replaced by a code copied from evince
if (G_UNLIKELY (!sheet || !gtk_widget_get_realized (GTK_WIDGET (sheet)))) {
NG_DEBUG ("Widget is not realized.");
return FALSE;
}
display = gtk_widget_get_display (GTK_WIDGET (sheet));
device_manager = gdk_display_get_device_manager (display);
// gdk_device_manager_get_client_pointer
// shall not be used within events
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
window = gtk_widget_get_window (GTK_WIDGET (sheet));
if (!window) {
NG_DEBUG ("Window is not realized.");
return FALSE;
}
// even though above is all defined the below will always return NUL for
// unknown reason and _x and _y are populated as expected
gdk_window_get_device_position (
window,
device_pointer,
&_x, &_y, NULL);
#if 0
if (!window) { //fails always
NG_DEBUG ("Window does not seem to be realized yet?");
return FALSE;
}
#else
NG_DEBUG ("\n%p %p %p %p %i %i\n\n",display, device_manager, device_pointer, window, _x, _y);
#endif
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
_x -= allocation.x;
_y -= allocation.y;
x1 = (gdouble) _x;
y1 = (gdouble) _y;
if (!sheet_get_adjustments (sheet, &hadj, &vadj))
return FALSE;
x1 += gtk_adjustment_get_value (hadj);
y1 += gtk_adjustment_get_value (vadj);
*x = x1;
*y = y1;
return TRUE;
}
static gboolean
gimp_view_button_press_event (GtkWidget *widget,
GdkEventButton *bevent)
{
GimpView *view = GIMP_VIEW (widget);
#ifdef DEBUG_MEMSIZE
if (bevent->type == GDK_BUTTON_PRESS && bevent->button == 2)
{
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (view->viewable), NULL);
gimp_debug_memsize = FALSE;
}
#endif /* DEBUG_MEMSIZE */
if (! view->clickable &&
! view->show_popup)
return FALSE;
if (! gtk_widget_get_realized (widget))
return FALSE;
if (bevent->type == GDK_BUTTON_PRESS)
{
if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
{
view->press_state = 0;
g_signal_emit (widget, view_signals[CONTEXT], 0);
}
else if (bevent->button == 1)
{
gtk_grab_add (widget);
view->has_grab = TRUE;
view->press_state = bevent->state;
if (view->show_popup && view->viewable)
{
gimp_view_popup_show (widget, bevent,
view->renderer->context,
view->viewable,
view->renderer->width,
view->renderer->height,
view->renderer->dot_for_dot);
}
}
else
{
view->press_state = 0;
if (bevent->button == 2)
gimp_view_popup_show (widget, bevent,
view->renderer->context,
view->viewable,
view->renderer->width,
view->renderer->height,
view->renderer->dot_for_dot);
return FALSE;
}
}
else if (bevent->type == GDK_2BUTTON_PRESS)
{
if (bevent->button == 1)
g_signal_emit (widget, view_signals[DOUBLE_CLICKED], 0);
}
return view->eat_button_events ? TRUE : FALSE;
}
static void
cvImageWidget_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
CvImageWidget *image_widget;
//printf("cvImageWidget_size_allocate\n");
g_return_if_fail (widget != NULL);
g_return_if_fail (CV_IS_IMAGE_WIDGET (widget));
g_return_if_fail (allocation != NULL);
#if defined (GTK_VERSION3)
gtk_widget_set_allocation(widget, allocation);
#else
widget->allocation = *allocation;
#endif //GTK_VERSION3
image_widget = CV_IMAGE_WIDGET (widget);
if( (image_widget->flags & CV_WINDOW_AUTOSIZE)==0 && image_widget->original_image ){
// (re) allocated scaled image
if( image_widget->flags & CV_WINDOW_NO_IMAGE ){
cvImageWidget_set_size( widget, image_widget->original_image->cols,
image_widget->original_image->rows);
}
else{
cvImageWidget_set_size( widget, allocation->width, allocation->height );
}
cvResize( image_widget->original_image, image_widget->scaled_image, CV_INTER_AREA );
}
if (gtk_widget_get_realized (widget))
{
image_widget = CV_IMAGE_WIDGET (widget);
if( image_widget->original_image &&
((image_widget->flags & CV_WINDOW_AUTOSIZE) ||
(image_widget->flags & CV_WINDOW_NO_IMAGE)) )
{
#if defined (GTK_VERSION3)
allocation->width = image_widget->original_image->cols;
allocation->height = image_widget->original_image->rows;
gtk_widget_set_allocation(widget, allocation);
#else
widget->allocation.width = image_widget->original_image->cols;
widget->allocation.height = image_widget->original_image->rows;
#endif //GTK_VERSION3
gdk_window_move_resize( gtk_widget_get_window(widget),
allocation->x, allocation->y,
image_widget->original_image->cols, image_widget->original_image->rows );
if(image_widget->flags & CV_WINDOW_NO_IMAGE){
image_widget->flags &= ~CV_WINDOW_NO_IMAGE;
gtk_widget_queue_resize( GTK_WIDGET(widget) );
}
}
else{
gdk_window_move_resize (gtk_widget_get_window(widget),
allocation->x, allocation->y,
allocation->width, allocation->height );
}
}
}
static void
emoticon_tool_button_popup (EEmoticonToolButton *button)
{
GtkToggleToolButton *tool_button;
GdkWindow *window;
gboolean grab_status;
GdkDevice *device, *mouse, *keyboard;
guint32 activate_time;
device = gtk_get_current_event_device ();
g_return_if_fail (device != NULL);
if (!gtk_widget_get_realized (GTK_WIDGET (button)))
return;
if (button->priv->popup_shown)
return;
activate_time = gtk_get_current_event_time ();
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) {
keyboard = device;
mouse = gdk_device_get_associated_device (device);
} else {
keyboard = gdk_device_get_associated_device (device);
mouse = device;
}
/* Position the window over the button. */
emoticon_tool_button_reposition_window (button);
/* Show the pop-up. */
gtk_widget_show (button->priv->window);
gtk_widget_grab_focus (button->priv->window);
/* Activate the tool button. */
tool_button = GTK_TOGGLE_TOOL_BUTTON (button);
gtk_toggle_tool_button_set_active (tool_button, TRUE);
/* Try to grab the pointer and keyboard. */
window = gtk_widget_get_window (button->priv->window);
grab_status = !keyboard ||
gdk_device_grab (
keyboard, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, activate_time) == GDK_GRAB_SUCCESS;
if (grab_status) {
grab_status = !mouse ||
gdk_device_grab (mouse, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
NULL, activate_time) == GDK_GRAB_SUCCESS;
if (!grab_status && keyboard)
gdk_device_ungrab (keyboard, activate_time);
}
if (grab_status) {
gtk_device_grab_add (button->priv->window, mouse, TRUE);
button->priv->grab_keyboard = keyboard;
button->priv->grab_mouse = mouse;
} else {
gtk_widget_hide (button->priv->window);
}
}
void budgie_popover_present(BudgiePopover *self,
GtkWidget *parent,
GdkEventButton *event)
{
GtkWidget *real_parent;
GdkWindow *parent_window;
gint x, y, tx, ty, rx, margin;
GdkScreen *screen;
GtkAllocation alloc, our_alloc;
GdkDeviceManager *manager;
gint32 time;
if (event) {
x = event->x;
y = event->y;
}
if (gtk_widget_get_visible(GTK_WIDGET(self))) {
budgie_popover_hide(self);
return;
}
if (!gtk_widget_get_realized(GTK_WIDGET(self)))
gtk_widget_realize(GTK_WIDGET(self));
/* Get position of parent widget on screen */
real_parent = gtk_widget_get_toplevel(parent);
parent_window = gtk_widget_get_window(real_parent);
gdk_window_get_position(parent_window, &x, &y);
gtk_widget_translate_coordinates(parent, real_parent, x, y, &tx, &ty);
gtk_widget_get_allocation(parent, &alloc);
gtk_widget_get_allocation(GTK_WIDGET(self), &our_alloc);
screen = gtk_widget_get_screen(GTK_WIDGET(self));
/* Ensure we're in a sensible position (under/over) */
if (ty + our_alloc.height + 11 < gdk_screen_get_height(screen)) {
self->top = TRUE;
ty = y+alloc.y+alloc.height;
} else {
ty = (y+alloc.y)-our_alloc.height;
self->top = FALSE;
}
/* Ensure widg_x is within bounds */
if (event) {
/* Point tip to mouse x,y */
rx = event->x;
} else {
/* Center the tip when there is no event */
rx = alloc.x + (alloc.width/2);
}
/* ensure margin is accounted for */
g_object_get(parent, "margin", &margin, NULL);
tx -= margin;
rx -= margin;
if (rx >= our_alloc.width)
rx = our_alloc.width - 18;
if (rx <= 18)
rx = 18;
self->widg_x = rx;
gtk_window_move(GTK_WINDOW(self), tx-11, ty);
gtk_widget_show_all(GTK_WIDGET(self));
if (event) {
self->pointer = event->device;
time = event->time;
} else {
manager = gdk_display_get_device_manager(gdk_screen_get_display(screen));
self->pointer = gdk_device_manager_get_client_pointer(manager);
time = GDK_CURRENT_TIME;
}
self->parent_widget = real_parent;
self->con_id = g_signal_connect(real_parent, "button-press-event", G_CALLBACK(button_press), self);
self->con_id = 0;
/* TODO: Handle keyboard grab too */
popup_grab_on_window(gtk_widget_get_window(GTK_WIDGET(real_parent)),
NULL, self->pointer, time);
}
static void pizza_size_allocate(GtkWidget* widget, GtkAllocation* alloc)
{
wxPizza* pizza = WX_PIZZA(widget);
GtkBorder border;
pizza->get_border(border);
int w = alloc->width - border.left - border.right;
if (w < 0) w = 0;
if (gtk_widget_get_realized(widget))
{
int h = alloc->height - border.top - border.bottom;
if (h < 0) h = 0;
const int x = alloc->x + border.left;
const int y = alloc->y + border.top;
GdkWindow* window = gtk_widget_get_window(widget);
int old_x, old_y;
gdk_window_get_position(window, &old_x, &old_y);
if (x != old_x || y != old_y ||
w != gdk_window_get_width(window) || h != gdk_window_get_height(window))
{
gdk_window_move_resize(window, x, y, w, h);
if (border.left + border.right + border.top + border.bottom)
{
// old and new border areas need to be invalidated,
// otherwise they will not be erased/redrawn properly
GtkAllocation old_alloc;
gtk_widget_get_allocation(widget, &old_alloc);
GdkWindow* parent = gtk_widget_get_parent_window(widget);
gdk_window_invalidate_rect(parent, &old_alloc, false);
gdk_window_invalidate_rect(parent, alloc, false);
}
}
}
gtk_widget_set_allocation(widget, alloc);
// adjust child positions
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (const GList* p = pizza->m_children; p; p = p->next)
{
const wxPizzaChild* child = static_cast<wxPizzaChild*>(p->data);
if (gtk_widget_get_visible(child->widget))
{
GtkAllocation child_alloc;
// note that child positions do not take border into
// account, they need to be relative to widget->window,
// which has already been adjusted
child_alloc.x = child->x - pizza->m_scroll_x;
child_alloc.y = child->y - pizza->m_scroll_y;
child_alloc.width = child->width;
child_alloc.height = child->height;
if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
child_alloc.x = w - child_alloc.x - child_alloc.width;
gtk_widget_size_allocate(child->widget, &child_alloc);
}
}
}
static cairo_surface_t *
snapshot_widget (GtkWidget *widget, SnapshotMode mode)
{
cairo_surface_t *surface;
cairo_pattern_t *bg;
GMainLoop *loop;
cairo_t *cr;
g_assert (gtk_widget_get_realized (widget));
surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
loop = g_main_loop_new (NULL, FALSE);
/* We wait until the widget is drawn for the first time.
* We can not wait for a GtkWidget::draw event, because that might not
* happen if the window is fully obscured by windowed child widgets.
* Alternatively, we could wait for an expose event on widget's window.
* Both of these are rather hairy, not sure what's best. */
gdk_event_handler_set (check_for_draw, loop, NULL);
g_main_loop_run (loop);
cr = cairo_create (surface);
switch (mode)
{
case SNAPSHOT_WINDOW:
{
GdkWindow *window = gtk_widget_get_window (widget);
if (gdk_window_get_window_type (window) == GDK_WINDOW_TOPLEVEL ||
gdk_window_get_window_type (window) == GDK_WINDOW_FOREIGN)
{
/* give the WM/server some time to sync. They need it.
* Also, do use popups instead of toplevls in your tests
* whenever you can. */
gdk_display_sync (gdk_window_get_display (window));
g_timeout_add (500, quit_when_idle, loop);
g_main_loop_run (loop);
}
gdk_cairo_set_source_window (cr, window, 0, 0);
cairo_paint (cr);
}
break;
case SNAPSHOT_DRAW:
bg = gdk_window_get_background_pattern (gtk_widget_get_window (widget));
if (bg)
{
cairo_set_source (cr, bg);
cairo_paint (cr);
}
gtk_widget_draw (widget, cr);
break;
default:
g_assert_not_reached();
break;
}
cairo_destroy (cr);
g_main_loop_unref (loop);
gtk_widget_destroy (widget);
return surface;
}
static void
gdu_format_volume_dialog_show_internal (UDisksClient *client,
GtkWindow *parent_window,
gint parent_xid,
UDisksObject *object)
{
GduApplication *app = GDU_APPLICATION (g_application_get_default ());
FormatVolumeData *data;
gint response;
data = g_new0 (FormatVolumeData, 1);
data->parent_window = (parent_window != NULL) ? g_object_ref (parent_window) : NULL;
data->object = g_object_ref (object);
data->block = udisks_object_get_block (object);
g_assert (data->block != NULL);
data->drive = udisks_client_get_drive_for_block (client, data->block);
data->dialog = GTK_WIDGET (gdu_application_new_widget (app,
"format-volume-dialog.ui",
"format-volume-dialog",
&data->builder));
data->contents_box = GTK_WIDGET (gtk_builder_get_object (data->builder, "contents-box"));
data->create_filesystem_widget = gdu_create_filesystem_widget_new (app,
data->drive,
NULL); /* additional_fstypes */
gtk_box_pack_start (GTK_BOX (data->contents_box),
data->create_filesystem_widget,
TRUE, TRUE, 0);
g_signal_connect (data->create_filesystem_widget, "notify::has-info",
G_CALLBACK (format_volume_property_changed), data);
if (parent_window != NULL)
{
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), parent_window);
}
else if (parent_xid != -1)
{
GdkWindow *foreign_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), parent_xid);
if (!gtk_widget_get_realized (data->dialog))
gtk_widget_realize (data->dialog);
gdk_window_set_transient_for (gtk_widget_get_window (data->dialog), foreign_window);
}
gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
format_volume_update (data);
gtk_widget_show_all (data->dialog);
gtk_widget_grab_focus (gdu_create_filesystem_widget_get_name_entry (GDU_CREATE_FILESYSTEM_WIDGET (data->create_filesystem_widget)));
response = gtk_dialog_run (GTK_DIALOG (data->dialog));
if (response == GTK_RESPONSE_OK)
{
const gchar *primary_message;
const gchar *erase_type;
GString *str;
GList *objects = NULL;
gtk_widget_hide (data->dialog);
erase_type = gdu_create_filesystem_widget_get_erase (GDU_CREATE_FILESYSTEM_WIDGET (data->create_filesystem_widget));
primary_message = _("Are you sure you want to format the volume?");
if (erase_type == NULL || g_strcmp0 (erase_type, "") == 0)
{
/* Translators: warning used for quick format of the volume*/
str = g_string_new (_("All data on the volume will be lost but may still be recoverable by data recovery services"));
g_string_append (str, "\n\n");
g_string_append (str, _("<b>Tip</b>: If you are planning to recycle, sell or give away your old computer or disk, you should use a more thorough erase type to keep your private information from falling into the wrong hands"));
}
else
{
/* Translators: warning used when overwriting data of the volume */
str = g_string_new (_("All data on the volume will be overwritten and will likely not be recoverable by data recovery services"));
}
objects = g_list_append (NULL, object);
if (!gdu_utils_show_confirmation (GTK_WINDOW (data->parent_window),
primary_message,
str->str,
_("_Format"),
NULL, NULL,
client, objects))
{
g_list_free (objects);
g_string_free (str, TRUE);
goto out;
}
g_list_free (objects);
g_string_free (str, TRUE);
/* ensure the volume is unused (e.g. unmounted) before formatting it... */
gdu_utils_ensure_unused (client,
GTK_WINDOW (data->parent_window),
data->object,
(GAsyncReadyCallback) ensure_unused_cb,
NULL, /* GCancellable */
data);
return;
}
out:
format_volume_data_free (data);
}
