static void
popup_container_position_func (PopupContainer *cont, gint *out_x, gint *out_y)
{
GtkWidget *console, *top;
gint x, y;
GtkRequisition req;
console = g_object_get_data (G_OBJECT (cont), "console");
top = gtk_widget_get_toplevel (console);
gtk_widget_get_preferred_size ((GtkWidget*) cont, NULL, &req);
GtkAllocation alloc;
gdk_window_get_origin (gtk_widget_get_window (top), &x, &y);
gtk_widget_get_allocation (top, &alloc);
x += (alloc.width - req.width) / 2;
y += (alloc.height - req.height) / 2;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
*out_x = x;
*out_y = y;
}
static void
egg_cell_renderer_keys_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height)
{
EggCellRendererKeys *keys = (EggCellRendererKeys *) cell;
GtkRequisition requisition;
if (keys->sizing_label == NULL)
keys->sizing_label = gtk_label_new (TOOLTIP_TEXT);
#if GTK_CHECK_VERSION (3,0,0)
gtk_widget_get_preferred_size (keys->sizing_label, NULL, &requisition);
#else
gtk_widget_size_request (keys->sizing_label, &requisition);
#endif
(* GTK_CELL_RENDERER_CLASS (parent_class)->get_size) (cell, widget, cell_area, x_offset, y_offset, width, height);
/* FIXME: need to take the cell_area et al. into account */
if (width)
*width = MAX (*width, requisition.width);
if (height)
*height = MAX (*height, requisition.height);
}
/**
* seahorse_util_determine_popup_menu_position:
* @menu: The menu to place
* @x: (out) x pos of the menu
* @y: (out) y pos of the menu
* @push_in: (out) will be set to TRUE
* @gdata: GTK_WIDGET for which the menu is
*
*
* Callback to determine where a popup menu should be placed
*
*/
void
seahorse_util_determine_popup_menu_position (GtkMenu *menu, int *x, int *y,
gboolean *push_in, gpointer gdata)
{
GtkWidget *widget;
GtkRequisition requisition;
GtkAllocation allocation;
gint menu_xpos;
gint menu_ypos;
widget = GTK_WIDGET (gdata);
gtk_widget_get_preferred_size (GTK_WIDGET (menu), &requisition, NULL);
gdk_window_get_origin (gtk_widget_get_window (widget), &menu_xpos, &menu_ypos);
gtk_widget_get_allocation (widget, &allocation);
menu_xpos += allocation.x;
menu_ypos += allocation.y;
if (menu_ypos > gdk_screen_get_height (gtk_widget_get_screen (widget)) / 2)
menu_ypos -= requisition.height;
else
menu_ypos += allocation.height;
*x = menu_xpos;
*y = menu_ypos;
*push_in = TRUE;
}
static void
position_popup (GNCDateEdit *gde)
{
gint x, y;
gint bwidth, bheight;
GtkRequisition req;
GtkAllocation alloc;
gtk_widget_get_preferred_size (gde->cal_popup, &req, NULL);
gdk_window_get_origin (gtk_widget_get_window (gde->date_button), &x, &y);
gtk_widget_get_allocation (gde->date_button, &alloc);
x += alloc.x;
y += alloc.y;
bwidth = alloc.width;
bheight = alloc.height;
x += bwidth - req.width;
y += bheight;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
gtk_window_move (GTK_WINDOW (gde->cal_popup), x, y);
}
static gboolean
get_child_position (GtkOverlay *overlay,
GtkWidget *widget,
GtkAllocation *alloc,
GtkWidget *relative)
{
GtkRequisition req;
GtkWidget *child;
GtkAllocation main_alloc;
gint x, y;
child = gtk_bin_get_child (GTK_BIN (overlay));
gtk_widget_translate_coordinates (relative, child, 0, 0, &x, &y);
main_alloc.x = x;
main_alloc.y = y;
main_alloc.width = gtk_widget_get_allocated_width (relative);
main_alloc.height = gtk_widget_get_allocated_height (relative);
gtk_widget_get_preferred_size (widget, NULL, &req);
alloc->x = main_alloc.x;
alloc->width = MIN (main_alloc.width, req.width);
if (gtk_widget_get_halign (widget) == GTK_ALIGN_END)
alloc->x += main_alloc.width - req.width;
alloc->y = main_alloc.y;
alloc->height = MIN (main_alloc.height, req.height);
if (gtk_widget_get_valign (widget) == GTK_ALIGN_END)
alloc->y += main_alloc.height - req.height;
return TRUE;
}
/* static */
wxSize wxButtonBase::GetDefaultSize()
{
static wxSize size = wxDefaultSize;
if (size == wxDefaultSize)
{
// NB: Default size of buttons should be same as size of stock
// buttons as used in most GTK+ apps. Unfortunately it's a little
// tricky to obtain this size: stock button's size may be smaller
// than size of button in GtkButtonBox and vice versa,
// GtkButtonBox's minimal button size may be smaller than stock
// button's size. We have to retrieve both values and combine them.
GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
GtkWidget *btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_container_add(GTK_CONTAINER(box), btn);
gtk_container_add(GTK_CONTAINER(wnd), box);
GtkRequisition req;
gtk_widget_get_preferred_size(btn, NULL, &req);
gint minwidth, minheight;
gtk_widget_style_get(box,
"child-min-width", &minwidth,
"child-min-height", &minheight,
NULL);
size.x = wxMax(minwidth, req.width);
size.y = wxMax(minheight, req.height);
gtk_widget_destroy(wnd);
}
return size;
}
static void
popup_position (PopupContainer *container, gint *out_x, gint *out_y)
{
GtkWidget *poswidget;
poswidget = g_object_get_data (G_OBJECT (container), "__poswidget");
gint x, y;
GtkRequisition req;
gtk_widget_get_preferred_size (poswidget, NULL, &req);
GtkAllocation alloc;
gdk_window_get_origin (gtk_widget_get_window (poswidget), &x, &y);
gtk_widget_get_allocation (poswidget, &alloc);
x += alloc.x;
y += alloc.y;
y += alloc.height;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
*out_x = x;
*out_y = y;
}
gint
gnc_popup_get_button_width (void)
{
GtkWidget *window, *button, *arrow;
gint width;
GtkRequisition req;
window = gtk_window_new (GTK_WINDOW_POPUP);
button = gtk_button_new ();
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (window), button);
arrow = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (button), arrow);
gtk_window_move (GTK_WINDOW (window), -500, -500);
gtk_widget_show (window);
gtk_widget_get_preferred_size (window, &req, NULL);
width = req.width;
gtk_widget_destroy (window);
return width;
}
wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
{
// Compute the max size of the tab labels.
wxSize sizeTabMax;
const size_t pageCount = GetPageCount();
for ( size_t n = 0; n < pageCount; n++ )
{
GtkRequisition req;
gtk_widget_get_preferred_size(GetNotebookPage(n)->m_box, NULL, &req);
sizeTabMax.IncTo(wxSize(req.width, req.height));
}
// Unfortunately this doesn't account for the real tab size and I don't
// know how to find it, e.g. where do the margins below come from.
const int PAGE_MARGIN = 3;
const int TAB_MARGIN = 4;
sizeTabMax.IncBy(3*TAB_MARGIN);
wxSize sizeFull(sizePage);
if ( IsVertical() )
sizeFull.y += sizeTabMax.y;
else
sizeFull.x += sizeTabMax.x;
sizeFull.IncBy(2*PAGE_MARGIN);
return sizeFull;
}
void
gedit_utils_menu_position_under_widget (GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer user_data)
{
GtkWidget *widget;
GtkRequisition requisition;
GtkAllocation allocation;
widget = GTK_WIDGET (user_data);
widget_get_origin (widget, x, y);
gtk_widget_get_preferred_size (GTK_WIDGET (menu), &requisition,
NULL);
gtk_widget_get_allocation (widget, &allocation);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
{
*x += allocation.x + allocation.width - requisition.width;
}
else
{
*x += allocation.x;
}
*y += allocation.y + allocation.height;
*push_in = TRUE;
}
static void ygtk_adj_size_get_preferred_size (
GtkWidget *widget, GtkRequisition *requisition)
{
GtkWidget *child = gtk_bin_get_child(GTK_BIN (widget));
requisition->width = requisition->height = 0;
if (child && gtk_widget_get_visible((child))) {
gtk_widget_get_preferred_size(child, NULL, requisition);
guint border = gtk_container_get_border_width(GTK_CONTAINER (widget));
requisition->width += border * 2;
requisition->height += border * 2;
YGtkAdjSize *adj_size = YGTK_ADJ_SIZE (widget);
if (adj_size->min_size_cb) {
guint min_width, min_height;
adj_size->min_size_cb (&min_width, &min_height, adj_size->min_size_data);
requisition->width = MAX (requisition->width, min_width);
requisition->height = MAX (requisition->height, min_height);
}
requisition->width = MAX (requisition->width, adj_size->min_width);
requisition->height = MAX (requisition->height, adj_size->min_height);
if (adj_size->max_width)
requisition->width = MIN (requisition->width, adj_size->max_width);
if (adj_size->max_height)
requisition->height = MIN (requisition->height, adj_size->max_height);
if (adj_size->only_expand) {
adj_size->min_width = requisition->width;
adj_size->min_height = requisition->height;
}
}
}
/* We put size_request and _allocate in the same functions for both
orientations because it's just easier to maintain having the
logic in the same place. */
static void ygtk_ratio_box_get_preferred_size (GtkWidget *widget,
GtkRequisition *requisition,
GtkOrientation orientation)
{
requisition->width = requisition->height = 0;
YGtkRatioBox* box = YGTK_RATIO_BOX (widget);
gint children_nb = 0;
GList *i;
for (i = box->children; i; i = i->next) {
YGtkRatioBoxChild* child = i->data;
if (!gtk_widget_get_visible (child->widget))
continue;
GtkRequisition min_child_req;
GtkRequisition nat_child_req;
gtk_widget_get_preferred_size (child->widget, &min_child_req, &nat_child_req);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
requisition->height = MAX (requisition->height, min_child_req.height);
else
requisition->width = MAX (requisition->width, min_child_req.width);
children_nb++;
}
gint spacing = children_nb ? box->spacing*(children_nb-1) : 0;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
requisition->width += spacing;
else
requisition->height += spacing;
int border = gtk_container_get_border_width(GTK_CONTAINER (box));
requisition->width += border*2;
requisition->height += border*2;
}
static gint
cpufreq_applet_get_widget_size (CPUFreqApplet *applet,
GtkWidget *widget)
{
GtkRequisition req;
gint size;
if (!gtk_widget_get_visible (widget))
return 0;
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_get_preferred_size (widget, &req, NULL);
#else
gtk_widget_size_request (widget, &req);
#endif
switch (applet->orient) {
case MATE_PANEL_APPLET_ORIENT_LEFT:
case MATE_PANEL_APPLET_ORIENT_RIGHT:
size = req.width;
break;
case MATE_PANEL_APPLET_ORIENT_UP:
case MATE_PANEL_APPLET_ORIENT_DOWN:
size = req.height;
break;
default:
g_assert_not_reached ();
}
return size;
}
static void
gtk_image_menu_item_get_preferred_height (GtkWidget *widget,
gint *minimum,
gint *natural)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
GtkImageMenuItemPrivate *priv = image_menu_item->priv;
gint child_height = 0;
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;
if (priv->image && gtk_widget_get_visible (priv->image))
{
GtkRequisition child_requisition;
gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL);
child_height = child_requisition.height;
}
GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->get_preferred_height (widget, minimum, natural);
if (pack_dir == GTK_PACK_DIRECTION_RTL || pack_dir == GTK_PACK_DIRECTION_LTR)
{
*minimum = MAX (*minimum, child_height);
*natural = MAX (*natural, child_height);
}
}
static void popup_position_func(GtkMenu* menu, gint* x, gint* y, gboolean* push_in, gpointer user_data)
{
GtkRequisition req;
GdkPoint* pos;
pos = user_data;
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL);
#else
gtk_widget_size_request(GTK_WIDGET(menu), &req);
#endif
*x = pos->x;
*y = pos->y;
if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
{
*x = MAX (0, *x - req.width);
}
/* Ensure onscreen */
*x = CLAMP (*x, 0, MAX(0, gdk_screen_width() - req.width));
*y = CLAMP (*y, 0, MAX(0, gdk_screen_height() - req.height));
}
/* If the menu is popped up in response to a keystroke, center it
* immediately below the toolbar.
*/
static void
tm_popup_position_func(GtkMenu * menu, gint * x, gint * y,
gboolean * push_in, gpointer user_data)
{
GtkWidget *toolbar = GTK_WIDGET(user_data);
GdkScreen *screen = gtk_widget_get_screen(toolbar);
GtkRequisition req;
gint monitor_num;
GdkRectangle monitor;
GtkAllocation allocation;
g_return_if_fail(gtk_widget_get_window(toolbar));
gdk_window_get_origin(gtk_widget_get_window(toolbar), x, y);
gtk_widget_get_preferred_size(GTK_WIDGET(menu), NULL, &req);
gtk_widget_get_allocation(toolbar, &allocation);
*x += (allocation.width - req.width) / 2;
*y += allocation.height;
monitor_num = gdk_screen_get_monitor_at_point(screen, *x, *y);
gtk_menu_set_monitor(menu, monitor_num);
gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor);
*x = CLAMP(*x, monitor.x,
monitor.x + MAX(0, monitor.width - req.width));
*y = CLAMP(*y, monitor.y,
monitor.y + MAX(0, monitor.height - req.height));
*push_in = FALSE;
}
static void
ephy_fullscreen_popup_update_position (EphyFullscreenPopup *popup)
{
GtkWidget *widget = GTK_WIDGET (popup);
GtkRequisition requisition;
GdkScreen *screen;
GdkRectangle screen_rect;
int popup_width;
gtk_widget_get_preferred_size (widget, &requisition, NULL);
popup_width = requisition.width;
screen = gtk_widget_get_screen (widget);
gdk_screen_get_monitor_geometry
(screen,
gdk_screen_get_monitor_at_window (screen,
gtk_widget_get_window (widget)),
&screen_rect);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
{
gtk_window_move (GTK_WINDOW (widget),
screen_rect.x, screen_rect.y);
}
else
{
gtk_window_move (GTK_WINDOW (widget),
screen_rect.x + screen_rect.width - popup_width,
screen_rect.y);
}
}
int get_widget_xy(GtkWidget *win, GtkWidget *widget, int *rx, int *ry)
{
if (!win && !widget)
p_err("get_widget_xy err");
// gdk_flush();
GtkRequisition sz;
gtk_widget_get_preferred_size(widget, NULL, &sz);
int wx, wy;
wx=wy=0;
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
// dbg("%d wx:%d\n", index, wx);
int win_x, win_y;
gtk_window_get_position(GTK_WINDOW(win), &win_x, &win_y);
int win_xl, win_yl;
get_win_size(win, &win_xl, &win_yl);
if (wx > win_xl)
wx = win_xl;
*rx = win_x + wx;
*ry = win_y + wy;
return wx;
}
static void
menu_position_func (GtkMenu *menu,
int *x,
int *y,
gboolean *push_in,
GtkButton *button)
{
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (button);
GtkRequisition menu_req;
GtkTextDirection direction;
GdkWindow *window;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu));
gtk_window_set_type_hint (GTK_WINDOW (toplevel), GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU);
gtk_widget_get_preferred_size (GTK_WIDGET (menu),
&menu_req, NULL);
direction = gtk_widget_get_direction (widget);
window = gtk_widget_get_window (widget);
gtk_widget_get_allocation (widget, &allocation);
gdk_window_get_origin (window, x, y);
*x += allocation.x;
*y += allocation.y + allocation.height;
if (direction == GTK_TEXT_DIR_LTR)
*x += allocation.width - menu_req.width;
*push_in = FALSE;
}
wxSize wxChoice::DoGetSizeFromTextSize(int xlen, int ylen) const
{
wxASSERT_MSG( m_widget, wxS("GetSizeFromTextSize called before creation") );
// a GtkEntry for wxComboBox and a GtkCellView for wxChoice
GtkWidget* childPart = gtk_bin_get_child(GTK_BIN(m_widget));
// Set a as small as possible size for the control, so preferred sizes
// return "natural" sizes, not taking into account the previous ones (which
// seems to be GTK+3 behaviour)
gtk_widget_set_size_request(m_widget, 0, 0);
// We are interested in the difference of sizes between the whole contol
// and its child part. I.e. arrow, separators, etc.
GtkRequisition req;
gtk_widget_get_preferred_size(childPart, NULL, &req);
wxSize totalS = GTKGetPreferredSize(m_widget);
wxSize tsize(xlen + totalS.x - req.width, totalS.y);
// For a wxChoice, not for wxComboBox, add some margins
if ( !GTK_IS_ENTRY(childPart) )
tsize.IncBy(5, 0);
// Perhaps the user wants something different from CharHeight
if ( ylen > 0 )
tsize.IncBy(0, ylen - GetCharHeight());
return tsize;
}
wxSize wxChoice::DoGetSizeFromTextSize(int xlen, int ylen) const
{
wxASSERT_MSG( m_widget, wxS("GetSizeFromTextSize called before creation") );
// a GtkEntry for wxComboBox and a GtkCellView for wxChoice
GtkWidget* childPart = gtk_bin_get_child(GTK_BIN(m_widget));
// We are interested in the difference of sizes between the whole contol
// and its child part. I.e. arrow, separators, etc.
GtkRequisition req;
gtk_widget_get_preferred_size(childPart, NULL, &req);
wxSize totalS = GTKGetPreferredSize(m_widget);
wxSize tsize(xlen + totalS.x - req.width, totalS.y);
// For a wxChoice, not for wxComboBox, add some margins
if ( !GTK_IS_ENTRY(childPart) )
tsize.IncBy(5, 0);
// Perhaps the user wants something different from CharHeight
if ( ylen > 0 )
tsize.IncBy(0, ylen - GetCharHeight());
return tsize;
}
static gboolean
gdict_sidebar_select_button_press_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
GtkAllocation allocation;
if (event->button == 1)
{
GtkRequisition req;
gint width;
gtk_widget_get_allocation (widget, &allocation);
width = allocation.width;
gtk_widget_set_size_request (sidebar->priv->menu, -1, -1);
gtk_widget_get_preferred_size (sidebar->priv->menu, NULL, &req);
gtk_widget_set_size_request (sidebar->priv->menu,
MAX (width, req.width), -1);
gtk_widget_grab_focus (widget);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
gtk_menu_popup (GTK_MENU (sidebar->priv->menu),
NULL, NULL,
gdict_sidebar_menu_position_function, widget,
event->button, event->time);
return TRUE;
}
return FALSE;
}
static void
get_menu_pos (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
{
charpick_data *curr_data = data;
GtkRequisition reqmenu;
gint tempx, tempy, width, height;
gint screen_width, screen_height;
gtk_widget_get_preferred_size (GTK_WIDGET (menu), NULL, &reqmenu);
gdk_window_get_origin (GDK_WINDOW (gtk_widget_get_window(curr_data->applet)), &tempx, &tempy);
gdk_window_get_geometry (GDK_WINDOW (gtk_widget_get_window(curr_data->applet)), NULL, NULL,
&width, &height
);
switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (curr_data->applet))) {
case MATE_PANEL_APPLET_ORIENT_DOWN:
tempy += height;
break;
case MATE_PANEL_APPLET_ORIENT_UP:
tempy -= reqmenu.height;
break;
case MATE_PANEL_APPLET_ORIENT_LEFT:
tempx -= reqmenu.width;
break;
case MATE_PANEL_APPLET_ORIENT_RIGHT:
tempx += width;
break;
}
gdk_window_get_geometry (gdk_screen_get_root_window (gdk_screen_get_default()),
NULL, NULL, &screen_width, &screen_height);
*x = CLAMP (tempx, 0, MAX (0, screen_width - reqmenu.width));
*y = CLAMP (tempy, 0, MAX (0, screen_height - reqmenu.height));
}
static gboolean
get_child_position (GtkOverlay *overlay,
GtkWidget *widget,
GtkAllocation *allocation,
GtkColorEditor *editor)
{
GtkRequisition req;
GtkAllocation alloc;
gint s, e;
gtk_widget_get_preferred_size (widget, &req, NULL);
allocation->x = 0;
allocation->y = 0;
allocation->width = req.width;
allocation->height = req.height;
if (widget == editor->priv->sv_popup)
{
if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL)
allocation->x = 0;
else
allocation->x = gtk_widget_get_allocated_width (GTK_WIDGET (overlay)) - req.width;
allocation->y = req.height / 3;
}
else if (widget == editor->priv->h_popup)
{
gtk_widget_get_allocation (editor->priv->h_slider, &alloc);
gtk_range_get_slider_range (GTK_RANGE (editor->priv->h_slider), &s, &e);
if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL)
gtk_widget_translate_coordinates (editor->priv->h_slider,
gtk_widget_get_parent (editor->priv->grid),
- req.width, (s + e - req.height) / 2,
&allocation->x, &allocation->y);
else
gtk_widget_translate_coordinates (editor->priv->h_slider,
gtk_widget_get_parent (editor->priv->grid),
alloc.width, (s + e - req.height) / 2,
&allocation->x, &allocation->y);
}
else if (widget == editor->priv->a_popup)
{
gtk_widget_get_allocation (editor->priv->a_slider, &alloc);
gtk_range_get_slider_range (GTK_RANGE (editor->priv->a_slider), &s, &e);
gtk_widget_translate_coordinates (editor->priv->a_slider,
gtk_widget_get_parent (editor->priv->grid),
(s + e - req.width) / 2, - req.height,
&allocation->x, &allocation->y);
}
else
return FALSE;
allocation->x = CLAMP (allocation->x, 0, gtk_widget_get_allocated_width (GTK_WIDGET (overlay)) - req.width);
allocation->y = CLAMP (allocation->y, 0, gtk_widget_get_allocated_height (GTK_WIDGET (overlay)) - req.height);
return TRUE;
}
/**
* Constructor
*/
AboutBox::AboutBox() : Gtk::Dialog(_("About Inkscape")) {
// call this first
initStrings();
Gtk::Notebook *tabs=new Gtk::Notebook();
tabs->set_scrollable();
Gtk::Widget *splash=build_splash_widget();
if (splash) {
tabs->append_page(*manage(splash), _("_Splash"), true);
}
tabs->append_page(*manage(
make_scrolled_text(authors_text)), _("_Authors"), true);
tabs->append_page(*manage(
make_scrolled_text(translators_text)), _("_Translators"), true);
tabs->append_page(*manage(
make_scrolled_text(license_text)), _("_License"), true);
#if WITH_GTKMM_3_0
get_content_area()->pack_end(*manage(tabs), true, true);
#else
get_vbox()->pack_end(*manage(tabs), true, true);
#endif
tabs->show_all();
add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
set_default_response(Gtk::RESPONSE_CLOSE);
Gtk::Label *label=new Gtk::Label();
gchar *label_text =
g_strdup_printf("<small>Inkscape %s</small>",
Inkscape::version_string);
label->set_markup(label_text);
label->set_alignment(Gtk::ALIGN_END, Gtk::ALIGN_CENTER);
label->set_padding(5,0);
g_free(label_text);
label->set_selectable(true);
label->show();
#if WITH_GTKMM_3_0
get_content_area()->pack_start(*manage(label), false, false);
#else
get_vbox()->pack_start(*manage(label), false, false);
#endif
Gtk::Requisition requisition;
#if GTK_CHECK_VERSION(3,0,0)
gtk_widget_get_preferred_size(reinterpret_cast<GtkWidget*>(gobj()), &requisition, NULL);
#else
gtk_widget_size_request (reinterpret_cast<GtkWidget*>(gobj()), &requisition);
#endif
// allow window to shrink
set_size_request(0, 0);
set_default_size(requisition.width, requisition.height);
}
void
uim_cand_win_gtk_layout(UIMCandWinGtk *cwin,
gint topwin_x, gint topwin_y,
gint topwin_width, gint topwin_height)
{
GtkRequisition req;
int x, y;
int cursor_x, cursor_y;
int sc_he, cw_he; /*screen height, candidate window height*/
int sc_wi, cw_wi;
g_return_if_fail(UIM_IS_CAND_WIN_GTK(cwin));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_get_preferred_size(GTK_WIDGET(cwin), &req, NULL);
#else
gtk_widget_size_request(GTK_WIDGET(cwin), &req);
#endif
cw_wi = req.width;
cw_he = req.height;
sc_he = gdk_screen_get_height(gdk_screen_get_default ());
sc_wi = gdk_screen_get_width (gdk_screen_get_default ());
/* FIXME */
switch (cwin->position) {
case UIM_CAND_WIN_POS_LEFT:
cursor_x = 0;
break;
case UIM_CAND_WIN_POS_RIGHT:
cursor_x = topwin_width - cw_wi;
break;
default:
cursor_x = cwin->cursor.x;
break;
}
cursor_y = cwin->cursor.y;
if (sc_wi < topwin_x + cursor_x + cw_wi) {
/* x = topwin_x + cursor_x - cw_wi; */
x = sc_wi - cw_wi;
} else {
x = topwin_x + cursor_x;
}
if (sc_he < topwin_y + cursor_y + cwin->cursor.height + cw_he) {
y = topwin_y + cursor_y - cw_he;
} else {
y = topwin_y + cursor_y + cwin->cursor.height;
}
gtk_window_move(GTK_WINDOW(cwin), x, y);
#if GTK_CHECK_VERSION(3, 7, 8)
if (gtk_widget_get_mapped(cwin->view) && GTK_IS_TREE_VIEW(cwin->view))
gtk_widget_queue_resize_no_redraw(cwin->view);
#endif
uim_cand_win_gtk_layout_sub_window(cwin);
}
void get_win_size(GtkWidget *win, int *width, int *height)
{
GtkRequisition sz;
sz.width = sz.height = 0;
gtk_widget_get_preferred_size(GTK_WIDGET(win), NULL, &sz);
*width = sz.width;
*height = sz.height;
}
static void
hd_status_area_box_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
HDStatusAreaBoxPrivate *priv;
guint border_width;
GtkAllocation child_allocation = {0, 0, 0, 0};
guint visible_children = 0;
GList *c;
priv = HD_STATUS_AREA_BOX (widget)->priv;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
/* chain up */
GTK_WIDGET_CLASS (hd_status_area_box_parent_class)->size_allocate (widget,
allocation);
child_allocation.height = ITEM_HEIGHT;
/* Place the first eight visible children */
for (c = priv->children; c && visible_children < priv->max_visible_children; c = c->next)
{
HDStatusAreaBoxChild *info = c->data;
GtkRequisition child_requisition;
/* ignore hidden widgets */
if (!gtk_widget_is_visible (info->widget))
continue;
/* there are some widgets which need a size request */
gtk_widget_get_preferred_size (info->widget, &child_requisition, NULL);
child_allocation.x = allocation->x +
border_width +
PADDING_LEFT +
(visible_children / 2) * (ITEM_WIDTH + SPACING);
child_allocation.y = allocation->y +
border_width +
(visible_children % 2 * (ITEM_HEIGHT + SPACING));
child_allocation.width = ITEM_WIDTH;
child_allocation.height = ITEM_HEIGHT;
gtk_widget_size_allocate (info->widget, &child_allocation);
gtk_widget_set_child_visible (info->widget, TRUE);
visible_children++;
}
/* Hide the other children */
for (; c; c = c->next)
{
HDStatusAreaBoxChild *info = c->data;
gtk_widget_set_child_visible (info->widget, FALSE);
}
}
static void
overlay_draw (GtkDrawingArea *da,
cairo_t *cr,
int width,
int height,
gpointer data)
{
GtkWidget *widget = GTK_WIDGET (da);
PangoLayout *layout;
const double dashes[] = { 6, 18 };
GtkAllocation label_allocation;
GtkRequisition minimum_size, natural_size;
GtkWidget *label = data;
gint x, y;
cairo_translate (cr, -0.5, -0.5);
cairo_set_line_width (cr, 1);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_rectangle (cr, 0, 0, width, height);
cairo_fill (cr);
gtk_widget_translate_coordinates (label, widget, 0, 0, &x, &y);
layout = gtk_widget_create_pango_layout (widget, "");
gtk_widget_get_preferred_size (label, &minimum_size, &natural_size);
pango_layout_set_markup (layout,
"<span color='#c33'>\342\227\217 requisition</span>\n"
"<span color='#3c3'>\342\227\217 natural size</span>\n"
"<span color='#33c'>\342\227\217 allocation</span>", -1);
pango_cairo_show_layout (cr, layout);
g_object_unref (layout);
gtk_widget_get_allocation (label, &label_allocation);
cairo_rectangle (cr,
x + 0.5 * (label_allocation.width - minimum_size.width),
y + 0.5 * (label_allocation.height - minimum_size.height),
minimum_size.width, minimum_size.height);
cairo_set_source_rgb (cr, 0.8, 0.2, 0.2);
cairo_set_dash (cr, NULL, 0, 0);
cairo_stroke (cr);
cairo_rectangle (cr, x, y, label_allocation.width, label_allocation.height);
cairo_set_source_rgb (cr, 0.2, 0.2, 0.8);
cairo_set_dash (cr, dashes, 2, 0.5);
cairo_stroke (cr);
cairo_rectangle (cr,
x + 0.5 * (label_allocation.width - natural_size.width),
y + 0.5 * (label_allocation.height - natural_size.height),
natural_size.width, natural_size.height);
cairo_set_source_rgb (cr, 0.2, 0.8, 0.2);
cairo_set_dash (cr, dashes, 2, 12.5);
cairo_stroke (cr);
}
static void
brasero_file_chooser_find_pane (GtkWidget *child,
gpointer footer)
{
if (GTK_IS_PANED (child)) {
GList *children_vbox;
GList *iter_vbox;
GtkWidget *vbox;
vbox = gtk_paned_get_child2 (GTK_PANED (child));
children_vbox = gtk_container_get_children (GTK_CONTAINER (vbox));
for (iter_vbox = children_vbox; iter_vbox; iter_vbox = iter_vbox->next) {
if (GTK_IS_BOX (iter_vbox->data) &&
gtk_orientable_get_orientation (GTK_ORIENTABLE (iter_vbox->data)) == GTK_ORIENTATION_HORIZONTAL) {
GtkPackType packing;
gtk_box_query_child_packing (GTK_BOX (vbox),
GTK_WIDGET (iter_vbox->data),
NULL,
NULL,
NULL,
&packing);
if (packing == GTK_PACK_START) {
GtkRequisition total_request, footer_request;
gtk_widget_get_preferred_size (GTK_WIDGET (vbox),
&total_request, NULL);
gtk_widget_get_preferred_size (GTK_WIDGET (iter_vbox->data),
&footer_request, NULL);
*((gint *) footer) = total_request.height - footer_request.height;
break;
}
}
}
g_list_free (children_vbox);
}
else if (GTK_IS_CONTAINER (child)) {
gtk_container_foreach (GTK_CONTAINER (child),
brasero_file_chooser_find_pane,
footer);
}
}
