// Token: 0x06005494 RID: 21652 RVA: 0x00176A14 File Offset: 0x00174C14 private void UpdateAnimation() { if (this._glow != null) { if (base.IsVisible && this._glow.Width > 0.0 && this._indicator.Width > 0.0) { double num = this._indicator.Width + this._glow.Width; double num2 = -1.0 * this._glow.Width; TimeSpan timeSpan = TimeSpan.FromSeconds((double)((int)(num - num2)) / 200.0); TimeSpan t = TimeSpan.FromSeconds(1.0); TimeSpan value; if (DoubleUtil.GreaterThan(this._glow.Margin.Left, num2) && DoubleUtil.LessThan(this._glow.Margin.Left, num - 1.0)) { value = TimeSpan.FromSeconds(-1.0 * (this._glow.Margin.Left - num2) / 200.0); } else { value = TimeSpan.Zero; } ThicknessAnimationUsingKeyFrames thicknessAnimationUsingKeyFrames = new ThicknessAnimationUsingKeyFrames(); thicknessAnimationUsingKeyFrames.BeginTime = new TimeSpan?(value); thicknessAnimationUsingKeyFrames.Duration = new Duration(timeSpan + t); thicknessAnimationUsingKeyFrames.RepeatBehavior = RepeatBehavior.Forever; thicknessAnimationUsingKeyFrames.KeyFrames.Add(new LinearThicknessKeyFrame(new Thickness(num2, 0.0, 0.0, 0.0), TimeSpan.FromSeconds(0.0))); thicknessAnimationUsingKeyFrames.KeyFrames.Add(new LinearThicknessKeyFrame(new Thickness(num, 0.0, 0.0, 0.0), timeSpan)); this._glow.BeginAnimation(FrameworkElement.MarginProperty, thicknessAnimationUsingKeyFrames); return; } this._glow.BeginAnimation(FrameworkElement.MarginProperty, null); } }
/// <summary> /// <see cref="FrameworkElement.MeasureOverride"/> /// </summary> protected override Size MeasureOverride(Size constraint) { UVSize curLineSize = new UVSize(Orientation); UVSize panelSize = new UVSize(Orientation); UVSize uvConstraint = new UVSize(Orientation, constraint.Width, constraint.Height); double itemWidth = ItemWidth; double itemHeight = ItemHeight; bool itemWidthSet = !double.IsNaN(itemWidth); bool itemHeightSet = !double.IsNaN(itemHeight); Size childConstraint = new Size( (itemWidthSet ? itemWidth : constraint.Width), (itemHeightSet ? itemHeight : constraint.Height)); UIElementCollection children = InternalChildren; for (int i = 0, count = children.Count; i < count; i++) { UIElement child = children[i] as UIElement; if (child == null) { continue; } //Flow passes its own constrint to children child.Measure(childConstraint); //this is the size of the child in UV space UVSize sz = new UVSize( Orientation, (itemWidthSet ? itemWidth : child.DesiredSize.Width), (itemHeightSet ? itemHeight : child.DesiredSize.Height)); if (DoubleUtil.GreaterThan(curLineSize.U + sz.U, uvConstraint.U)) //need to switch to another line { panelSize.U = Math.Max(curLineSize.U, panelSize.U); panelSize.V += curLineSize.V; curLineSize = sz; if (DoubleUtil.GreaterThan(sz.U, uvConstraint.U)) //the element is wider then the constrint - give it a separate line { panelSize.U = Math.Max(sz.U, panelSize.U); panelSize.V += sz.V; curLineSize = new UVSize(Orientation); } } else //continue to accumulate a line { curLineSize.U += sz.U; curLineSize.V = Math.Max(sz.V, curLineSize.V); } } //the last line size, if any should be added panelSize.U = Math.Max(curLineSize.U, panelSize.U); panelSize.V += curLineSize.V; //go from UV space to W/H space return(new Size(panelSize.Width, panelSize.Height)); }
/// <summary> /// <see cref="FrameworkElement.ArrangeOverride"/> /// </summary> protected override Size ArrangeOverride(Size finalSize) { int firstInLine = 0; double itemWidth = ItemWidth; double itemHeight = ItemHeight; double accumulatedV = 0; double itemU = (Orientation == Orientation.Horizontal ? itemWidth : itemHeight); UVSize curLineSize = new UVSize(Orientation); UVSize uvFinalSize = new UVSize(Orientation, finalSize.Width, finalSize.Height); bool itemWidthSet = !double.IsNaN(itemWidth); bool itemHeightSet = !double.IsNaN(itemHeight); bool useItemU = (Orientation == Orientation.Horizontal ? itemWidthSet : itemHeightSet); UIElementCollection children = InternalChildren; for (int i = 0, count = children.Count; i < count; i++) { UIElement child = children[i] as UIElement; if (child == null) { continue; } UVSize sz = new UVSize( Orientation, (itemWidthSet ? itemWidth : child.DesiredSize.Width), (itemHeightSet ? itemHeight : child.DesiredSize.Height)); if (DoubleUtil.GreaterThan(curLineSize.U + sz.U, uvFinalSize.U)) //need to switch to another line { arrangeLine(accumulatedV, curLineSize.V, firstInLine, i, useItemU, itemU); accumulatedV += curLineSize.V; curLineSize = sz; if (DoubleUtil.GreaterThan(sz.U, uvFinalSize.U)) //the element is wider then the constraint - give it a separate line { //switch to next line which only contain one element arrangeLine(accumulatedV, sz.V, i, ++i, useItemU, itemU); accumulatedV += sz.V; curLineSize = new UVSize(Orientation); } firstInLine = i; } else //continue to accumulate a line { curLineSize.U += sz.U; curLineSize.V = Math.Max(sz.V, curLineSize.V); } } //arrange the last line, if any if (firstInLine < children.Count) { arrangeLine(accumulatedV, curLineSize.V, firstInLine, children.Count, useItemU, itemU); } return(finalSize); }
/// <summary>Arranges the content of a <see cref="T:System.Windows.Controls.WrapPanel" /> element.</summary> /// <param name="finalSize">The <see cref="T:System.Windows.Size" /> that this element should use to arrange its child elements.</param> /// <returns>The <see cref="T:System.Windows.Size" /> that represents the arranged size of this <see cref="T:System.Windows.Controls.WrapPanel" /> element and its children.</returns> // Token: 0x06005B53 RID: 23379 RVA: 0x0019BE90 File Offset: 0x0019A090 protected override Size ArrangeOverride(Size finalSize) { int num = 0; double itemWidth = this.ItemWidth; double itemHeight = this.ItemHeight; double num2 = 0.0; double itemU = (this.Orientation == Orientation.Horizontal) ? itemWidth : itemHeight; WrapPanel.UVSize uvsize = new WrapPanel.UVSize(this.Orientation); WrapPanel.UVSize uvsize2 = new WrapPanel.UVSize(this.Orientation, finalSize.Width, finalSize.Height); bool flag = !DoubleUtil.IsNaN(itemWidth); bool flag2 = !DoubleUtil.IsNaN(itemHeight); bool useItemU = (this.Orientation == Orientation.Horizontal) ? flag : flag2; UIElementCollection internalChildren = base.InternalChildren; int i = 0; int count = internalChildren.Count; while (i < count) { UIElement uielement = internalChildren[i]; if (uielement != null) { WrapPanel.UVSize uvsize3 = new WrapPanel.UVSize(this.Orientation, flag ? itemWidth : uielement.DesiredSize.Width, flag2 ? itemHeight : uielement.DesiredSize.Height); if (DoubleUtil.GreaterThan(uvsize.U + uvsize3.U, uvsize2.U)) { this.arrangeLine(num2, uvsize.V, num, i, useItemU, itemU); num2 += uvsize.V; uvsize = uvsize3; if (DoubleUtil.GreaterThan(uvsize3.U, uvsize2.U)) { this.arrangeLine(num2, uvsize3.V, i, ++i, useItemU, itemU); num2 += uvsize3.V; uvsize = new WrapPanel.UVSize(this.Orientation); } num = i; } else { uvsize.U += uvsize3.U; uvsize.V = Math.Max(uvsize3.V, uvsize.V); } } i++; } if (num < internalChildren.Count) { this.arrangeLine(num2, uvsize.V, num, internalChildren.Count, useItemU, itemU); } return(finalSize); }
private void MoveToolBar(ToolBar toolBar, int newBandNumber, double position) { int i; bool fHorizontal = Orientation == Orientation.Horizontal; List <ToolBar> newBand = _bands[newBandNumber].Band; // calculate the new BandIndex where toolBar should insert // calculate Width (layout) of the items before the toolBar if (DoubleUtil.LessThanOrClose(position, 0)) { toolBar.BandIndex = -1; // This will position toolBar at the first place } else { double toolBarOffset = 0d; int newToolBarIndex = -1; for (i = 0; i < newBand.Count; i++) { ToolBar currentToolBar = newBand[i]; if (newToolBarIndex == -1) { toolBarOffset += fHorizontal ? currentToolBar.RenderSize.Width : currentToolBar.RenderSize.Height; // points at the end of currentToolBar if (DoubleUtil.GreaterThan(toolBarOffset, position)) { newToolBarIndex = i + 1; toolBar.BandIndex = newToolBarIndex; // Update the currentToolBar width if (fHorizontal) { currentToolBar.Width = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Width - toolBarOffset + position); } else { currentToolBar.Height = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Height - toolBarOffset + position); } } } else // After we insert the toolBar we need to increase the indexes { currentToolBar.BandIndex = i + 1; } } if (newToolBarIndex == -1) { toolBar.BandIndex = i; } } }
//This creates the repeating animation private void UpdateAnimation() { if (_glow != null) { if (IsVisible && (_glow.Width > 0) && (_indicator.Width > 0)) { //Set up the animation double endPos = _indicator.Width + _glow.Width; double startPos = -1 * _glow.Width; TimeSpan translateTime = TimeSpan.FromSeconds(((int)(endPos - startPos) / 200.0)); // travel at 200px /second TimeSpan pauseTime = TimeSpan.FromSeconds(1.0); // pause 1 second between animations TimeSpan startTime; //Is the animation currenly running (with one pixel fudge factor) if (DoubleUtil.GreaterThan(_glow.Margin.Left, startPos) && (DoubleUtil.LessThan(_glow.Margin.Left, endPos - 1))) { // make it appear that the timer already started. // To do this find out how many pixels the glow has moved and divide by the speed to get time. startTime = TimeSpan.FromSeconds(-1 * (_glow.Margin.Left - startPos) / 200.0); } else { startTime = TimeSpan.Zero; } ThicknessAnimationUsingKeyFrames animation = new ThicknessAnimationUsingKeyFrames(); animation.BeginTime = startTime; animation.Duration = new Duration(translateTime + pauseTime); animation.RepeatBehavior = RepeatBehavior.Forever; //Start with the glow hidden on the left. animation.KeyFrames.Add(new LinearThicknessKeyFrame(new Thickness(startPos, 0, 0, 0), TimeSpan.FromSeconds(0))); //Move to the glow hidden on the right. animation.KeyFrames.Add(new LinearThicknessKeyFrame(new Thickness(endPos, 0, 0, 0), translateTime)); //There is a pause after the glow is off screen _glow.BeginAnimation(FrameworkElement.MarginProperty, animation); } else { _glow.BeginAnimation(FrameworkElement.MarginProperty, null); } } }
/// <summary>Measures the child elements of a <see cref="T:System.Windows.Controls.WrapPanel" /> in anticipation of arranging them during the <see cref="M:System.Windows.Controls.WrapPanel.ArrangeOverride(System.Windows.Size)" /> pass.</summary> /// <param name="constraint">An upper limit <see cref="T:System.Windows.Size" /> that should not be exceeded.</param> /// <returns>The <see cref="T:System.Windows.Size" /> that represents the desired size of the element.</returns> // Token: 0x06005B52 RID: 23378 RVA: 0x0019BC88 File Offset: 0x00199E88 protected override Size MeasureOverride(Size constraint) { WrapPanel.UVSize uvsize = new WrapPanel.UVSize(this.Orientation); WrapPanel.UVSize uvsize2 = new WrapPanel.UVSize(this.Orientation); WrapPanel.UVSize uvsize3 = new WrapPanel.UVSize(this.Orientation, constraint.Width, constraint.Height); double itemWidth = this.ItemWidth; double itemHeight = this.ItemHeight; bool flag = !DoubleUtil.IsNaN(itemWidth); bool flag2 = !DoubleUtil.IsNaN(itemHeight); Size availableSize = new Size(flag ? itemWidth : constraint.Width, flag2 ? itemHeight : constraint.Height); UIElementCollection internalChildren = base.InternalChildren; int i = 0; int count = internalChildren.Count; while (i < count) { UIElement uielement = internalChildren[i]; if (uielement != null) { uielement.Measure(availableSize); WrapPanel.UVSize uvsize4 = new WrapPanel.UVSize(this.Orientation, flag ? itemWidth : uielement.DesiredSize.Width, flag2 ? itemHeight : uielement.DesiredSize.Height); if (DoubleUtil.GreaterThan(uvsize.U + uvsize4.U, uvsize3.U)) { uvsize2.U = Math.Max(uvsize.U, uvsize2.U); uvsize2.V += uvsize.V; uvsize = uvsize4; if (DoubleUtil.GreaterThan(uvsize4.U, uvsize3.U)) { uvsize2.U = Math.Max(uvsize4.U, uvsize2.U); uvsize2.V += uvsize4.V; uvsize = new WrapPanel.UVSize(this.Orientation); } } else { uvsize.U += uvsize4.U; uvsize.V = Math.Max(uvsize4.V, uvsize.V); } } i++; } uvsize2.U = Math.Max(uvsize.U, uvsize2.U); uvsize2.V += uvsize.V; return(new Size(uvsize2.Width, uvsize2.Height)); }
// Token: 0x0600545C RID: 21596 RVA: 0x00175A78 File Offset: 0x00173C78 internal static double ComputeScrollOffsetWithMinimalScroll(double topView, double bottomView, double topChild, double bottomChild, ref bool alignTop, ref bool alignBottom) { bool flag = DoubleUtil.LessThan(topChild, topView) && DoubleUtil.LessThan(bottomChild, bottomView); bool flag2 = DoubleUtil.GreaterThan(bottomChild, bottomView) && DoubleUtil.GreaterThan(topChild, topView); bool flag3 = bottomChild - topChild > bottomView - topView; if (((flag && !flag3) || (flag2 && flag3)) | alignTop) { alignTop = true; return(topChild); } if ((flag || flag2) | alignBottom) { alignBottom = true; return(bottomChild - (bottomView - topView)); } return(topView); }
// Token: 0x06005860 RID: 22624 RVA: 0x00187CB4 File Offset: 0x00185EB4 private int GetBandFromOffset(double toolBarOffset) { if (DoubleUtil.LessThan(toolBarOffset, 0.0)) { return(-1); } double num = 0.0; for (int i = 0; i < this._bands.Count; i++) { num += this._bands[i].Thickness; if (DoubleUtil.GreaterThan(num, toolBarOffset)) { return(i); } } return(this._bands.Count); }
// Token: 0x0600585F RID: 22623 RVA: 0x00187B94 File Offset: 0x00185D94 private void MoveToolBar(ToolBar toolBar, int newBandNumber, double position) { bool flag = this.Orientation == Orientation.Horizontal; List <ToolBar> band = this._bands[newBandNumber].Band; if (DoubleUtil.LessThanOrClose(position, 0.0)) { toolBar.BandIndex = -1; return; } double num = 0.0; int num2 = -1; int i; for (i = 0; i < band.Count; i++) { ToolBar toolBar2 = band[i]; if (num2 == -1) { num += (flag ? toolBar2.RenderSize.Width : toolBar2.RenderSize.Height); if (DoubleUtil.GreaterThan(num, position)) { num2 = i + 1; toolBar.BandIndex = num2; if (flag) { toolBar2.Width = Math.Max(toolBar2.MinLength, toolBar2.RenderSize.Width - num + position); } else { toolBar2.Height = Math.Max(toolBar2.MinLength, toolBar2.RenderSize.Height - num + position); } } } else { toolBar2.BandIndex = i + 1; } } if (num2 == -1) { toolBar.BandIndex = i; } }
internal static double ComputeScrollOffsetWithMinimalScroll( double topView, double bottomView, double topChild, double bottomChild, ref bool alignTop, ref bool alignBottom) { // # CHILD POSITION CHILD SIZE SCROLL REMEDY // 1 Above viewport <= viewport Down Align top edge of child & viewport // 2 Above viewport > viewport Down Align bottom edge of child & viewport // 3 Below viewport <= viewport Up Align bottom edge of child & viewport // 4 Below viewport > viewport Up Align top edge of child & viewport // 5 Entirely within viewport NA No scroll. // 6 Spanning viewport NA No scroll. // // Note: "Above viewport" = childTop above viewportTop, childBottom above viewportBottom // "Below viewport" = childTop below viewportTop, childBottom below viewportBottom // These child thus may overlap with the viewport, but will scroll the same direction/ bool fAbove = DoubleUtil.LessThan(topChild, topView) && DoubleUtil.LessThan(bottomChild, bottomView); bool fBelow = DoubleUtil.GreaterThan(bottomChild, bottomView) && DoubleUtil.GreaterThan(topChild, topView); bool fLarger = (bottomChild - topChild) > (bottomView - topView); // Handle Cases: 1 & 4 above if ((fAbove && !fLarger) || (fBelow && fLarger) || alignTop) { alignTop = true; return(topChild); } // Handle Cases: 2 & 3 above else if (fAbove || fBelow || alignBottom) { alignBottom = true; return(bottomChild - (bottomView - topView)); } // Handle cases: 5 & 6 above. return(topView); }
private int GetBandFromOffset(double toolBarOffset) { if (DoubleUtil.LessThan(toolBarOffset, 0)) { return(-1); } double bandOffset = 0d; for (int i = 0; i < _bands.Count; i++) { bandOffset += _bands[i].Thickness; if (DoubleUtil.GreaterThan(bandOffset, toolBarOffset)) { return(i); } } return(_bands.Count); }
private void ProcessThumbDragDelta(DragDeltaEventArgs e) { // Process thumb event only if Thumb styled parent is a ToolBar under the TollBarTray Thumb thumb = e.OriginalSource as Thumb; if (thumb != null) { ToolBar toolBar = thumb.TemplatedParent as ToolBar; if (toolBar != null && toolBar.Parent == this) { // _bandsDirty would be true at this time only when a Measure gets // skipped between two mouse moves. Ideally that should not happen // but VS has proved that it can. Hence making the code more robust. // Uncomment the line below if the measure skip issue ever gets fixed. // Debug.Assert(!_bandsDirty, "Bands should not be dirty at this point"); if (_bandsDirty) { GenerateBands(); } bool fHorizontal = (Orientation == Orientation.Horizontal); int currentBand = toolBar.Band; Point pointRelativeToToolBarTray = Mouse.PrimaryDevice.GetPosition((IInputElement)this); Point pointRelativeToToolBar = TransformPointToToolBar(toolBar, pointRelativeToToolBarTray); int hittestBand = GetBandFromOffset(fHorizontal ? pointRelativeToToolBarTray.Y : pointRelativeToToolBarTray.X); double newPosition; double thumbChange = fHorizontal ? e.HorizontalChange : e.VerticalChange; double toolBarPosition; if (fHorizontal) { toolBarPosition = pointRelativeToToolBarTray.X - pointRelativeToToolBar.X; } else { toolBarPosition = pointRelativeToToolBarTray.Y - pointRelativeToToolBar.Y; } newPosition = toolBarPosition + thumbChange; // New toolBar position // Move within the band if (hittestBand == currentBand) { List <ToolBar> band = _bands[currentBand].Band; int toolBarIndex = toolBar.BandIndex; // Move ToolBar within the band if (DoubleUtil.LessThan(thumbChange, 0)) // Move left/up { double toolBarsTotalMinimum = ToolBarsTotalMinimum(band, 0, toolBarIndex - 1); // Check if minimized toolbars will fit in the range if (DoubleUtil.LessThanOrClose(toolBarsTotalMinimum, newPosition)) { ShrinkToolBars(band, 0, toolBarIndex - 1, -thumbChange); } else if (toolBarIndex > 0) // Swap toolbars { ToolBar prevToolBar = band[toolBarIndex - 1]; Point pointRelativeToPreviousToolBar = TransformPointToToolBar(prevToolBar, pointRelativeToToolBarTray); // if pointer in on the left side of previous toolbar if (DoubleUtil.LessThan((fHorizontal ? pointRelativeToPreviousToolBar.X : pointRelativeToPreviousToolBar.Y), 0)) { prevToolBar.BandIndex = toolBarIndex; band[toolBarIndex] = prevToolBar; toolBar.BandIndex = toolBarIndex - 1; band[toolBarIndex - 1] = toolBar; if (toolBarIndex + 1 == band.Count) // If toolBar was the last item in the band { prevToolBar.ClearValue(fHorizontal ? WidthProperty : HeightProperty); } } else { // Move to the left/up and shring the other toolbars if (fHorizontal) { if (DoubleUtil.LessThan(toolBarsTotalMinimum, pointRelativeToToolBarTray.X - pointRelativeToToolBar.X)) { ShrinkToolBars(band, 0, toolBarIndex - 1, pointRelativeToToolBarTray.X - pointRelativeToToolBar.X - toolBarsTotalMinimum); } } else { if (DoubleUtil.LessThan(toolBarsTotalMinimum, pointRelativeToToolBarTray.Y - pointRelativeToToolBar.Y)) { ShrinkToolBars(band, 0, toolBarIndex - 1, pointRelativeToToolBarTray.Y - pointRelativeToToolBar.Y - toolBarsTotalMinimum); } } } } } else // Move right/down { double toolBarsTotalMaximum = ToolBarsTotalMaximum(band, 0, toolBarIndex - 1); if (DoubleUtil.GreaterThan(toolBarsTotalMaximum, newPosition)) { ExpandToolBars(band, 0, toolBarIndex - 1, thumbChange); } else { if (toolBarIndex < band.Count - 1) // Swap toolbars { ToolBar nextToolBar = band[toolBarIndex + 1]; Point pointRelativeToNextToolBar = TransformPointToToolBar(nextToolBar, pointRelativeToToolBarTray); // if pointer in on the right side of next toolbar if (DoubleUtil.GreaterThanOrClose((fHorizontal ? pointRelativeToNextToolBar.X : pointRelativeToNextToolBar.Y), 0)) { nextToolBar.BandIndex = toolBarIndex; band[toolBarIndex] = nextToolBar; toolBar.BandIndex = toolBarIndex + 1; band[toolBarIndex + 1] = toolBar; if (toolBarIndex + 2 == band.Count) // If toolBar becomes the last item in the band { toolBar.ClearValue(fHorizontal ? WidthProperty : HeightProperty); } } else { ExpandToolBars(band, 0, toolBarIndex - 1, thumbChange); } } else { ExpandToolBars(band, 0, toolBarIndex - 1, thumbChange); } } } } else // Move ToolBar to another band { _bandsDirty = true; toolBar.Band = hittestBand; toolBar.ClearValue(fHorizontal ? WidthProperty : HeightProperty); // move to another existing band if (hittestBand >= 0 && hittestBand < _bands.Count) { MoveToolBar(toolBar, hittestBand, newPosition); } List <ToolBar> oldBand = _bands[currentBand].Band; // currentBand should restore sizes to Auto for (int i = 0; i < oldBand.Count; i++) { ToolBar currentToolBar = oldBand[i]; currentToolBar.ClearValue(fHorizontal ? WidthProperty : HeightProperty); } } e.Handled = true; } } }
// Token: 0x060058E9 RID: 22761 RVA: 0x00189730 File Offset: 0x00187930 private bool HandleScrollKeys(Key key) { ScrollViewer scrollHost = base.ScrollHost; if (scrollHost != null) { bool flag = base.FlowDirection == FlowDirection.RightToLeft; switch (key) { case Key.Prior: if (DoubleUtil.GreaterThan(scrollHost.ExtentHeight, scrollHost.ViewportHeight)) { scrollHost.PageUp(); } else { scrollHost.PageLeft(); } return(true); case Key.Next: if (DoubleUtil.GreaterThan(scrollHost.ExtentHeight, scrollHost.ViewportHeight)) { scrollHost.PageDown(); } else { scrollHost.PageRight(); } return(true); case Key.End: scrollHost.ScrollToBottom(); return(true); case Key.Home: scrollHost.ScrollToTop(); return(true); case Key.Left: if (flag) { scrollHost.LineRight(); } else { scrollHost.LineLeft(); } return(true); case Key.Up: scrollHost.LineUp(); return(true); case Key.Right: if (flag) { scrollHost.LineLeft(); } else { scrollHost.LineRight(); } return(true); case Key.Down: scrollHost.LineDown(); return(true); } } return(false); }
/// <summary>Draws the contents of a <see cref="T:System.Windows.Media.DrawingContext" /> object during the render pass of a <see cref="T:System.Windows.Controls.Border" />. </summary> /// <param name="dc">The <see cref="T:System.Windows.Media.DrawingContext" /> that defines the object to be drawn.</param> // Token: 0x06004266 RID: 16998 RVA: 0x0012FBE0 File Offset: 0x0012DDE0 protected override void OnRender(DrawingContext dc) { bool useLayoutRounding = base.UseLayoutRounding; DpiScale dpi = base.GetDpi(); if (this._useComplexRenderCodePath) { StreamGeometry borderGeometryCache = this.BorderGeometryCache; Brush brush; if (borderGeometryCache != null && (brush = this.BorderBrush) != null) { dc.DrawGeometry(brush, null, borderGeometryCache); } StreamGeometry backgroundGeometryCache = this.BackgroundGeometryCache; if (backgroundGeometryCache != null && (brush = this.Background) != null) { dc.DrawGeometry(brush, null, backgroundGeometryCache); return; } } else { Thickness borderThickness = this.BorderThickness; CornerRadius cornerRadius = this.CornerRadius; double topLeft = cornerRadius.TopLeft; bool flag = !DoubleUtil.IsZero(topLeft); Brush borderBrush; if (!borderThickness.IsZero && (borderBrush = this.BorderBrush) != null) { Pen pen = this.LeftPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX); } else { pen.Thickness = borderThickness.Left; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.LeftPenCache = pen; } if (borderThickness.IsUniform) { double num = pen.Thickness * 0.5; Rect rectangle = new Rect(new Point(num, num), new Point(base.RenderSize.Width - num, base.RenderSize.Height - num)); if (flag) { dc.DrawRoundedRectangle(null, pen, rectangle, topLeft, topLeft); } else { dc.DrawRectangle(null, pen, rectangle); } } else { if (DoubleUtil.GreaterThan(borderThickness.Left, 0.0)) { double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(num, 0.0), new Point(num, base.RenderSize.Height)); } if (DoubleUtil.GreaterThan(borderThickness.Right, 0.0)) { pen = this.RightPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX); } else { pen.Thickness = borderThickness.Right; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.RightPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(base.RenderSize.Width - num, 0.0), new Point(base.RenderSize.Width - num, base.RenderSize.Height)); } if (DoubleUtil.GreaterThan(borderThickness.Top, 0.0)) { pen = this.TopPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY); } else { pen.Thickness = borderThickness.Top; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.TopPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(0.0, num), new Point(base.RenderSize.Width, num)); } if (DoubleUtil.GreaterThan(borderThickness.Bottom, 0.0)) { pen = this.BottomPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY); } else { pen.Thickness = borderThickness.Bottom; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.BottomPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(0.0, base.RenderSize.Height - num), new Point(base.RenderSize.Width, base.RenderSize.Height - num)); } } } Brush background = this.Background; if (background != null) { Point point; Point point2; if (useLayoutRounding) { point = new Point(UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY)); if (FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { point2 = new Point(UIElement.RoundLayoutValue(base.RenderSize.Width - borderThickness.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(base.RenderSize.Height - borderThickness.Bottom, dpi.DpiScaleY)); } else { point2 = new Point(base.RenderSize.Width - UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX), base.RenderSize.Height - UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY)); } } else { point = new Point(borderThickness.Left, borderThickness.Top); point2 = new Point(base.RenderSize.Width - borderThickness.Right, base.RenderSize.Height - borderThickness.Bottom); } if (point2.X > point.X && point2.Y > point.Y) { if (flag) { Border.Radii radii = new Border.Radii(cornerRadius, borderThickness, false); double topLeft2 = radii.TopLeft; dc.DrawRoundedRectangle(background, null, new Rect(point, point2), topLeft2, topLeft2); return; } dc.DrawRectangle(background, null, new Rect(point, point2)); } } } }
/// <summary> /// In addition to the child, Border renders a background + border. The background is drawn inside the border. /// </summary> protected override void OnRender(DrawingContext dc) { bool useLayoutRounding = this.UseLayoutRounding; DpiScale dpi = GetDpi(); if (_useComplexRenderCodePath) { Brush brush; StreamGeometry borderGeometry = BorderGeometryCache; if (borderGeometry != null && (brush = BorderBrush) != null) { dc.DrawGeometry(brush, null, borderGeometry); } StreamGeometry backgroundGeometry = BackgroundGeometryCache; if (backgroundGeometry != null && (brush = Background) != null) { dc.DrawGeometry(brush, null, backgroundGeometry); } } else { Thickness border = BorderThickness; Brush borderBrush; CornerRadius cornerRadius = CornerRadius; double outerCornerRadius = cornerRadius.TopLeft; // Already validated that all corners have the same radius bool roundedCorners = !DoubleUtil.IsZero(outerCornerRadius); // If we have a brush with which to draw the border, do so. // NB: We double draw corners right now. Corner handling is tricky (bevelling, &c...) and // we need a firm spec before doing "the right thing." (greglett, ffortes) if (!border.IsZero && (borderBrush = BorderBrush) != null) { // Initialize the first pen. Note that each pen is created via new() // and frozen if possible. Doing this avoids the pen // being copied when used in the DrawLine methods. Pen pen = LeftPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Left, dpi.DpiScaleX); } else { pen.Thickness = border.Left; } if (borderBrush.IsFrozen) { pen.Freeze(); } LeftPenCache = pen; } double halfThickness; if (border.IsUniform) { halfThickness = pen.Thickness * 0.5; // Create rect w/ border thickness, and round if applying layout rounding. Rect rect = new Rect(new Point(halfThickness, halfThickness), new Point(RenderSize.Width - halfThickness, RenderSize.Height - halfThickness)); if (roundedCorners) { dc.DrawRoundedRectangle( null, pen, rect, outerCornerRadius, outerCornerRadius); } else { dc.DrawRectangle( null, pen, rect); } } else { // Nonuniform border; stroke each edge. if (DoubleUtil.GreaterThan(border.Left, 0)) { halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(halfThickness, 0), new Point(halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Right, 0)) { pen = RightPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Right, dpi.DpiScaleX); } else { pen.Thickness = border.Right; } if (borderBrush.IsFrozen) { pen.Freeze(); } RightPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(RenderSize.Width - halfThickness, 0), new Point(RenderSize.Width - halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Top, 0)) { pen = TopPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Top, dpi.DpiScaleY); } else { pen.Thickness = border.Top; } if (borderBrush.IsFrozen) { pen.Freeze(); } TopPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, halfThickness), new Point(RenderSize.Width, halfThickness)); } if (DoubleUtil.GreaterThan(border.Bottom, 0)) { pen = BottomPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Bottom, dpi.DpiScaleY); } else { pen.Thickness = border.Bottom; } if (borderBrush.IsFrozen) { pen.Freeze(); } BottomPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, RenderSize.Height - halfThickness), new Point(RenderSize.Width, RenderSize.Height - halfThickness)); } } } // Draw background in rectangle inside border. Brush background = Background; if (background != null) { // Intialize background Point ptTL, ptBR; if (useLayoutRounding) { ptTL = new Point(UIElement.RoundLayoutValue(border.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(border.Top, dpi.DpiScaleY)); if (FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { ptBR = new Point(UIElement.RoundLayoutValue(RenderSize.Width - border.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(RenderSize.Height - border.Bottom, dpi.DpiScaleY)); } else { ptBR = new Point(RenderSize.Width - UIElement.RoundLayoutValue(border.Right, dpi.DpiScaleX), RenderSize.Height - UIElement.RoundLayoutValue(border.Bottom, dpi.DpiScaleY)); } } else { ptTL = new Point(border.Left, border.Top); ptBR = new Point(RenderSize.Width - border.Right, RenderSize.Height - border.Bottom); } // Do not draw background if the borders are so large that they overlap. if (ptBR.X > ptTL.X && ptBR.Y > ptTL.Y) { if (roundedCorners) { Radii innerRadii = new Radii(cornerRadius, border, false); // Determine the inner edge radius double innerCornerRadius = innerRadii.TopLeft; // Already validated that all corners have the same radius dc.DrawRoundedRectangle(background, null, new Rect(ptTL, ptBR), innerCornerRadius, innerCornerRadius); } else { dc.DrawRectangle(background, null, new Rect(ptTL, ptBR)); } } } } }
/// <summary> /// This is the method that responds to the KeyDown event. /// </summary> /// <param name="e">Event Arguments</param> protected override void OnKeyDown(KeyEventArgs e) { bool handled = true; Key key = e.Key; switch (key) { case Key.Divide: case Key.Oem2: // Ctrl-Fowardslash = Select All if (((Keyboard.Modifiers & ModifierKeys.Control) == (ModifierKeys.Control)) && (SelectionMode == SelectionMode.Extended)) { SelectAll(); } else { handled = false; } break; case Key.Oem5: // Ctrl-Backslash = Select the item with focus. if (((Keyboard.Modifiers & ModifierKeys.Control) == (ModifierKeys.Control)) && (SelectionMode == SelectionMode.Extended)) { ListBoxItem focusedItemUI = (FocusedInfo != null) ? FocusedInfo.Container as ListBoxItem : null; if (focusedItemUI != null) { MakeSingleSelection(focusedItemUI); } } else { handled = false; } break; case Key.Up: case Key.Left: case Key.Down: case Key.Right: { KeyboardNavigation.ShowFocusVisual(); // Depend on logical orientation we decide to move focus or just scroll // shouldScroll also detects if we can scroll more in this direction bool shouldScroll = ScrollHost != null; if (shouldScroll) { shouldScroll = ((key == Key.Down && IsLogicalHorizontal && DoubleUtil.GreaterThan(ScrollHost.ScrollableHeight, ScrollHost.VerticalOffset))) || ((key == Key.Up && IsLogicalHorizontal && DoubleUtil.GreaterThan(ScrollHost.VerticalOffset, 0d))) || ((key == Key.Right && IsLogicalVertical && DoubleUtil.GreaterThan(ScrollHost.ScrollableWidth, ScrollHost.HorizontalOffset))) || ((key == Key.Left && IsLogicalVertical && DoubleUtil.GreaterThan(ScrollHost.HorizontalOffset, 0d))); } if (shouldScroll) { ScrollHost.ScrollInDirection(e); } else { if ((ItemsHost != null && ItemsHost.IsKeyboardFocusWithin) || IsKeyboardFocused) { if (!NavigateByLine(KeyboardNavigation.KeyToTraversalDirection(key), new ItemNavigateArgs(e.Device, Keyboard.Modifiers))) { handled = false; } } else { handled = false; } } } break; case Key.Home: NavigateToStart(new ItemNavigateArgs(e.Device, Keyboard.Modifiers)); break; case Key.End: NavigateToEnd(new ItemNavigateArgs(e.Device, Keyboard.Modifiers)); break; case Key.Space: case Key.Enter: { if (e.Key == Key.Enter && (bool)GetValue(KeyboardNavigation.AcceptsReturnProperty) == false) { handled = false; break; } // If the event came from a ListBoxItem that's a child of ours, then look at it. ListBoxItem source = e.OriginalSource as ListBoxItem; // If ALT is down & Ctrl is up, then we shouldn't handle this. (system menu) if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Alt)) == ModifierKeys.Alt) { handled = false; break; } // If the user hits just "space" while text searching, do not handle the event // Note: Space cannot be the first character in a string sent to ITS. if (IsTextSearchEnabled && Keyboard.Modifiers == ModifierKeys.None) { TextSearch instance = TextSearch.EnsureInstance(this); // If TextSearch enabled and Prefix is not empty // then let this SPACE go so ITS can process it. if (instance != null && (instance.GetCurrentPrefix() != String.Empty)) { handled = false; break; } } if (source != null && ItemsControlFromItemContainer(source) == this) { switch (SelectionMode) { case SelectionMode.Single: if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control) { MakeToggleSelection(source); } else { MakeSingleSelection(source); } break; case SelectionMode.Multiple: MakeToggleSelection(source); break; case SelectionMode.Extended: if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.Control) { // Only CONTROL MakeToggleSelection(source); } else if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.Shift) { // Only SHIFT MakeAnchorSelection(source, true /* clearCurrent */); } else if ((Keyboard.Modifiers & ModifierKeys.Shift) == 0) { MakeSingleSelection(source); } else { handled = false; } break; } } else { handled = false; } } break; case Key.PageUp: NavigateByPage(FocusNavigationDirection.Up, new ItemNavigateArgs(e.Device, Keyboard.Modifiers)); break; case Key.PageDown: NavigateByPage(FocusNavigationDirection.Down, new ItemNavigateArgs(e.Device, Keyboard.Modifiers)); break; default: handled = false; break; } if (handled) { e.Handled = true; } else { base.OnKeyDown(e); } }
private bool HandleScrollKeys(Key key) { ScrollViewer scroller = ScrollHost; if (scroller != null) { bool invert = (FlowDirection == FlowDirection.RightToLeft); switch (key) { case Key.Up: scroller.LineUp(); return(true); case Key.Down: scroller.LineDown(); return(true); case Key.Left: if (invert) { scroller.LineRight(); } else { scroller.LineLeft(); } return(true); case Key.Right: if (invert) { scroller.LineLeft(); } else { scroller.LineRight(); } return(true); case Key.Home: scroller.ScrollToTop(); return(true); case Key.End: scroller.ScrollToBottom(); return(true); case Key.PageUp: //if vertically scrollable - go vertical, otherwise horizontal if (DoubleUtil.GreaterThan(scroller.ExtentHeight, scroller.ViewportHeight)) { scroller.PageUp(); } else { scroller.PageLeft(); } return(true); case Key.PageDown: //if vertically scrollable - go vertical, otherwise horizontal if (DoubleUtil.GreaterThan(scroller.ExtentHeight, scroller.ViewportHeight)) { scroller.PageDown(); } else { scroller.PageRight(); } return(true); } } return(false); }
/// <summary>Responds to the <see cref="E:System.Windows.UIElement.KeyDown" /> event. </summary> /// <param name="e">Provides data for <see cref="T:System.Windows.Input.KeyEventArgs" />.</param> // Token: 0x06005131 RID: 20785 RVA: 0x0016C2F0 File Offset: 0x0016A4F0 protected override void OnKeyDown(KeyEventArgs e) { bool flag = true; Key key = e.Key; if (key <= Key.Down) { if (key != Key.Return) { switch (key) { case Key.Space: break; case Key.Prior: base.NavigateByPage(FocusNavigationDirection.Up, new ItemsControl.ItemNavigateArgs(e.Device, Keyboard.Modifiers)); goto IL_379; case Key.Next: base.NavigateByPage(FocusNavigationDirection.Down, new ItemsControl.ItemNavigateArgs(e.Device, Keyboard.Modifiers)); goto IL_379; case Key.End: base.NavigateToEnd(new ItemsControl.ItemNavigateArgs(e.Device, Keyboard.Modifiers)); goto IL_379; case Key.Home: base.NavigateToStart(new ItemsControl.ItemNavigateArgs(e.Device, Keyboard.Modifiers)); goto IL_379; case Key.Left: case Key.Up: case Key.Right: case Key.Down: { KeyboardNavigation.ShowFocusVisual(); bool flag2 = base.ScrollHost != null; if (flag2) { flag2 = ((key == Key.Down && base.IsLogicalHorizontal && DoubleUtil.GreaterThan(base.ScrollHost.ScrollableHeight, base.ScrollHost.VerticalOffset)) || (key == Key.Up && base.IsLogicalHorizontal && DoubleUtil.GreaterThan(base.ScrollHost.VerticalOffset, 0.0)) || (key == Key.Right && base.IsLogicalVertical && DoubleUtil.GreaterThan(base.ScrollHost.ScrollableWidth, base.ScrollHost.HorizontalOffset)) || (key == Key.Left && base.IsLogicalVertical && DoubleUtil.GreaterThan(base.ScrollHost.HorizontalOffset, 0.0))); } if (flag2) { base.ScrollHost.ScrollInDirection(e); goto IL_379; } if ((base.ItemsHost == null || !base.ItemsHost.IsKeyboardFocusWithin) && !base.IsKeyboardFocused) { flag = false; goto IL_379; } if (!base.NavigateByLine(KeyboardNavigation.KeyToTraversalDirection(key), new ItemsControl.ItemNavigateArgs(e.Device, Keyboard.Modifiers))) { flag = false; goto IL_379; } goto IL_379; } default: goto IL_377; } } if (e.Key == Key.Return && !(bool)base.GetValue(KeyboardNavigation.AcceptsReturnProperty)) { flag = false; goto IL_379; } ListBoxItem listBoxItem = e.OriginalSource as ListBoxItem; if ((Keyboard.Modifiers & (ModifierKeys.Alt | ModifierKeys.Control)) == ModifierKeys.Alt) { flag = false; goto IL_379; } if (base.IsTextSearchEnabled && Keyboard.Modifiers == ModifierKeys.None) { TextSearch textSearch = TextSearch.EnsureInstance(this); if (textSearch != null && textSearch.GetCurrentPrefix() != string.Empty) { flag = false; goto IL_379; } } if (listBoxItem == null || ItemsControl.ItemsControlFromItemContainer(listBoxItem) != this) { flag = false; goto IL_379; } switch (this.SelectionMode) { case SelectionMode.Single: if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control) { this.MakeToggleSelection(listBoxItem); goto IL_379; } this.MakeSingleSelection(listBoxItem); goto IL_379; case SelectionMode.Multiple: this.MakeToggleSelection(listBoxItem); goto IL_379; case SelectionMode.Extended: if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.Control) { this.MakeToggleSelection(listBoxItem); goto IL_379; } if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.Shift) { this.MakeAnchorSelection(listBoxItem, true); goto IL_379; } if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.None) { this.MakeSingleSelection(listBoxItem); goto IL_379; } flag = false; goto IL_379; default: goto IL_379; } } else if (key != Key.Divide && key != Key.Oem2) { if (key == Key.Oem5) { if ((Keyboard.Modifiers & ModifierKeys.Control) != ModifierKeys.Control || this.SelectionMode != SelectionMode.Extended) { flag = false; goto IL_379; } ListBoxItem listBoxItem2 = (base.FocusedInfo != null) ? (base.FocusedInfo.Container as ListBoxItem) : null; if (listBoxItem2 != null) { this.MakeSingleSelection(listBoxItem2); goto IL_379; } goto IL_379; } } else { if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && this.SelectionMode == SelectionMode.Extended) { this.SelectAll(); goto IL_379; } flag = false; goto IL_379; } IL_377: flag = false; IL_379: if (flag) { e.Handled = true; return; } base.OnKeyDown(e); }
// Token: 0x06005859 RID: 22617 RVA: 0x00187528 File Offset: 0x00185728 private void ProcessThumbDragDelta(DragDeltaEventArgs e) { Thumb thumb = e.OriginalSource as Thumb; if (thumb != null) { ToolBar toolBar = thumb.TemplatedParent as ToolBar; if (toolBar != null && toolBar.Parent == this) { if (this._bandsDirty) { this.GenerateBands(); } bool flag = this.Orientation == Orientation.Horizontal; int band = toolBar.Band; Point position = Mouse.PrimaryDevice.GetPosition(this); Point point = this.TransformPointToToolBar(toolBar, position); int bandFromOffset = this.GetBandFromOffset(flag ? position.Y : position.X); double num = flag ? e.HorizontalChange : e.VerticalChange; double num2; if (flag) { num2 = position.X - point.X; } else { num2 = position.Y - point.Y; } double num3 = num2 + num; if (bandFromOffset == band) { List <ToolBar> band2 = this._bands[band].Band; int bandIndex = toolBar.BandIndex; if (DoubleUtil.LessThan(num, 0.0)) { double num4 = this.ToolBarsTotalMinimum(band2, 0, bandIndex - 1); if (DoubleUtil.LessThanOrClose(num4, num3)) { this.ShrinkToolBars(band2, 0, bandIndex - 1, -num); } else if (bandIndex > 0) { ToolBar toolBar2 = band2[bandIndex - 1]; Point point2 = this.TransformPointToToolBar(toolBar2, position); if (DoubleUtil.LessThan(flag ? point2.X : point2.Y, 0.0)) { toolBar2.BandIndex = bandIndex; band2[bandIndex] = toolBar2; toolBar.BandIndex = bandIndex - 1; band2[bandIndex - 1] = toolBar; if (bandIndex + 1 == band2.Count) { toolBar2.ClearValue(flag ? FrameworkElement.WidthProperty : FrameworkElement.HeightProperty); } } else if (flag) { if (DoubleUtil.LessThan(num4, position.X - point.X)) { this.ShrinkToolBars(band2, 0, bandIndex - 1, position.X - point.X - num4); } } else if (DoubleUtil.LessThan(num4, position.Y - point.Y)) { this.ShrinkToolBars(band2, 0, bandIndex - 1, position.Y - point.Y - num4); } } } else { double value = this.ToolBarsTotalMaximum(band2, 0, bandIndex - 1); if (DoubleUtil.GreaterThan(value, num3)) { this.ExpandToolBars(band2, 0, bandIndex - 1, num); } else if (bandIndex < band2.Count - 1) { ToolBar toolBar3 = band2[bandIndex + 1]; Point point3 = this.TransformPointToToolBar(toolBar3, position); if (DoubleUtil.GreaterThanOrClose(flag ? point3.X : point3.Y, 0.0)) { toolBar3.BandIndex = bandIndex; band2[bandIndex] = toolBar3; toolBar.BandIndex = bandIndex + 1; band2[bandIndex + 1] = toolBar; if (bandIndex + 2 == band2.Count) { toolBar.ClearValue(flag ? FrameworkElement.WidthProperty : FrameworkElement.HeightProperty); } } else { this.ExpandToolBars(band2, 0, bandIndex - 1, num); } } else { this.ExpandToolBars(band2, 0, bandIndex - 1, num); } } } else { this._bandsDirty = true; toolBar.Band = bandFromOffset; toolBar.ClearValue(flag ? FrameworkElement.WidthProperty : FrameworkElement.HeightProperty); if (bandFromOffset >= 0 && bandFromOffset < this._bands.Count) { this.MoveToolBar(toolBar, bandFromOffset, num3); } List <ToolBar> band3 = this._bands[band].Band; for (int i = 0; i < band3.Count; i++) { ToolBar toolBar4 = band3[i]; toolBar4.ClearValue(flag ? FrameworkElement.WidthProperty : FrameworkElement.HeightProperty); } } e.Handled = true; } } }