/// <summary> Measure the text using the default font of indicated graphics context. </summary> /// <param name="display"> The display pointer, that specifies the connection to the X server. <see cref="IntPtr"/> </param> /// <param name="gc"> The crapchics context to use for measuring. <see cref="IntPtr"/> </param> /// <param name="text"> The text to measure. <see cref="X11.TChar[]"/> </param> /// <returns> The measured size of the indicated text. <see cref="TSize"/> </returns> public virtual TSize MeasureTextLine(IntPtr display, IntPtr gc, X11.TChar[] text) { TSize result = new TSize(5, 5); if (display == IntPtr.Zero) { Console.WriteLine(CLASS_NAME + "::MeasureTextLine () ERROR: Argument null: display"); return(result); } if (gc == IntPtr.Zero) { Console.WriteLine(CLASS_NAME + "::MeasureTextLine () ERROR: Argument null: gc"); return(result); } TInt gcID = X11lib.XGContextFromGC(gc); if (gcID != 0) { TInt direction = 0; TInt fontAscent = 0; TInt fontDescent = 0; X11lib.XCharStruct xCharStruct = new X11lib.XCharStruct(); X11lib.XQueryTextExtents(display, gcID, text, (X11.TInt)text.Length, ref direction, ref fontAscent, ref fontDescent, ref xCharStruct); result.Width = (int)xCharStruct.width; result.Height = (int)fontAscent + (int)fontDescent; } else { Console.WriteLine(CLASS_NAME + "::MeasureTextLine () ERROR: Cannot investigate default font ressource ID of underlaying graphics context."); } return(result); }
/// <summary> Calculate the preferred size acting like a HBox. </summary> /// <returns> The preferred size. <see cref="TIntSize"/> </returns> private TSize PreferredSizeHBox() { TSize preferredSize = new TSize(0, 0); for (int counter = 0; counter < _children.Count; counter++) { TSize childPreferredSize = _children[counter].PreferredSize(); if ((int)childPreferredSize.Width > 0) { preferredSize.Width = preferredSize.Width + childPreferredSize.Width; } if ((int)childPreferredSize.Height > 0) { preferredSize.Height = Math.Max(preferredSize.Height, childPreferredSize.Height); } if (counter > 0) { preferredSize.Width = preferredSize.Width + _horzSpacing; } } preferredSize.Width = preferredSize.Width + _borderWidth * 2 + _frameWidth * 2; preferredSize.Height = preferredSize.Height + _borderWidth * 2 + _frameWidth * 2; return(preferredSize); }
public async Task <IActionResult> Edit(int id, [Bind("SizeId,TypeSize")] TSize tSize) { if (id != tSize.SizeId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(tSize); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TSizeExists(tSize.SizeId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(tSize)); }
protected override T GetFirst() { Interval <T, TSize> interval = _interval; // When anchor is set, start the interval at the next anchor position. if (_isAnchorSet) { TSize anchorDiff = Operator <T, TSize> .Subtract(_interval.Start, _anchor); double stepSize = ConvertSizeToDouble(_step); double diff = Math.Abs(ConvertSizeToDouble(anchorDiff)) % stepSize; if (diff > 0) { if (_anchor.CompareTo(_interval.Start) < 0) { diff = stepSize - diff; } TSize addition = ConvertDoubleToSize(diff); interval = new Interval <T, TSize>( Operator <T, TSize> .AddSize(_interval.Start, addition), true, _interval.End, _interval.IsEndIncluded); } } // When first value doesn't lie in interval, immediately step. return(interval.IsStartIncluded ? interval.Start : Operator <T, TSize> .AddSize(interval.Start, _step)); }
/// <summary> updates the current bracket then moves to the next lower one /// </summary> /// <param name="t"> Current bracket size</param> private void scanArray2(TSize t) { /* //String a = GetControlSummary( Parent, 0 ); * TourneyMatchUp[] temp = null; * switch (t) { * case TSize.St: * temp = getArray( TSize.St ); * updateArray( temp, getArray( TSize.Q ), 4 ); * //orderAndSet( temp, 4 ); * scanArray( TSize.Q ); * break; * case TSize.Q: * temp = getArray( TSize.Q ); * updateArray( temp, getArray( TSize.S ), 3 ); * //orderAndSet( temp, 3 ); * scanArray( TSize.S ); * break; * case TSize.S: * temp = getArray( TSize.S ); * updateArray( temp, getArray( TSize.F ), 2 ); * //orderAndSet( temp, 2 ); * scanArray( TSize.F ); * break; * case TSize.F: * temp = getArray( TSize.F ); * updateArray( temp, TourneyWinner ); * //orderAndSet( temp, 1 ); * break; * }*/ //Parent.Invalidate(); }
/// <summary> Calcualate layout after a position or size change. </summary> /// <param name="assignedPosition"> The position of the top left top corner assigned by the window manager (for shell widgets) or geometry management (by non-shell widgets). <see cref="TPoint"/> </param> /// <param name="availableSize"> The available size. <see cref="TIntSize"/> </param> /// <remarks> This method is defined at XrwRectObj for compatibility, but must be implemented for composite widgets only. </remarks> public override void CalculateChildLayout(TPoint assignedPosition, TSize availableSize) { int borderAndFrame = _borderWidth + _frameWidth; TPoint childPosition = new TPoint(assignedPosition.X + borderAndFrame, assignedPosition.Y + borderAndFrame); for (int counter = 0; counter < _children.Count; counter++) { TSize preferredSize = _children[counter].PreferredSize(); if (_children[counter].ExpandToAvailableWidth == true) { if (preferredSize.Width < availableSize.Width - borderAndFrame - borderAndFrame) { preferredSize.Width = availableSize.Width - borderAndFrame - borderAndFrame; } } if (_children[counter].ExpandToAvailableHeight == true) { if (preferredSize.Height < availableSize.Height - borderAndFrame - borderAndFrame) { preferredSize.Height = availableSize.Height - borderAndFrame - borderAndFrame; } } GeometryManagerAccess.SetAssignedGeometry(_children[counter], childPosition, preferredSize); } }
// ############################################################################### // ### M E T H O D S // ############################################################################### #region XrwRectObj overrides /// <summary> Calculate the preferred size. </summary> /// <returns> The preferred size. <see cref="TIntSize"/> </returns> public override TSize PreferredSize() { TSize preferredSize = new TSize(_borderWidth * 2, _borderWidth * 2); for (int counter = 0; counter < _children.Count; counter++) { TSize childPreferredSize = _children[counter].PreferredSize(); if ((int)childPreferredSize.Width > 0) { preferredSize.Width = Math.Max(preferredSize.Width, childPreferredSize.Width); } if ((int)childPreferredSize.Height > 0) { preferredSize.Height = preferredSize.Height + childPreferredSize.Height; } if (counter > 0) { preferredSize.Height = preferredSize.Height + _vertSpacing; } } preferredSize.Width = preferredSize.Width + _borderWidth * 2 + _frameWidth * 2; preferredSize.Height = preferredSize.Height + _borderWidth * 2 + _frameWidth * 2; return(preferredSize); }
// ############################################################################### // ### M E T H O D S // ############################################################################### #region XrwRectObj overrides /// <summary> Calculate the preferred size. </summary> /// <returns> The preferred size. <see cref="TSize"/> </returns> public override TSize PreferredSize() { TSize textMeasure = _lines.Measure(new TSize(0, _space * 2)); TSize preferredSize = new TSize(Math.Max(MIN_WIDTH + _borderWidth * 2 + _frameWidth * 2 + _leftMargin + _rightMargin, textMeasure.Width + _borderWidth * 2 + _frameWidth * 2 + _leftMargin + _rightMargin), Math.Max(MIN_HEIGHT + _borderWidth * 2 + _frameWidth * 2, textMeasure.Height + _borderWidth * 2 + _frameWidth * 2)); TSize bitmapMeasure = new TSize(0, 0); if (_offBitmap != null) { bitmapMeasure.Width = _offBitmap.Width + _space; bitmapMeasure.Height = Math.Max(preferredSize.Height, _offBitmap.Height + _space * 2 + _borderWidth * 2 + _frameWidth * 2); } if (_onBitmap != null) { bitmapMeasure.Width = Math.Max(bitmapMeasure.Width, _onBitmap.Width + _space); bitmapMeasure.Height = Math.Max(bitmapMeasure.Height, Math.Max(preferredSize.Height, _onBitmap.Height + _space * 2 + _borderWidth * 2 + _frameWidth * 2)); } preferredSize.Width += bitmapMeasure.Width; preferredSize.Height = Math.Max(preferredSize.Height, bitmapMeasure.Height); if (_fixedSize.Width >= 0 && _fixedSize.Width > MIN_WIDTH) { preferredSize.Width = _fixedSize.Width + _borderWidth * 2 + _frameWidth * 2 + _leftMargin + _rightMargin; } if (_fixedSize.Height >= 0 && _fixedSize.Height > MIN_HEIGHT) { preferredSize.Height = _fixedSize.Height + _borderWidth * 2 + _frameWidth * 2; } return(preferredSize); }
/// <summary> Draw text with current font of indicated graphics context. </summary> /// <param name="display"> The display pointer, that specifies the connection to the X server. <see cref="IntPtr"/> </param> /// <param name="window"> The window to draw on. <see cref="IntPtr"/> </param> /// <param name="gc"> The graphics context to use for drawing. <see cref="IntPtr"/> </param> /// <param name="text"> The tyt to draw. <see cref="X11.TChar[]"/> </param> /// <param name="area"> The area to draw within. <see cref="Rectangle"/> </param> /// <param name="horzAlign"> The horizontal alignment (0.5F is centered). <see cref="XFloat"/> </param> /// <param name="vertAlign"> The vertical alignment (0.5F is centered). <see cref="XFloat"/> </param> public virtual void DrawTextLine(IntPtr display, IntPtr window, IntPtr gc, X11.TChar[] text, X11.TRectangle area, float horzAlign, float vertAlign) { if (display == IntPtr.Zero) { Console.WriteLine(CLASS_NAME + "::DrawTextLine () ERROR: Argument null: display"); return; } if (window == IntPtr.Zero) { Console.WriteLine(CLASS_NAME + "::DrawTextLine () ERROR: Argument null: window"); return; } if (gc == IntPtr.Zero) { Console.WriteLine(CLASS_NAME + "::DrawTextLine () ERROR: Argument null: gc"); return; } if (horzAlign < 0.0F || horzAlign > 1.0F) { Console.WriteLine(CLASS_NAME + "::DrawTextLine () ERROR: Argument out of range (0.0 ... 1.0): horzAlign"); if (horzAlign < 0.0F) { horzAlign = 0.0F; } if (horzAlign > 1.0F) { horzAlign = 1.0F; } } if (vertAlign < 0.0F || vertAlign > 1.0F) { Console.WriteLine(CLASS_NAME + "::DrawTextLine () ERROR: Argument out of range (0.0 ... 1.0): vertAlign"); if (vertAlign < 0.0F) { vertAlign = 0.0F; } if (vertAlign > 1.0F) { vertAlign = 1.0F; } } TSize textMeasure = MeasureTextLine(display, gc, text); int textX = (int)((area.Width - textMeasure.Width) * horzAlign); if (textX < _borderWidth + 2) { textX = _borderWidth + 2; } if (textX > area.Width - textMeasure.Width - _borderWidth - 2) { textX = area.Width - textMeasure.Width - _borderWidth - 2; } int textY = (int)((area.Height - textMeasure.Height) * vertAlign) + (int)(textMeasure.Height * 0.85F); X11lib.XDrawString(display, window, gc, (TInt)((int)area.Left + (int)textX), (TInt)((int)area.Top + (int)textY), text, (X11.TInt)text.Length); }
/// <summary> Initializing constructor. </summary> /// <param name="display">The display pointer, that specifies the connection to the X server. <see cref="System.IntPtr"/> </param> /// <param name="screenNumber"> The appropriate screen number on the host server. <see cref="System.Int32"/> </param> /// <param name="parentWindow"> The X11 *** parent *** window for X11 calls. This widget has no X11 *** own *** window. <see cref="System.IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TIntSize"/> </param> /// <param name="label"> The label to display. <see cref="System.String"/> </param> /// <param name="leftBitmap"> The left bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="leftShared"> Indicate wether the leftBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> /// <param name="rightBitmap"> The right bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="rightShared"> Indicate wether the rightBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> public XrwCommand(IntPtr display, X11.TInt screen, IntPtr parentWindow, ref TSize fixedSize, string label, X11Graphic leftBitmap, bool leftShared, X11Graphic rightBitmap, bool rightShared) : base(display, screen, parentWindow, ref fixedSize, label, leftBitmap, leftShared, rightBitmap, rightShared) { // Create a *** own *** window and exchange the *** parent *** window against it. base.InitializeOwnWindow(); InitializeCommandRessources(); }
/// <summary> Initializing constructor. </summary> /// <param name="display">The display pointer, that specifies the connection to the X server. <see cref="System.IntPtr"/> </param> /// <param name="screenNumber"> The appropriate screen number on the host server. <see cref="System.Int32"/> </param> /// <param name="parentWindow"> The X11 *** parent *** window for X11 calls. This widget has no X11 *** own *** window. <see cref="System.IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TIntSize"/> </param> /// <param name="label"> The label to display. <see cref="System.String"/> </param> public XrwLabel(IntPtr display, X11.TInt screen, IntPtr parentWindow, ref TSize fixedSize, string label) : base(display, screen, parentWindow, ref fixedSize) { _label = label; _lines = new Multiline(this, _label); InitializeLabelRessources(); }
public static void RequestSize(TSize size) { if (size.NotNull()) { size.Width = (size.Columns * MiniSize.Width); size.Height = (size.Rows * MiniSize.Height); } }
/// <summary> Initializing constructor. </summary> /// <param name="display">The display pointer, that specifies the connection to the X server. <see cref="IntPtr"/> </param> /// <param name="screenNumber"> The appropriate screen number on the host server. <see cref="System.Int32"/> </param> /// <param name="parentWindow"> The X11 *** parent *** window that will be the parent for an X11 *** own ** window. <see cref="IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. <see cref="TIntSize"/> </param> /// <param name="label"> The label to display. <see cref="System.String"/> </param> public XrwCommand(IntPtr display, X11.TInt screen, IntPtr parentWindow, ref TSize fixedSize, string label) : base(display, screen, parentWindow, ref fixedSize, label) { // Create a *** own *** window and exchange the *** parent *** window against it. base.InitializeOwnWindow(); InitializeCommandRessources(); }
/// <summary> Initializing constructor. </summary> /// <param name="parent"> The parent (associated top-level) shell (an override shell can't be a top-level shell. <see cref="IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TSize"/> </param> public XrwOverrideShell(XrwApplicationShell parent, ref TSize fixedSize) : base(parent.Display, parent.Screen, parent.Window, ref fixedSize) { _parent = parent; TPoint assignedPosition = new TPoint(0, 0); InitializeOverrideShellResources(ref assignedPosition); }
/// <summary> Calcualate layout after a position or size change. </summary> /// <param name="assignedPosition"> The position of the top left top corner assigned by the window manager (for shell widgets) or geometry management (by non-shell widgets). <see cref="TPoint"/> </param> /// <param name="availableSize"> The available size. <see cref="TIntSize"/> </param> /// <remarks> This method is defined at XrwRectObj for compatibility, but must be implemented for composite widgets only. </remarks> public override void CalculateChildLayout(TPoint assignedPosition, TSize availableSize) { if (_orientation == TOrientation.Horizontal) { CalculateChildLayoutHBox(assignedPosition, availableSize); } else { CalculateChildLayoutVBox(assignedPosition, availableSize); } }
public async Task <IActionResult> Create([Bind("SizeId,TypeSize")] TSize tSize) { if (ModelState.IsValid) { _context.Add(tSize); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(tSize)); }
public static TSize LinearSpeed <TInput>(TInput begin, TInput end) where TInput : struct, IInputIterator <T, TSize, TInput> { TSize count = Size.Zero; for (TInput i = begin; !i.Equals(end); i.Increment()) { Size.Increment(ref count); } return(count); }
/// <summary> Get the measured text size in pixel. </summary> /// <param name="summand"> The size to add. <see cref="TSize"/> </param> /// <returns> The measured text size in pixel. <see cref="TSize"/> </returns> public TSize Measure(TSize summand) { TSize textMeasure = new TSize(0, 0); for (int cntLines = 0; cntLines < this.Count; cntLines++) { textMeasure.Width = Math.Max(textMeasure.Width, this[cntLines].WidthInPixel); textMeasure.Height += this[cntLines].HeightInPixel; } textMeasure.Add(summand); return(textMeasure); }
/// <summary> Initializing constructor. </summary> /// <param name="display">The display pointer, that specifies the connection to the X server. <see cref="System.IntPtr"/> </param> /// <param name="screenNumber"> The appropriate screen number on the host server. <see cref="System.Int32"/> </param> /// <param name="parentWindow"> The X11 *** parent *** window for X11 calls. This widget has no X11 *** own *** window. <see cref="System.IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TIntSize"/> </param> /// <param name="label"> The label to display. <see cref="System.String"/> </param> /// <param name="leftBitmap"> The left bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="leftShared"> Indicate wether the leftBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> /// <param name="rightBitmap"> The right bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="rightShared"> Indicate wether the rightBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> public XrwLabel(IntPtr display, X11.TInt screen, IntPtr parentWindow, ref TSize fixedSize, string label, X11Graphic leftBitmap, bool leftShared, X11Graphic rightBitmap, bool rightShared) : base(display, screen, parentWindow, ref fixedSize) { _label = label; _lines = new Multiline(this, _label); _leftBitmap = leftBitmap; _leftBitmapShared = leftShared; _rightBitmap = rightBitmap; _rightBitmapShared = rightShared; InitializeLabelRessources(); }
public Enumerator( IInterval <T, TSize> interval, TSize step, Func <T, T, TSize> subtract, Func <T, TSize, T> addSize, Func <TSize, double> convertSizeToDouble, Func <double, TSize> convertDoubeToSize, Func <T, bool, T, bool, IInterval <T, TSize> > createInstance, T anchorAt) : this(interval, step, subtract, addSize, convertSizeToDouble, convertDoubeToSize, createInstance) { _isAnchorSet = true; _anchor = anchorAt; }
// ToDo: Clip protected void DrawTextLines(Multiline lines, TRectangle clientArea, float horzTextAlign, float vertTextAlign) { int FUZZY = 4; // Avoid line hiding on rounding errors. int drawableLines = lines.CompleteDrawableLines(clientArea.Height + FUZZY); TSize textMeasure = lines.Measure(0, drawableLines - 1); int extraHeight = (int)((clientArea.Height - textMeasure.Height) * vertTextAlign); TRectangle lineArea = new TRectangle(clientArea.X, clientArea.Y + extraHeight, clientArea.Width, 0); for (int cntLines = 0; cntLines < drawableLines; cntLines++) { DrawTextLine(_display, _window, _gc, lines[cntLines].Text, lineArea, horzTextAlign, 0.0F); lineArea.Y += lines[cntLines].HeightInPixel; } }
/// <summary> Initializing constructor. </summary> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TSize"/> </param> public XrwRectObj(ref TSize fixedSize) { if (fixedSize.Width < MIN_WIDTH) { Console.WriteLine(CLASS_NAME + "::Ctr () WARNING: The width must be greater or equal MIN_WIDTH."); fixedSize.Width = MIN_WIDTH; } if (fixedSize.Height < MIN_HEIGHT) { Console.WriteLine(CLASS_NAME + "::Ctr () WARNING: The height must be greater or equal MIN_HEIGHT."); fixedSize.Height = MIN_HEIGHT; } _fixedSize = fixedSize; }
public void CopyTo(T[] array, TSize arrayIndex) { if (typeof(TSize) == typeof(int)) { Array.Copy(_items, 0, array, Size.ToInt32(arrayIndex), _count); } else { long targetIndex = Size.ToInt64(arrayIndex); for (int i = 0; i < _count; i++, targetIndex++) { array[targetIndex] = _items[i]; } } }
/// <summary> Initializing constructor. </summary> /// <param name="display">The display pointer, that specifies the connection to the X server. <see cref="System.IntPtr"/> </param> /// <param name="screenNumber"> The appropriate screen number on the host server. <see cref="System.Int32"/> </param> /// <param name="parentWindow"> The X11 *** parent *** window for X11 calls. This widget has no X11 *** own *** window. <see cref="System.IntPtr"/> </param> /// <param name="fixedSize"> The fixed size, that ist to use (if set) rather than the calcualated size. Passed as reference to avoid structure copy constructor calls. <see cref="TIntSize"/> </param> /// <param name="label"> The label to display. <see cref="System.String"/> </param> /// <param name="offBitmap"> The right bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="offShared"> Indicate wether the offBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> /// <param name="onBitmap"> The left bitmap to display. <see cref="XrwBitmap"/> </param> /// <param name="onShared"> Indicate wether the onBitmap is shared (desposed by caller) or private (disposed together with tis label). <see cref="System.Boolean"/> </param> public XrwToggle(IntPtr display, X11.TInt screen, IntPtr parentWindow, ref TSize fixedSize, string label, X11Graphic offBitmap, bool offShared, X11Graphic onBitmap, bool onShared) : base(display, screen, parentWindow, ref fixedSize) { _label = label; _lines = new Multiline(this, _label); _offBitmap = offBitmap; _offBitmapShared = offShared; _onBitmap = onBitmap; _onBitmapShared = onShared; // Create a *** own *** window and exchange the *** parent *** window against it. base.InitializeOwnWindow(); InitializeToggleRessources(); }
/// <summary> Get the measured text size in pixel. </summary> /// <param name="startLineIndex"> The zero based index of the first line to measure. <see cref="System.Int32"/> </param> /// <param name="endLineIndex"> The zero based index of the last line to measure. <see cref="System.Int32"/> </param> /// <returns> The measured text size in pixel. <see cref="TSize"/> </returns> public TSize Measure(int startLineIndex, int endLineIndex) { TSize textMeasure = new TSize(0, 0); if (startLineIndex >= this.Count || endLineIndex < startLineIndex) { return(textMeasure); } for (int cntLines = startLineIndex; cntLines <= endLineIndex; cntLines++) { textMeasure.Width = Math.Max(textMeasure.Width, this[cntLines].WidthInPixel); textMeasure.Height += this[cntLines].HeightInPixel; } return(textMeasure); }
/// <summary> Calculate the preferred size. </summary> /// <returns> The preferred size. <see cref="TSize"/> </returns> public virtual TSize PreferredSize() { TSize preferredSize = new TSize(MIN_WIDTH + _borderWidth * 2, MIN_HEIGHT + _borderWidth * 2); if (_fixedSize.Width >= 0 && _fixedSize.Width > MIN_WIDTH) { preferredSize.Width = _fixedSize.Width + _borderWidth * 2; } if (_fixedSize.Height >= 0 && _fixedSize.Height > MIN_HEIGHT) { preferredSize.Height = _fixedSize.Height + _borderWidth * 2; } return(preferredSize); }
/// <summary> /// Create a new enumerator which traverses across an interval in specified steps. /// </summary> /// <param name = "interval">The interval which to traverse.</param> /// <param name = "step">The steps to step forward each time.</param> public Enumerator( IInterval <T, TSize> interval, TSize step, Func <T, T, TSize> subtract, Func <T, TSize, T> addSize, Func <TSize, double> convertSizeToDouble, Func <double, TSize> convertDoubeToSize, Func <T, bool, T, bool, IInterval <T, TSize> > createInstance) { _interval = interval; _step = step; _subtract = subtract; _addSize = addSize; _convertSizeToDouble = convertSizeToDouble; _convertDoubleToSize = convertDoubeToSize; _createInstance = createInstance; }
/// <summary> Set the assigned position and size, calculated by the geometry management. </summary> /// <param name="rectObj"> The rectangle object to set the assigned position and size for. <see cref="XrwRectObj"/> </param> /// <param name="position"> The assigned position to set. <see cref="TPoint"/> </param> /// <param name="size"> The assigned position to set. <see cref="TSize"/> </param> public static void SetAssignedGeometry(XrwRectObj rectObj, TPoint position, TSize size) { if (rectObj == null) { Console.WriteLine("GeometryManagerAccess::SetAssignedGeometry () ERROR: Argument null: rectObj"); return; } // Fixed size always has priority! if (rectObj.IsFixedWidth == true) { size.Width = rectObj.FixedSize.Width; } if (rectObj.IsFixedWidth == true) { size.Height = rectObj.FixedSize.Height; } rectObj._assignedSize = size; if (rectObj.HasOwnWindow && (rectObj is XrwVisibleRectObj)) { // Transfer the geometry to the underlaying window. XrwVisibleRectObj visibleRect = rectObj as XrwVisibleRectObj; if (visibleRect.Display != IntPtr.Zero && visibleRect.Window != IntPtr.Zero) { // This call causes a ConfigureNotify event. X11lib.XMoveResizeWindow(visibleRect.Display, visibleRect.Window, (TInt)position.X, (TInt)position.Y, (TUint)size.Width, (TUint)size.Height); visibleRect._assignedPosition = new TPoint(0, 0); } else { throw new AccessViolationException("XrwVisibleRectObj or inherited widget without display or window."); } } else { rectObj._assignedPosition = position; } // Child should be prevented from overwriting parent's border. size.Width -= 2 * rectObj.BorderWidth; size.Height -= 2 * rectObj.BorderWidth; rectObj.CalculateChildLayout(position, size); }
// ############################################################################### // ### M E T H O D S // ############################################################################### #region XrwRectObj overrides /// <summary> Calculate the preferred size. </summary> /// <returns> The preferred size. <see cref="TIntSize"/> </returns> public override TSize PreferredSize() { TSize preferredSize = new TSize(0, 0); for (int counter = 0; counter < _children.Count; counter++) { TSize childPreferredSize = _children[counter].PreferredSize(); if ((int)childPreferredSize.Width > preferredSize.Width) { preferredSize.Width = childPreferredSize.Width; } if ((int)childPreferredSize.Height > preferredSize.Height) { preferredSize.Height = childPreferredSize.Height; } } preferredSize.Width = preferredSize.Width + _borderWidth * 2 + _frameWidth * 2; preferredSize.Height = preferredSize.Height + _borderWidth * 2 + _frameWidth * 2; return(preferredSize); }
/// <summary> Calcualate layout after a position or size change. </summary> /// <remarks> This method is defined at XrwRectObj for compatibility, but must be implemented for composite widgets only. </remarks> public void CalculateChildLayout() { TPoint childPosition = new TPoint(_borderWidth, _borderWidth); TSize requestedSize = new TSize(0, 0); List <ChildData> childData = new List <ChildData>(); for (int counter = 0; counter < _children.Count; counter++) { TSize preferredSize = _children[counter].PreferredSize(); childData.Add(new ChildData(_children[counter], preferredSize)); if (requestedSize.Width < preferredSize.Width) { requestedSize.Width = preferredSize.Width; } requestedSize.Height += preferredSize.Height; if (counter > 0) { requestedSize.Height += _vertSpacing; } } requestedSize.Width = Math.Max(MIN_WIDTH, requestedSize.Width); requestedSize.Height = Math.Max(MIN_HEIGHT, requestedSize.Height); for (int counter = 0; counter < childData.Count; counter++) { ChildData cd = childData[counter]; cd.Widget._assignedPosition.X = childPosition.X; cd.Widget._assignedPosition.Y = childPosition.Y; cd.Widget._assignedSize.Width = requestedSize.Width; cd.Widget._assignedSize.Height = cd.Size.Height; childPosition.Y = childPosition.Y + cd.Size.Height + _vertSpacing; } this._assignedSize.Width = requestedSize.Width + 2 * _borderWidth; this._assignedSize.Height = requestedSize.Height + 2 * _borderWidth; }