wxSize wxControl::DoGetBestSize() const { // Do not return any arbitrary default value... wxASSERT_MSG( m_widget, wxT("DoGetBestSize called before creation") ); wxSize best; if (m_wxwindow) { // this is not a native control, size_request is likely to be (0,0) best = wxControlBase::DoGetBestSize(); } else { GtkRequisition req; #ifdef __WXGTK3__ if (gtk_widget_get_request_mode(m_widget) != GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH) { gtk_widget_get_preferred_height(m_widget, NULL, &req.height); gtk_widget_get_preferred_width_for_height(m_widget, req.height, NULL, &req.width); } else { gtk_widget_get_preferred_width(m_widget, NULL, &req.width); gtk_widget_get_preferred_height_for_width(m_widget, req.width, NULL, &req.height); } #else GTK_WIDGET_GET_CLASS(m_widget)->size_request(m_widget, &req); #endif best.Set(req.width, req.height); } CacheBestSize(best); return best; }
/** * gtk_widget_get_preferred_size: * @widget: a #GtkWidget instance * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL * * Retrieves the minimum and natural size of a widget, taking * into account the widget's preference for height-for-width management. * * This is used to retrieve a suitable size by container widgets which do * not impose any restrictions on the child placement. It can be used * to deduce toplevel window and menu sizes as well as child widgets in * free-form containers such as GtkLayout. * * <note><para>Handle with care. Note that the natural height of a height-for-width * widget will generally be a smaller size than the minimum height, since the required * height for the natural width is generally smaller than the required height for * the minimum width.</para></note> * * Since: 3.0 */ void gtk_widget_get_preferred_size (GtkWidget *widget, GtkRequisition *minimum_size, GtkRequisition *natural_size) { gint min_width, nat_width; gint min_height, nat_height; g_return_if_fail (GTK_IS_WIDGET (widget)); if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH) { gtk_widget_get_preferred_width (widget, &min_width, &nat_width); if (minimum_size) { minimum_size->width = min_width; gtk_widget_get_preferred_height_for_width (widget, min_width, &minimum_size->height, NULL); } if (natural_size) { natural_size->width = nat_width; gtk_widget_get_preferred_height_for_width (widget, nat_width, NULL, &natural_size->height); } } else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT or CONSTANT_SIZE */ { gtk_widget_get_preferred_height (widget, &min_height, &nat_height); if (minimum_size) { minimum_size->height = min_height; gtk_widget_get_preferred_width_for_height (widget, min_height, &minimum_size->width, NULL); } if (natural_size) { natural_size->height = nat_height; gtk_widget_get_preferred_width_for_height (widget, nat_height, NULL, &natural_size->width); } } }
static void gtk_widget_query_size_for_orientation (GtkWidget *widget, GtkOrientation orientation, gint for_size, gint *minimum_size, gint *natural_size) { SizeRequestCache *cache; gint min_size = 0; gint nat_size = 0; gboolean found_in_cache; if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_CONSTANT_SIZE) for_size = -1; cache = _gtk_widget_peek_request_cache (widget); found_in_cache = _gtk_size_request_cache_lookup (cache, orientation, for_size, &min_size, &nat_size); if (!found_in_cache) { gint adjusted_min, adjusted_natural, adjusted_for_size = for_size; G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_widget_ensure_style (widget); G_GNUC_END_IGNORE_DEPRECATIONS; if (orientation == GTK_ORIENTATION_HORIZONTAL) { if (for_size < 0) { push_recursion_check (widget, orientation, for_size); GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_size, &nat_size); pop_recursion_check (widget, orientation); } else { gint ignored_position = 0; gint minimum_height; gint natural_height; /* Pull the base natural height from the cache as it's needed to adjust * the proposed 'for_size' */ gtk_widget_get_preferred_height (widget, &minimum_height, &natural_height); /* convert for_size to unadjusted height (for_size is a proposed allocation) */ GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget, GTK_ORIENTATION_VERTICAL, &minimum_height, &natural_height, &ignored_position, &adjusted_for_size); push_recursion_check (widget, orientation, for_size); GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget, MAX (adjusted_for_size, minimum_height), &min_size, &nat_size); pop_recursion_check (widget, orientation); } } else { if (for_size < 0) { push_recursion_check (widget, orientation, for_size); GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_size, &nat_size); pop_recursion_check (widget, orientation); } else { gint ignored_position = 0; gint minimum_width; gint natural_width; /* Pull the base natural width from the cache as it's needed to adjust * the proposed 'for_size' */ gtk_widget_get_preferred_width (widget, &minimum_width, &natural_width); /* convert for_size to unadjusted width (for_size is a proposed allocation) */ GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget, GTK_ORIENTATION_HORIZONTAL, &minimum_width, &natural_width, &ignored_position, &adjusted_for_size); push_recursion_check (widget, orientation, for_size); GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, MAX (adjusted_for_size, minimum_width), &min_size, &nat_size); pop_recursion_check (widget, orientation); } } if (min_size > nat_size) { g_warning ("%s %p reported min size %d and natural size %d in %s(); natural size must be >= min size", G_OBJECT_TYPE_NAME (widget), widget, min_size, nat_size, get_vfunc_name (orientation, for_size)); } adjusted_min = min_size; adjusted_natural = nat_size; GTK_WIDGET_GET_CLASS (widget)->adjust_size_request (widget, orientation, &adjusted_min, &adjusted_natural); if (adjusted_min < min_size || adjusted_natural < nat_size) { g_warning ("%s %p adjusted size %s min %d natural %d must not decrease below min %d natural %d", G_OBJECT_TYPE_NAME (widget), widget, orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal", adjusted_min, adjusted_natural, min_size, nat_size); /* don't use the adjustment */ } else if (adjusted_min > adjusted_natural) { g_warning ("%s %p adjusted size %s min %d natural %d original min %d natural %d has min greater than natural", G_OBJECT_TYPE_NAME (widget), widget, orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal", adjusted_min, adjusted_natural, min_size, nat_size); /* don't use the adjustment */ } else { /* adjustment looks good */ min_size = adjusted_min; nat_size = adjusted_natural; } _gtk_size_request_cache_commit (cache, orientation, for_size, min_size, nat_size); } if (minimum_size) *minimum_size = min_size; if (natural_size) *natural_size = nat_size; g_assert (min_size <= nat_size); GTK_NOTE (SIZE_REQUEST, g_print ("[%p] %s\t%s: %d is minimum %d and natural: %d (hit cache: %s)\n", widget, G_OBJECT_TYPE_NAME (widget), orientation == GTK_ORIENTATION_HORIZONTAL ? "width for height" : "height for width" , for_size, min_size, nat_size, found_in_cache ? "yes" : "no")); }
static void gstyle_slidein_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height) { GstyleSlidein *self = (GstyleSlidein *)widget; GtkWidget *child; gint min_height_slide_based; gint nat_height_slide_based; g_assert (GSTYLE_IS_SLIDEIN (self)); *min_height = *nat_height = 1; child = gtk_bin_get_child (GTK_BIN (self)); if (child != NULL) gtk_widget_get_preferred_width (child, min_height, nat_height); if (self->interpolate_size || (self->overlay_child != NULL && gtk_widget_get_visible (self->overlay_child))) { if (gtk_widget_get_request_mode (self->overlay_child) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH) { gint min_width; gint nat_width; gtk_widget_get_preferred_width (self->overlay_child, &min_width, &nat_width); GTK_WIDGET_GET_CLASS(self->overlay_child)->get_preferred_height_for_width (self->overlay_child, min_width, &min_height_slide_based, &nat_height_slide_based); } else gtk_widget_get_preferred_height (self->overlay_child, &min_height_slide_based, &nat_height_slide_based); if (get_orientation (self) == GTK_ORIENTATION_VERTICAL) { if (!self->interpolate_size) { min_height_slide_based *= self->offset; nat_height_slide_based *= self->offset; } if (self->slide_fraction > 0) { min_height_slide_based /= self->slide_fraction; nat_height_slide_based /= self->slide_fraction; } min_height_slide_based += self->slide_margin; nat_height_slide_based += self->slide_margin; } /* TODO: add dynamic grow/shrink mode */ *min_height = MAX (*min_height, min_height_slide_based); *nat_height = MAX (*nat_height, nat_height_slide_based); } else { *min_height = MAX (*min_height, self->slide_margin); *nat_height = MAX (*nat_height, self->slide_margin); } }