public override Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { if (childBackend == null) return base.GetPreferredSize (widthConstraint, heightConstraint); var size = childBackend.Frontend.Surface.GetPreferredSize (widthConstraint, heightConstraint, true); return size; }
public override Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var r = new System.Drawing.RectangleF(0, 0, widthConstraint.IsConstrained ? (float)widthConstraint.AvailableSize : float.MaxValue, heightConstraint.IsConstrained ? (float)heightConstraint.AvailableSize : float.MaxValue); var s = Widget.Cell.CellSizeForBounds(r); return(new Size(s.Width, s.Height)); }
protected override Size OnGetPreferredSize(SizeConstraint w, SizeConstraint h) { double width = 0; double height = 0; if (horizontal) { width = start_border + end_border; } else { height = start_border + end_border; } foreach (AnimatedWidget widget in Widgets) { var req = widget.Surface.GetPreferredSize(); if (horizontal) { width += req.Width; height = Math.Max(height, req.Height); } else { width = Math.Max(width, req.Width); height += req.Height; } } return(new Size(width, height)); }
private static Size?CalculateRenderSize(SizeConstraint constraint) { if (constraint == null) { return(null); } if (!constraint.ShouldUsePadding || constraint.Padding.Bottom == 0 && constraint.Padding.Top == 0 && constraint.Padding.Left == 0 && constraint.Padding.Right == 0) { return(constraint.Size); } var thickness = constraint.Padding; var size = constraint.Size; var width = size.Width - (int)Math.Round(thickness.Left + thickness.Right); if (width < 0) { width = 0; } var height = size.Height - (int)Math.Round(thickness.Top + thickness.Bottom); if (height < 0) { height = 0; } return(new Size(width, height)); }
protected override Size MeasureSelf(SizeConstraint constraint) { if (Root == null || Root.Canvas == null || Root.Canvas.IsDisposed) { /// 測れないので現状維持 return(constraint.MeasureConstrainedSize(Size)); } if (!IsVisible) { /// 現状維持 return(constraint.MeasureConstrainedSize(Size)); } using (var g = Root.Canvas.CreateGraphics()) using (_ResourceCache.UseResource()) { /// _ImageResourceを参照しておかないとImageSizeが正しく取れないことがある var image = _ImageResource; if (Text != null) { var textSize = MeasureText(g, Text, _FontResource, int.MaxValue); var size = new Size( ImageSize.Width + Margin + textSize.Width + Padding.Width, Math.Max(ImageSize.Height, textSize.Height) + Padding.Height ); return(constraint.MeasureConstrainedSize(size)); } else { return(constraint.MeasureConstrainedSize(ImageSize)); } } }
/// <summary> /// Constructor for the ShoppingCartViewModel. /// </summary> /// <param name="cart">A shopping cart object.</param> public ShoppingCartViewModel(ShoppingCartInfo cart) { // Creates a collection containing all lines from the given shopping cart CartItems = cart.CartProducts.Select((cartItemInfo) => { return(new ShoppingCartItemViewModel() { CartItemUnits = cartItemInfo.CartItemUnits, SKUName = cartItemInfo.SKU.SKUName, TotalPrice = cartItemInfo.TotalPrice, CartItemID = cartItemInfo.CartItemID, SKUID = cartItemInfo.SKUID, SKUImageUrl = string.IsNullOrEmpty(cartItemInfo.SKU.SKUImagePath) ? null : new FileUrl(cartItemInfo.SKU.SKUImagePath, true) .WithSizeConstraint(SizeConstraint.MaxWidthOrHeight(100)) .RelativePath }); }); CurrencyFormatString = cart.Currency.CurrencyFormatString; CouponCodes = cart.CouponCodes.AllAppliedCodes.Select(x => x.Code); TotalTax = cart.TotalTax; TotalShipping = cart.TotalShipping; GrandTotal = cart.GrandTotal; RemainingAmountForFreeShipping = cart.CalculateRemainingAmountForFreeShipping(); IsEmpty = cart.IsEmpty; }
protected override Size OnGetPreferredSize(SizeConstraint w, SizeConstraint h) { var size = base.OnGetPreferredSize(w, h); double descriptionWidth = 1; double totalHeight = yBorder * 2 + 1; layout.Text = TitleText; var lsize = layout.GetSize(); totalHeight += lsize.Height; xSpacer = 0; foreach (var pair in Items) { layout.Markup = pair.Key; var w1 = layout.GetSize(); layout.Markup = pair.Value; var w2 = layout.GetSize(); descriptionWidth = System.Math.Max(descriptionWidth, w2.Width); xSpacer = System.Math.Max(xSpacer, w1.Width); totalHeight += w2.Height; } xSpacer += xBorder * 2 + 1; return(new Size(descriptionWidth + xSpacer + xBorder * 2 + 1, totalHeight)); }
public override Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { if (this.direction == Orientation.Vertical) return new Size (1, heightConstraint.IsConstrained ? heightConstraint.AvailableSize : 0); else return new Size (widthConstraint.IsConstrained ? widthConstraint.AvailableSize : 0, 1); }
protected override Size OnGetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var lvsize = base.OnGetPreferredSize(widthConstraint, heightConstraint); var s = layout.GetSize(); rowHeight = (int)s.Height + padding; visibleRows = 7;//(winHeight + padding - margin * 2) / rowHeight; double newHeight; if (this.win.DataProvider.Count > this.visibleRows) { newHeight = (rowHeight * visibleRows) + margin * 2; } else { newHeight = (rowHeight * this.win.DataProvider.Count) + margin * 2; } if (lvsize.Width != listWidth || lvsize.Height != newHeight) { return(new Size(listWidth, newHeight)); } return(lvsize); }
void UpdateChildSize() { if (child == null) { return; } if (Widget.ContentView is CustomClipView) { } else { NSView view = (NSView)Widget.DocumentView; ViewBackend c = (ViewBackend)child; Size s; if (horizontalScrollPolicy == ScrollPolicy.Never) { s = c.Frontend.Surface.GetPreferredSize(SizeConstraint.WithSize(Widget.ContentView.Frame.Width), SizeConstraint.Unconstrained); } else if (verticalScrollPolicy == ScrollPolicy.Never) { s = c.Frontend.Surface.GetPreferredSize(SizeConstraint.Unconstrained, SizeConstraint.WithSize(Widget.ContentView.Frame.Width)); } else { s = c.Frontend.Surface.GetPreferredSize(); } var w = Math.Max(s.Width, Widget.ContentView.Frame.Width); var h = Math.Max(s.Height, Widget.ContentView.Frame.Height); view.Frame = new System.Drawing.RectangleF(view.Frame.X, view.Frame.Y, (float)s.Width, (float)h); } }
public Size OnGetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var children = (ChildrenCollection <BoxPlacement>)GetFieldValuePrivate(typeof(Box), owner, "children"); double spacing = owner.Spacing; Size s = new Size(); int count = 0; var visibleChildren = children.Where(b => b.Child.Visible).ToArray(); Dictionary <BoxPlacement, double> nextsize = null; if (direction == Orientation.Horizontal) { // If the width is constrained then we have a total width, and we can calculate the exact width assigned to each child. // We can then use that width as a width constraint for the child. if (widthConstraint.IsConstrained) { nextsize = CalcDefaultSizes(widthConstraint, heightConstraint, false); // Calculates the width assigned to each child } foreach (var cw in visibleChildren) { // Use the calculated width if available var wsize = cw.Child.Surface.GetPreferredSize(widthConstraint.IsConstrained ? nextsize[cw] : SizeConstraint.Unconstrained, heightConstraint, true); s.Width += wsize.Width; if (wsize.Height > s.Height) { s.Height = wsize.Height; } count++; } if (count > 0) { s.Width += spacing * (double)(count - 1); } } else { if (heightConstraint.IsConstrained) { nextsize = CalcDefaultSizes(widthConstraint, heightConstraint, false); } foreach (var cw in visibleChildren) { var wsize = cw.Child.Surface.GetPreferredSize(widthConstraint, heightConstraint.IsConstrained ? nextsize[cw] : SizeConstraint.Unconstrained, true); s.Height += wsize.Height; if (wsize.Width > s.Width) { s.Width = wsize.Width; } count++; } if (count > 0) { s.Height += spacing * (double)(count - 1); } } return(s); }
public void GetHashCode_SameHeight_SameHashCode(int firstConstraintWidth, int secondConstraintWidth) { var constraint1 = SizeConstraint.Height(firstConstraintWidth); var constraint2 = SizeConstraint.Height(secondConstraintWidth); Assert.AreEqual(constraint1, constraint2); }
public void GetHashCode_DifferentMaxWidthOrHeight_DifferentHashCode(int firstConstraintWidth, int secondConstraintWidth) { var constraint1 = SizeConstraint.MaxWidthOrHeight(firstConstraintWidth); var constraint2 = SizeConstraint.MaxWidthOrHeight(secondConstraintWidth); Assert.AreNotEqual(constraint1, constraint2); }
public override Size Measure(IFigure parent, SizeConstraint constraint) { if (!parent.Children.Any()) { return(_emptyPreferredSize + _padding.Size); } var ret = new Size(0, _padding.Top); var clientAreaConstraint = constraint.Deflate(_padding.Size); foreach (var child in parent.Children) { if (child.IsVisible) { child.Measure(clientAreaConstraint); var prefSize = child.PreferredSize; ret.Width = Math.Max(prefSize.Width, ret.Width); ret.Height += prefSize.Height + _itemSpace; } } ret.Width += _padding.Width; ret.Height += _padding.Bottom - _itemSpace; return(constraint.MeasureConstrainedSize(ret)); }
protected override Size OnGetRequiredSize (SizeConstraint widthConstraint) { var buildOutputNode = GetValue (BuildOutputNodeField); var status = GetViewStatus (buildOutputNode); double minWidth = ImageSize + ImagePadding + MinLayoutWidth + DefaultInformationContainerWidth; if (widthConstraint.IsConstrained) minWidth = Math.Max (minWidth, widthConstraint.AvailableSize); // in collapsed state we have always the same height and require the minimal width // if the layout height has not been calculated yet, use the ImageSize for the height if (!status.Expanded) { return new Size (minWidth, status.CollapsedRowHeight > -1 ? status.CollapsedRowHeight : ImageSize); } double maxLayoutWidth; if (widthConstraint.IsConstrained) maxLayoutWidth = minWidth - ((ImageSize - 3) + ImageSize + ImagePadding + DefaultInformationContainerWidth); else maxLayoutWidth = status.LastRenderLayoutBounds.Width; var layout = status.GetUnconstrainedLayout (); layout.Width = maxLayoutWidth; var textSize = layout.GetSize (); var height = Math.Max (textSize.Height + 2 * status.LayoutYPadding, DefaultRowHeight); return new Size (minWidth, height); }
public void Equals_DifferentInstancesSameSizes_ReturnsTrue() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(100, 200); Assert.That(constraint1.Equals(constraint2), Is.True); }
void Reallocate() { var contentWidth = (Controller.DefaultPageSize.Width > 0 ? Controller.DefaultPageSize.Width : 660); var pageRequest = currentPageWidget.Surface.GetPreferredSize(true); contentWidth = Math.Max(contentWidth, pageRequest.Width); pageRequest = currentPageWidget.Surface.GetPreferredSize(SizeConstraint.WithSize(contentWidth), SizeConstraint.Unconstrained, true); var contentHeight = pageRequest.Height; var rightSideWidget = currentPage.GetRightSideWidget() ?? Controller.RightSideWidget; if (rightSideWidget != null) { var widget = (Xwt.Widget)rightSideWidget; if (rightSideFrame.Content != widget) { rightSideFrame.Content = widget; rightSideFrame.Content.VerticalPlacement = rightSideFrame.Content.HorizontalPlacement = WidgetPlacement.Fill; rightSideFrame.Visible = true; } Dialog.Width = contentWidth + RightSideWidgetWidth; } else { rightSideFrame.Visible = false; Dialog.Width = contentWidth; } Dialog.Height = Math.Max(contentHeight, Controller.DefaultPageSize.Height) + buttonBox.Size.Height; }
public void NotEqualOperator_DifferentInstancesSameSizes_ReturnsFalse() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(100, 200); Assert.That(constraint1 != constraint2, Is.False); }
public void NotEqualOperator_DifferentInstancesDifferentSizes_ReturnsTrue() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(300, 500); Assert.That(constraint1 != constraint2, Is.True); }
/// <summary> /// Creates a new product model. /// </summary> /// <param name="productPage">Product's page.</param> /// <param name="priceDetail">Price of the product.</param> public ProductViewModel(SKUTreeNode productPage, ProductCatalogPrices priceDetail) { // Fills the page information Name = productPage.DocumentName; Description = productPage.DocumentSKUDescription; ShortDescription = productPage.DocumentSKUShortDescription; // Fills the SKU information SKUInfo sku = productPage.SKU; SKUID = sku.SKUID; ImagePath = string.IsNullOrEmpty(sku.SKUImagePath) ? null : new FileUrl(sku.SKUImagePath, true) .WithSizeConstraint(SizeConstraint.MaxWidthOrHeight(400)) .RelativePath; IsInStock = sku.SKUTrackInventory == TrackInventoryTypeEnum.Disabled || sku.SKUAvailableItems > 0; PriceDetail = new PriceDetailViewModel() { Price = priceDetail.Price, ListPrice = priceDetail.ListPrice, CurrencyFormatString = priceDetail.Currency.CurrencyFormatString }; }
protected override Size OnGetRequiredSize(SizeConstraint widthConstraint) { var node = GetValue(NodeField); var status = GetViewStatus(node); TextLayout layout = new TextLayout(); layout.Text = node.Text; var textSize = layout.GetSize(); var maxWidth = widthConstraint.IsConstrained ? widthConstraint.AvailableSize : status.LastRenderWidth; // When in expanded mode, the height of the row depends on the width. Since we don't know the width, // let's use the last width that was used for rendering. if (status.Expanded && maxWidth > 0 && textSize.Width > maxWidth) { layout.Width = maxWidth - addImage.Width - MoreLinkSpacing; textSize = layout.GetSize(); } status.LastCalculatedHeight = textSize.Height; return(new Size(30, textSize.Height)); }
void HandleWidgetSizeRequested(object o, Gtk.SizeRequestedArgs args) { var req = args.Requisition; if (!gettingPreferredSize && (enabledEvents & WidgetEvent.PreferredSizeCheck) != 0) { SizeConstraint wc = SizeConstraint.Unconstrained, hc = SizeConstraint.Unconstrained; var cp = Widget.Parent as IConstraintProvider; if (cp != null) { cp.GetConstraints(Widget, out wc, out hc); } ApplicationContext.InvokeUserCode(delegate { var w = eventSink.GetPreferredSize(wc, hc); req.Width = (int)w.Width; req.Height = (int)w.Height; }); } if (Frontend.MinWidth != -1 && Frontend.MinWidth > req.Width) { req.Width = (int)Frontend.MinWidth; } if (Frontend.MinHeight != -1 && Frontend.MinHeight > req.Height) { req.Height = (int)Frontend.MinHeight; } args.Requisition = req; }
// The GetPreferredSize method is called when the corresponding OnGetPreferredSize method in the // XWT widget is not overriden, or if it is overriden and the new implementation calls // base.OnGetPreferredSize. For this reason, we have to ensure that the widget's MeasureOverride // method doesn't end calling the frontend OnGetPreferredSize method. To avoid it we set // the calculatingPreferredSize flag to true, and we check this flag in MeasureOverride public virtual Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { SW.Size size; Widget.InvalidateMeasure(); GetWidgetDesiredSize(widthConstraint.IsConstrained ? widthConstraint.AvailableSize : Double.PositiveInfinity, heightConstraint.IsConstrained ? heightConstraint.AvailableSize : Double.PositiveInfinity, out size); return(new Size(size.Width, size.Height)); }
public void Equals_DifferentInstancesDifferentSizes_ReturnsFalse() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(300, 500); Assert.That(constraint1.Equals(constraint2), Is.False); }
public Size OnGetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { Size s = new Size(); int count = 0; double[] nextsize = null; double spacing = this.owner.Spacing; // If the width is constrained then we have a total width, and we can calculate the exact width assigned to each child. // We can then use that width as a width constraint for the child. if (widthConstraint.IsConstrained) { nextsize = CalcDefaultSizes(widthConstraint, heightConstraint, false); // Calculates the width assigned to each child } for (var nit = 0; nit < this.owner.Placements.Count; nit++) { // Use the calculated width if available var wsize = this.owner.Placements[nit].Child.GetBackend().GetPreferredSize(widthConstraint.IsConstrained ? SizeConstraint.WithSize(nextsize[nit]) : SizeConstraint.Unconstrained, heightConstraint); s.Width += wsize.Width; if (wsize.Height > s.Height) { s.Height = wsize.Height; } count++; } if (count > 0) { s.Width += spacing * (double)(count - 1); } return(s); }
public void GetHashCode_SameSizes_SameHashCode() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(100, 200); Assert.AreEqual(constraint1.GetHashCode(), constraint2.GetHashCode()); }
public override Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var s = EventSink.GetDefaultNaturalSize(); if (child == null) { return(s); } if (widthConstraint.IsConstrained) { s.Width = widthConstraint.AvailableSize; } if (heightConstraint.IsConstrained) { s.Height = heightConstraint.AvailableSize; } var childWidthConstraint = horizontalScrollPolicy == ScrollPolicy.Never ? widthConstraint : SizeConstraint.Unconstrained; var childHeightConstraint = verticalScrollPolicy == ScrollPolicy.Never ? heightConstraint : SizeConstraint.Unconstrained; var schild = ((ViewBackend)child).Frontend.Surface.GetPreferredSize(childWidthConstraint, childHeightConstraint, true); if (horizontalScrollPolicy == ScrollPolicy.Never) { s.Width = Math.Max(s.Width, schild.Width); } if (verticalScrollPolicy == ScrollPolicy.Never) { s.Height = Math.Max(s.Height, schild.Height); } return(s); }
public void GetHashCode_DifferentSizes_DifferentHashCode() { var constraint1 = SizeConstraint.Size(100, 200); var constraint2 = SizeConstraint.Size(101, 200); Assert.AreNotEqual(constraint1.GetHashCode(), constraint2.GetHashCode()); }
public override void Arrange(IFigure parent) { var clientArea = _padding.GetClientArea(parent.Bounds); var constraint = new SizeConstraint(clientArea.Size); var itemTop = parent.Top + _padding.Top; foreach (var child in parent.Children) { if (child.IsVisible) { var csize = child.PreferredSize; child.Location = new Point(parent.Left + _padding.Left, itemTop); if (_adjustItemWidth) { child.Width = clientArea.Width; } child.Height = csize.Height; itemTop += child.Height + ItemSpace; } } if (_extendLast && parent.Children.Count > 0) { /// 最後のchildを残りいっぱいの大きさにする var lastItem = parent.Children.Last(); lastItem.Height = clientArea.Bottom - lastItem.Top; } }
protected override Size OnGetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var size = base.OnGetPreferredSize(widthConstraint, heightConstraint); var content = GetContentBound(); return(content.Size + new Size(10, 10)); }
protected override Size OnGetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { foreach (DockItem item in items.GetVisibleItems()) { item.Panel?.Surface.GetPreferredSize(); } return(items.GetBound(0, 0).Size); }
protected override Size OnGetPreferredSize(SizeConstraint width, SizeConstraint height) { //if (Child != null) // Child.SizeRequest(); //vScrollBar.SizeRequest(); //hScrollBar.SizeRequest(); return(base.OnGetPreferredSize(width, height)); }
public override Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { var s = base.GetPreferredSize (widthConstraint, heightConstraint); // If the label is ellipsized or can wrap then the width can't be dermined unless we have a constraint. // If there is no constraint, just return the smallest size if (!widthConstraint.IsConstrained && (Wrap != WrapMode.None || Ellipsize != EllipsizeMode.None)) s.Width = 1; return s; }
public virtual Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { try { SetSizeConstraints (widthConstraint, heightConstraint); gettingPreferredSize = true; var sr = Widget.SizeRequest (); return new Size (sr.Width, sr.Height); } finally { gettingPreferredSize = false; } }
public virtual Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { SetSizeConstraints (widthConstraint, heightConstraint); int min_width = 0; int min_height = 0; IWidgetBackend xwt_backend = Widget as IWidgetBackend; if (xwt_backend != null) { var size = xwt_backend.GetPreferredSize (widthConstraint, heightConstraint); min_width = (int)size.Width; min_height = (int)size.Height; } else { int nat_width, nat_height; if (widthConstraint.IsConstrained) { Widget.GetPreferredHeightForWidth((int)widthConstraint.AvailableSize, out min_height, out nat_height); } else if (heightConstraint.IsConstrained) { Widget.GetPreferredWidthForHeight ((int)heightConstraint.AvailableSize, out min_width, out nat_width); } else if ((heightConstraint.IsConstrained) && (widthConstraint.IsConstrained)) { } else { Widget.GetPreferredHeight (out min_height, out nat_height); Widget.GetPreferredWidth (out min_width, out nat_width); } } if ((enabledEvents & WidgetEvent.PreferredSizeCheck) != 0) { SizeConstraint wc = SizeConstraint.Unconstrained, hc = SizeConstraint.Unconstrained; var cp = Widget.Parent as IConstraintProvider; if (cp != null) cp.GetConstraints (Widget, out wc, out hc); ApplicationContext.InvokeUserCode (delegate { var w = eventSink.GetPreferredSize (wc, hc); min_width = (int) w.Width; min_height = (int) w.Height; }); } if (Widget.WidthRequest > min_width) min_width = Widget.WidthRequest; if (Widget.HeightRequest > min_height) min_height = Widget.HeightRequest; if (Frontend.MinWidth > 0 && Frontend.MinWidth > min_width) min_width = (int) Frontend.MinWidth; if (Frontend.MinHeight > 0 && Frontend.MinHeight > min_height) min_height = (int) Frontend.MinHeight; return new Size(min_width, min_height); }
// The size of the container is the size of the child, // so we redirect size calculations to the child. public override Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { return child != null ? child.Surface.GetPreferredSize (widthConstraint, heightConstraint) : Size.Zero; }
public override Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { return Size.Zero; }
public void GetConstraints(Gtk.Widget target, out SizeConstraint width, out SizeConstraint height) { width = height = SizeConstraint.Unconstrained; }
public override Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { Size preSize = base.GetPreferredSize(widthConstraint, heightConstraint); if(Button.Content is string) { string label = (string)Button.Content; System.Windows.Media.FormattedText formattedText = new System.Windows.Media.FormattedText(label, System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface(Button.FontFamily, Button.FontStyle, Button.FontWeight, Button.FontStretch), Button.FontSize, null); double formattedTextWidth = formattedText.WidthIncludingTrailingWhitespace; preSize.Width = formattedTextWidth + 10; } return preSize; }
// The GetPreferredSize method is called when the corresponding OnGetPreferredSize method in the // XWT widget is not overriden, or if it is overriden and the new implementation calls // base.OnGetPreferredSize. For this reason, we have to ensure that the widget's MeasureOverride // method doesn't end calling the frontend OnGetPreferredSize method. To avoid it we set // the calculatingPreferredSize flag to true, and we check this flag in MeasureOverride public virtual Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { SW.Size size; Widget.InvalidateMeasure (); GetWidgetDesiredSize (widthConstraint.IsConstrained ? widthConstraint.AvailableSize : Double.PositiveInfinity, heightConstraint.IsConstrained ? heightConstraint.AvailableSize : Double.PositiveInfinity, out size); return new Size (size.Width, size.Height); }
public override Size GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { if (panel1.HasWidget && panel2.HasWidget) { double w, h; if (direction == Orientation.Horizontal) { var s1 = panel1.WidgetSurface.GetPreferredSize (SizeConstraint.Unconstrained, heightConstraint); var s2 = panel2.WidgetSurface.GetPreferredSize (SizeConstraint.Unconstrained, heightConstraint); w = s1.Width + s2.Width + SplitterSize; h = Math.Max (s1.Height, s2.Height); } else { var s1 = panel1.WidgetSurface.GetPreferredSize (widthConstraint, SizeConstraint.Unconstrained); var s2 = panel2.WidgetSurface.GetPreferredSize (widthConstraint, SizeConstraint.Unconstrained); h = s1.Height + s2.Height + SplitterSize; w = Math.Max (s1.Width, s2.Width); } if (direction == Orientation.Horizontal && widthConstraint.IsConstrained && w > widthConstraint.AvailableSize) w = widthConstraint.AvailableSize; if (direction == Orientation.Vertical && heightConstraint.IsConstrained && h > heightConstraint.AvailableSize) h = heightConstraint.AvailableSize; return new Size (w, h); } else if (panel1.HasWidget) return panel1.WidgetSurface.GetPreferredSize (widthConstraint, heightConstraint); else if (panel2.HasWidget) return panel2.WidgetSurface.GetPreferredSize (widthConstraint, heightConstraint); else return Size.Zero; }
public void GetConstraints (Gtk.Widget target, out SizeConstraint width, out SizeConstraint height) { width = RequestedSize.Width; height = RequestedSize.Height; }
public void GetConstraints (Gtk.Widget target, out SizeConstraint width, out SizeConstraint height) { backend.GetConstraints (this, out width, out height); }
public override Size GetPreferredSize(SizeConstraint widthConstraint, SizeConstraint heightConstraint) { Size baseSize = base.GetPreferredSize(widthConstraint, heightConstraint); Size outputSize = new Size(longestItemWidth > 0 ? longestItemWidth + COMBO_BOX_STARTING_WIDTH : baseSize.Width, baseSize.Height); return outputSize; }
Size IWidgetBackend.GetPreferredSize (SizeConstraint widthConstraint, SizeConstraint heightConstraint) { return Surface.GetPreferredSize (widthConstraint, heightConstraint); }