public override void Connect()
{
SWF.ScrollBar hscrollbar
= ((ListBoxProvider)Provider).GetInternalScrollBar(SWF.Orientation.Horizontal);
hscrollbar.ValueChanged += new EventHandler(OnScrollPercentChanged);
}
void AccusoftTextBoxScrollBinder(System.Windows.Forms.ScrollBar scrScroll, System.Windows.Forms.TextBox textTextBox)
{
System.Int32 iTmp;
try
{
iTmp = Convert.ToInt32(textTextBox.Text, cultNumber);
}
catch (System.NullReferenceException ex)
{
AccusoftError(ex, lblError);
textTextBox.Text = scrScroll.Value.ToString(cultNumber);
return;
}
catch (System.Exception ex)
{
AccusoftError(ex, lblError);
textTextBox.Text = scrScroll.Value.ToString(cultNumber);
return;
}
if ((iTmp < scrScroll.Maximum) && (iTmp > scrScroll.Minimum))
{
scrScroll.Value = iTmp;
}
else
{
iTmp = scrScroll.Value;
}
textTextBox.Text = iTmp.ToString(cultNumber);
}
public override void Disconnect()
{
SWF.ScrollBar vscrollbar
= ((ListBoxProvider)Provider).GetInternalScrollBar(SWF.Orientation.Vertical);
vscrollbar.ValueChanged -= new EventHandler(OnScrollPercentChanged);
}
public HeapLayoutView()
{
SetStyle(
ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
ControlStyles.Opaque | ControlStyles.ResizeRedraw |
ControlStyles.Selectable,
true
);
BackColor = SystemColors.Window;
ForeColor = SystemColors.WindowText;
ScrollBar = new VScrollBar {
SmallChange = 1,
LargeChange = 8,
TabStop = false
};
NextAllocationButton = new Button {
Text = ">",
TabStop = false,
UseVisualStyleBackColor = true
};
NextAllocationButton.Click += NextAllocationButton_Click;
ScrollBar.Scroll += ScrollBar_Scroll;
OnResize(EventArgs.Empty);
Controls.Add(ScrollBar);
Controls.Add(NextAllocationButton);
}
public PrintPreviewControlScrollBarProvider(SWF.ScrollBar scrollbar,
PrintPreviewControlProvider provider)
: base(scrollbar)
{
this.provider = provider;
name = scrollbar is SWF.HScrollBar ? "Horizontal Scroll Bar" : "Vertical Scroll Bar";
}
private void OnNavigationUpdated(object sender, NavigationEventArgs e)
{
if (e.ChildProvider is ScrollBarProvider provider)
{
SWF.ScrollBar scrollbarProvider = (SWF.ScrollBar)provider.Control;
if (e.ChangeType == StructureChangeType.ChildAdded)
{
if (scrollbar == scrollbarProvider)
{
return;
}
if (scrollbar != null)
{
scrollbar.ValueChanged -= OnScrollValueChanged;
}
scrollbar = scrollbarProvider;
scrollbar.ValueChanged += OnScrollValueChanged;
}
else if (e.ChangeType == StructureChangeType.ChildRemoved ||
e.ChangeType == StructureChangeType.ChildrenBulkRemoved)
{
if (scrollbar != null)
{
scrollbar.ValueChanged -= OnScrollValueChanged;
}
scrollbar = null;
}
}
RaiseAutomationPropertyChangedEvent();
}
private void UpdateScrollbarNavigation(SWF.ScrollBar scrollbar,
bool navigable)
{
if (scrollbar == vscrollbar)
{
if (navigable == false && vscrollbarProvider != null)
{
RaiseNavigationEvent(StructureChangeType.ChildRemoved,
ref vscrollbarProvider,
vscrollbar);
}
else if (navigable == true && vscrollbarProvider == null)
{
RaiseNavigationEvent(StructureChangeType.ChildAdded,
ref vscrollbarProvider,
vscrollbar);
}
}
else if (scrollbar == hscrollbar)
{
if (navigable == false && hscrollbarProvider != null)
{
RaiseNavigationEvent(StructureChangeType.ChildRemoved,
ref hscrollbarProvider,
hscrollbar);
}
else if (navigable == true && hscrollbarProvider == null)
{
RaiseNavigationEvent(StructureChangeType.ChildAdded,
ref hscrollbarProvider,
hscrollbar);
}
}
}
public override void Disconnect()
{
SWF.ScrollBar vscrollbar
= ((ScrollableControlProvider)Provider).ScrollBehaviorObserver.VerticalScrollBar;
vscrollbar.VisibleChanged -= OnScrollableChanged;
vscrollbar.EnabledChanged -= OnScrollableChanged;
}
public override void Disconnect()
{
SWF.ScrollBar hscrollbar
= ((PrintPreviewControlProvider)Provider).ScrollBehaviorObserver.HorizontalScrollBar;
hscrollbar.VisibleChanged -= OnScrollableChanged;
hscrollbar.EnabledChanged -= OnScrollableChanged;
}
/// <summary>
/// This method for System.Windows.Forms.ScrollBar and inherited classes
/// </summary>
private void AdjustScrollbar(ScrollBar scrollBar, int max, int value, int clientSize)
{
scrollBar.LargeChange = clientSize / 3;
scrollBar.SmallChange = clientSize / 11;
scrollBar.Maximum = max + scrollBar.LargeChange;
scrollBar.Visible = max > 0;
scrollBar.Value = Math.Min(scrollBar.Maximum, value);
}
public override void Disconnect()
{
SWF.ScrollBar hscrollbar
= ((ListBoxProvider)Provider).GetInternalScrollBar(SWF.Orientation.Horizontal);
hscrollbar.VisibleChanged -= new EventHandler(OnScrollableChanged);
hscrollbar.EnabledChanged -= new EventHandler(OnScrollableChanged);
}
public override void Connect()
{
SWF.ScrollBar vscrollbar
= ((ListBoxProvider)Provider).GetInternalScrollBar(SWF.Orientation.Vertical);
vscrollbar.VisibleChanged += new EventHandler(OnScrollableChanged);
vscrollbar.EnabledChanged += new EventHandler(OnScrollableChanged);
}
public override void Connect()
{
SWF.ScrollBar hscrollbar
= ((DataGridProvider)Provider).ScrollBehaviorObserver.HorizontalScrollBar;
hscrollbar.VisibleChanged += OnScrollableChanged;
hscrollbar.EnabledChanged += OnScrollableChanged;
}
public override void Connect()
{
SWF.ScrollBar vscrollbar
= ((PrintPreviewControlProvider)Provider).ScrollBehaviorObserver.VerticalScrollBar;
vscrollbar.VisibleChanged += OnScrollableChanged;
vscrollbar.EnabledChanged += OnScrollableChanged;
}
public DataGridScrollBarProvider(SWF.ScrollBar scrollbar,
DataGridProvider provider)
: base(scrollbar)
{
this.provider = provider;
name = scrollbar is SWF.HScrollBar ? Catalog.GetString("Horizontal Scroll Bar")
: Catalog.GetString("Vertical Scroll Bar");
}
public void SetScrollbar(ScrollBar bar)
{
scrollbar = bar;
scrollbar.ValueChanged += (o, e) => invalidateScrollbar();
scrollbar.Scroll += (o, e) => invalidateScrollbar();
if (tileSet != null)
invalidateScrollbar();
}
public TabControl(DockStyle dockStyle, AnchorAlignment stripAnchor)
{
if ((dockStyle == DockStyle.Fill) || (dockStyle == DockStyle.None))
{
throw new ArgumentException(DR.GetString("InvalidDockingStyle", new object[] { "dockStyle" }));
}
base.SuspendLayout();
this.stripAnchor = stripAnchor;
this.Dock = dockStyle;
this.allowDockChange = false;
if ((this.Dock == DockStyle.Left) || (this.Dock == DockStyle.Right))
{
base.Width = SystemInformation.VerticalScrollBarWidth + 2;
this.splitter = new Splitter();
this.tabStrip = new System.Workflow.ComponentModel.Design.TabStrip(Orientation.Vertical, SystemInformation.VerticalScrollBarWidth);
this.scrollBar = new VScrollBar();
if (this.stripAnchor == AnchorAlignment.Near)
{
this.tabStrip.Dock = DockStyle.Top;
this.splitter.Dock = DockStyle.Top;
this.scrollBar.Dock = DockStyle.Fill;
}
else
{
this.tabStrip.Dock = DockStyle.Bottom;
this.splitter.Dock = DockStyle.Bottom;
this.scrollBar.Dock = DockStyle.Fill;
}
}
else
{
base.Height = SystemInformation.HorizontalScrollBarHeight + 2;
this.splitter = new Splitter();
this.tabStrip = new System.Workflow.ComponentModel.Design.TabStrip(Orientation.Horizontal, SystemInformation.HorizontalScrollBarHeight);
this.scrollBar = new HScrollBar();
if (this.stripAnchor == AnchorAlignment.Near)
{
this.tabStrip.Dock = DockStyle.Left;
this.splitter.Dock = DockStyle.Left;
this.scrollBar.Dock = DockStyle.Fill;
}
else
{
this.tabStrip.Dock = DockStyle.Right;
this.splitter.Dock = DockStyle.Right;
this.scrollBar.Dock = DockStyle.Fill;
}
}
base.Controls.AddRange(new Control[] { this.scrollBar, this.splitter, this.tabStrip });
this.splitter.Size = new Size(6, 6);
this.splitter.Paint += new PaintEventHandler(this.OnSplitterPaint);
this.splitter.DoubleClick += new EventHandler(this.OnSplitterDoubleClick);
((ItemList <System.Workflow.ComponentModel.Design.ItemInfo>) this.TabStrip.Tabs).ListChanged += new ItemListChangeEventHandler <System.Workflow.ComponentModel.Design.ItemInfo>(this.OnTabsChanged);
this.BackColor = SystemColors.Control;
base.ResumeLayout();
}
public TabControl(DockStyle dockStyle, AnchorAlignment stripAnchor)
{
if ((dockStyle == DockStyle.Fill) || (dockStyle == DockStyle.None))
{
throw new ArgumentException(DR.GetString("InvalidDockingStyle", new object[] { "dockStyle" }));
}
base.SuspendLayout();
this.stripAnchor = stripAnchor;
this.Dock = dockStyle;
this.allowDockChange = false;
if ((this.Dock == DockStyle.Left) || (this.Dock == DockStyle.Right))
{
base.Width = SystemInformation.VerticalScrollBarWidth + 2;
this.splitter = new Splitter();
this.tabStrip = new System.Workflow.ComponentModel.Design.TabStrip(Orientation.Vertical, SystemInformation.VerticalScrollBarWidth);
this.scrollBar = new VScrollBar();
if (this.stripAnchor == AnchorAlignment.Near)
{
this.tabStrip.Dock = DockStyle.Top;
this.splitter.Dock = DockStyle.Top;
this.scrollBar.Dock = DockStyle.Fill;
}
else
{
this.tabStrip.Dock = DockStyle.Bottom;
this.splitter.Dock = DockStyle.Bottom;
this.scrollBar.Dock = DockStyle.Fill;
}
}
else
{
base.Height = SystemInformation.HorizontalScrollBarHeight + 2;
this.splitter = new Splitter();
this.tabStrip = new System.Workflow.ComponentModel.Design.TabStrip(Orientation.Horizontal, SystemInformation.HorizontalScrollBarHeight);
this.scrollBar = new HScrollBar();
if (this.stripAnchor == AnchorAlignment.Near)
{
this.tabStrip.Dock = DockStyle.Left;
this.splitter.Dock = DockStyle.Left;
this.scrollBar.Dock = DockStyle.Fill;
}
else
{
this.tabStrip.Dock = DockStyle.Right;
this.splitter.Dock = DockStyle.Right;
this.scrollBar.Dock = DockStyle.Fill;
}
}
base.Controls.AddRange(new Control[] { this.scrollBar, this.splitter, this.tabStrip });
this.splitter.Size = new Size(6, 6);
this.splitter.Paint += new PaintEventHandler(this.OnSplitterPaint);
this.splitter.DoubleClick += new EventHandler(this.OnSplitterDoubleClick);
((ItemList<System.Workflow.ComponentModel.Design.ItemInfo>) this.TabStrip.Tabs).ListChanged += new ItemListChangeEventHandler<System.Workflow.ComponentModel.Design.ItemInfo>(this.OnTabsChanged);
this.BackColor = SystemColors.Control;
base.ResumeLayout();
}
private void PerformScrollByPercent(SWF.ScrollBar scrollbar, int value)
{
if (scrollbar.InvokeRequired == true)
{
scrollbar.BeginInvoke(new ScrollByPercentDelegate(PerformScrollByPercent),
new object [] { scrollbar, value });
return;
}
scrollbar.Value = value;
}
private void PerformScrollByAmount(SWF.ScrollBar scrollbar)
{
if (scrollbar.InvokeRequired == true)
{
scrollbar.BeginInvoke(new ScrollByAmountDelegate(PerformScrollByAmount),
new object [] { scrollbar });
return;
}
invoke(scrollbar);
invoke = null;
}
public void Initialize(ScrollBar v, ScrollBar h) {
this.VerticalSB = v;
this.HorizontalSB = h;
this.Texture = null;
Buffer = new Selection[BUFFER_SIZE];
for (int i = 0; i < BUFFER_SIZE; i++) {
Buffer[i] = new Selection {
GridWidth = 1, GridHeight = 1
};
}
}
public ScrollBehaviorObserver(IScrollBehaviorSubject subject,
SWF.ScrollBar horizontal,
SWF.ScrollBar vertical)
{
this.subject = subject;
HorizontalScrollBar = horizontal;
VerticalScrollBar = vertical;
scrollpatternSet = false;
if (SupportsScrollPattern == true)
{
OnScrollPatternSupportChanged();
}
}
private void AdjustScrollbar(float t, ScrollBar scrollMax, ScrollBar scrollMin)
{
if (t > scrollMax.Maximum)
{
scrollMax.Maximum = (int) t;
scrollMax.Minimum = scrollMin.Maximum;
}
if (t < scrollMin.Minimum)
{
scrollMin.Minimum = (int) t;
scrollMin.Maximum = scrollMax.Minimum;
}
}
public SideBarControl(SideBar nSideBar)
{
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.CacheText, true);
AllowDrop = true;
mMouseWheelHandler = new MouseWheelHandler();
mSideTabContent = new SideTabContent(nSideBar);
mScrollBar = new VScrollBar();
mScrollBar.Scroll += new ScrollEventHandler(_scrollBarScrolled);
mSideBar = nSideBar;
mMouseDownTab = null;
Controls.Add(mScrollBar);
Controls.Add(mSideTabContent);
}
private void ScrollByAmount(SWF.ScrollBar scrollbar, string method)
{
if (method == string.Empty)
{
return;
}
MethodInfo methodInfo = typeof(SWF.ScrollBar).GetMethod(method,
BindingFlags.InvokeMethod
| BindingFlags.NonPublic
| BindingFlags.Instance);
invoke
= (Action <SWF.ScrollBar>)Delegate.CreateDelegate(typeof(Action <SWF.ScrollBar>),
methodInfo);
PerformScrollByAmount(scrollbar);
}
public SystemScrollBarAdapter(Orientation orientation)
{
switch(orientation)
{
case Orientation.Vertical:
_scrollBar = new VScrollBar();
break;
case Orientation.Horizontal:
_scrollBar = new HScrollBar();
break;
default:
throw new ArgumentException("orientation");
}
_scrollBar.Scroll += OnScrollBarScroll;
_scrollBar.ValueChanged += OnScrollBarValueChanged;
_orientation = orientation;
}
private void RaiseNavigationEvent(StructureChangeType type,
ref FragmentControlProvider provider,
SWF.ScrollBar scrollbar)
{
if (type == StructureChangeType.ChildAdded)
{
provider = subject.GetScrollbarProvider(scrollbar);
provider.Initialize();
subject.AddChildProvider(provider);
}
else
{
subject.RemoveChildProvider(provider);
provider.Terminate();
provider = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (!this._disposed)
{
if (disposing)
{
if (this._maskControl != null)
{
this._maskControl.Dispose();
this._maskControl = null;
}
this._owner = null;
}
this.ReleaseHandleInternal();
}
this._disposed = true;
}
public ScrollBarReplacement(System.Windows.Forms.ScrollBar sb)
{
m_ParentScrollBar = sb;
m_ParentScrollBarWndProc = (IScrollBarExtender)m_ParentScrollBar;
m_IsVScrollBar = m_ParentScrollBar is VScrollBar;
m_ScrollBarCore = new ScrollBarCore(m_ParentScrollBar, false);
m_ScrollBarCore.ValueChanged += new EventHandler(ScrollBarCore_ValueChanged);
if (m_ParentScrollBar is HScrollBar)
m_ScrollBarCore.Orientation = eOrientation.Horizontal;
else
m_ScrollBarCore.Orientation = eOrientation.Vertical;
m_ScrollBarCore.Minimum = m_ParentScrollBar.Minimum;
m_ScrollBarCore.Maximum = m_ParentScrollBar.Maximum;
m_ScrollBarCore.Value = m_ParentScrollBar.Value;
m_ScrollBarCore.Enabled = m_ParentScrollBar.Enabled;
m_ParentScrollBar.EnabledChanged += new EventHandler(ParentScrollBar_EnabledChanged);
}
public ScrollBarImplementation(System.Windows.Forms.ScrollBar sb)
{
m_ParentScrollBar = sb;
m_ParentScrollBarWndProc = (IScrollBarExtender)m_ParentScrollBar;
m_IsVScrollBar = m_ParentScrollBar is VScrollBar;
m_PaintTimer = new Timer();
m_PaintTimer.Interval = 50;
m_PaintTimer.Tick += new EventHandler(PaintTimerTick);
m_ScrollBarCore = new ScrollBarCore(m_ParentScrollBar, true);
//m_ScrollBarCore.IsAppScrollBarStyle = false;
if (m_ParentScrollBar is HScrollBar)
m_ScrollBarCore.Orientation = eOrientation.Horizontal;
else
m_ScrollBarCore.Orientation = eOrientation.Vertical;
m_ScrollBarCore.Minimum = m_ParentScrollBar.Minimum;
m_ScrollBarCore.Maximum = m_ParentScrollBar.Maximum;
m_ScrollBarCore.Value = m_ParentScrollBar.Value;
}
public ScrollBarControlLogic(Panel panel)
{
mPanel = panel;
mVerticalScrollBar = new VScrollBar();
mVerticalScrollBar.Dock = DockStyle.Right;
//mVerticalScrollBar.Scroll += HandleVerticalScroll;
mVerticalScrollBar.ValueChanged += HandleVerticalScroll;
panel.Controls.Add(mVerticalScrollBar);
mHorizontalScrollBar = new HScrollBar();
mHorizontalScrollBar.Dock = DockStyle.Bottom;
mHorizontalScrollBar.ValueChanged += HandleHorizontalScroll;
panel.Controls.Add(mHorizontalScrollBar);
UpdateToImage(2048, 2048);
mPanel.Resize += HandlePanelResize;
}
public DeltaList()
{
SetStyle(
ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
ControlStyles.Opaque | ControlStyles.ResizeRedraw |
ControlStyles.Selectable,
true
);
BackColor = SystemColors.Window;
ForeColor = SystemColors.WindowText;
ScrollBar = new VScrollBar {
SmallChange = 1,
LargeChange = 8,
TabStop = false
};
ScrollBar.Scroll += ScrollBar_Scroll;
OnResize(EventArgs.Empty);
Controls.Add(ScrollBar);
}
public FragmentControlProvider GetScrollbarProvider(SWF.ScrollBar scrollbar)
{
return(new ScrollBarProvider(scrollbar));
}
/// <summary>
/// Scrolls the view according to the given ScrollEventArgs.
/// </summary>
/// <param name="scrollBar">The source of the ScrollEvent.</param>
/// <param name="e">A ScrollEventArgs containing the event data.</param>
/// <param name="animateFirst">
/// A boolean value indicating whether or not to animate the first scroll.
/// </param>
protected virtual void Scroll(ScrollBar scrollBar, ScrollEventArgs e, bool animateFirst) {
// If we are animating, terminate any previous scroll activities.
if (animateScrolls) {
TerminatePreviousScroll(scrollBar, e);
}
if (e.Type != ScrollEventType.EndScroll) {
Point viewPosition;
if (scrollBar is VScrollBar) {
viewPosition = new Point(ViewPosition.X, e.NewValue);
} else {
viewPosition = new Point(e.NewValue, ViewPosition.Y);
}
// At the Start of a scroll sequence, we will animate the scroll if
// animateScrolls is set to true.
if (startOfScrollSequence && animateFirst) {
if (e.Type != ScrollEventType.ThumbTrack) {
SetViewPosition(viewPosition, true);
e.NewValue = scrollBar.Value;
}
startOfScrollSequence = false;
}
else {
if (!Canvas.Interacting) Canvas.Interacting = true;
// Otherwise, just set the position directly.
SetViewPosition(viewPosition, false);
}
} else {
// Reset some flags at the End of a scroll sequence.
startOfScrollSequence = true;
if (Canvas.Interacting) Canvas.Interacting = false;
}
}
private void Scroll (ScrollBar scrollbar, int delta)
{
if (delta == 0 || !scrollbar.Visible)
return;
SetScrollValue (scrollbar, scrollbar.Value + delta);
}
protected virtual void ScrollBar_DrawThumb(ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc)
{
if (bar.Enabled && thumb_pos.Width > 0 && thumb_pos.Height > 0 && clip.IntersectsWith(thumb_pos))
DrawScrollButtonPrimitive(dc, thumb_pos, ButtonState.Normal);
}
bool IWorkflowDesignerMessageSink.OnScroll(ScrollBar sender, int value)
{
try
{
OnScroll(sender, value);
}
catch
{
}
return true;
}
private void SetScroll( ScrollBar scrollBar, Axis axis, double scrollMin, double scrollMax )
{
if ( scrollBar != null && axis != null )
{
scrollBar.Minimum = 0;
scrollBar.Maximum = _ScrollControlSpan - 1;
if ( scrollMin > axis._scale._min )
scrollMin = axis._scale._min;
if ( scrollMax < axis._scale._max )
scrollMax = axis._scale._max;
int val = 0;
Scale scale = axis._scale;
double minLinearized = scale._minLinearized;
double maxLinearized = scale._maxLinearized;
scrollMin = scale.Linearize( scrollMin );
scrollMax = scale.Linearize( scrollMax );
double scrollMin2 = scrollMax - ( maxLinearized - minLinearized );
/*
if ( axis.Scale.IsLog )
scrollMin2 = scrollMax / ( axis._scale._max / axis._scale._min );
else
scrollMin2 = scrollMax - ( axis._scale._max - axis._scale._min );
*/
if ( scrollMin >= scrollMin2 )
{
//scrollBar.Visible = false;
scrollBar.Enabled = false;
scrollBar.Value = 0;
}
else
{
double ratio = ( maxLinearized - minLinearized ) / ( scrollMax - scrollMin );
/*
if ( axis.Scale.IsLog )
ratio = ( Math.Log( axis._scale._max ) - Math.Log( axis._scale._min ) ) /
( Math.Log( scrollMax ) - Math.Log( scrollMin ) );
else
ratio = ( axis._scale._max - axis._scale._min ) / ( scrollMax - scrollMin );
*/
int largeChange = (int)( ratio * _ScrollControlSpan + 0.5 );
if ( largeChange < 1 )
largeChange = 1;
scrollBar.LargeChange = largeChange;
int smallChange = largeChange / _ScrollSmallRatio;
if ( smallChange < 1 )
smallChange = 1;
scrollBar.SmallChange = smallChange;
int span = _ScrollControlSpan - largeChange;
val = (int)( ( minLinearized - scrollMin ) / ( scrollMin2 - scrollMin ) *
span + 0.5 );
/*
if ( axis.Scale.IsLog )
val = (int)( ( Math.Log( axis._scale._min ) - Math.Log( scrollMin ) ) /
( Math.Log( scrollMin2 ) - Math.Log( scrollMin ) ) * span + 0.5 );
else
val = (int)( ( axis._scale._min - scrollMin ) / ( scrollMin2 - scrollMin ) *
span + 0.5 );
*/
if ( val < 0 )
val = 0;
else if ( val > span )
val = span;
//if ( ( axis is XAxis && axis.IsReverse ) || ( ( ! axis is XAxis ) && ! axis.IsReverse ) )
if ( ( axis is XAxis ) == axis.Scale.IsReverse )
val = span - val;
if ( val < scrollBar.Minimum )
val = scrollBar.Minimum;
if ( val > scrollBar.Maximum )
val = scrollBar.Maximum;
scrollBar.Value = val;
scrollBar.Enabled = true;
//scrollBar.Visible = true;
}
}
}
/// <summary>
/// Returns an observable sequence wrapping the Scroll event on the ScrollBar instance.
/// </summary>
/// <param name="instance">The ScrollBar instance to observe.</param>
/// <returns>An observable sequence wrapping the Scroll event on the ScrollBar instance.</returns>
public static IObservable <EventPattern <ScrollEventArgs> > ScrollObservable(this ScrollBar instance)
{
return(Observable.FromEventPattern <ScrollEventHandler, ScrollEventArgs>(
handler => instance.Scroll += handler,
handler => instance.Scroll -= handler));
}
void zgc_ScrollProgressEvent( ZedGraphControl sender, ScrollBar scrollBar, ZoomState oldState,
ZoomState newState )
{
//this.toolStripStatusLabel1.Text = sender.GraphPane.XAxis.Scale.Max.ToString();
// When scroll action is finished, recalculate the axis ranges
sender.AxisChange();
sender.Refresh();
}
public ScrollBarChildAccessibleObject(ScrollBar owningScrollBar)
{
OwningScrollBar = owningScrollBar;
}
internal ScrollBarAccessibleObject(ScrollBar owner) : base(owner)
{
_owningScrollBar = owner;
}
public FragmentControlProvider GetScrollbarProvider(SWF.ScrollBar scrollbar)
{
return(new DataGridScrollBarProvider(scrollbar, this));
}
public FragmentControlProvider GetScrollbarProvider(SWF.ScrollBar scrollbar)
{
return(new PrintPreviewControlScrollBarProvider(scrollbar, this));
}
// Drawing //public abstract void DrawScrollBar (Graphics dc, Rectangle area, ScrollBar bar, ref Rectangle thumb_pos, ref Rectangle first_arrow_area, ref Rectangle second_arrow_area, ButtonState first_arrow, ButtonState second_arrow, ref int scrollbutton_width, ref int scrollbutton_height, bool vert); public abstract void DrawScrollBar(Graphics dc, Rectangle clip_rectangle, ScrollBar bar);
public void Initialize(ScrollBar scrollbar) {
this.scrollbar = scrollbar;
this.scrolling = new FluentScrolling(scrollbar);
}
/// <summary>
/// Returns an observable sequence wrapping the BackgroundImageLayoutChanged event on the ScrollBar instance.
/// </summary>
/// <param name="instance">The ScrollBar instance to observe.</param>
/// <returns>An observable sequence wrapping the BackgroundImageLayoutChanged event on the ScrollBar instance.</returns>
public static IObservable <EventPattern <EventArgs> > BackgroundImageLayoutChangedObservable(this ScrollBar instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.BackgroundImageLayoutChanged += handler,
handler => instance.BackgroundImageLayoutChanged -= handler));
}
public ScrollBarThumbAccessibleObject(ScrollBar owningScrollBar) : base(owningScrollBar)
{
}
private void ProcessEventStuff( ScrollBar scrollBar, ScrollEventArgs e )
{
if ( e.Type == ScrollEventType.ThumbTrack )
{
if ( ScrollProgressEvent != null )
ScrollProgressEvent( this, hScrollBar1, _zoomState,
new ZoomState( GraphPane, ZoomState.StateType.Scroll ) );
}
else // if ( e.Type == ScrollEventType.ThumbPosition )
{
if ( _zoomState != null && _zoomState.IsChanged( GraphPane ) )
{
//this.GraphPane.ZoomStack.Push( _zoomState );
ZoomStatePush( GraphPane );
// Provide Callback to notify the user of pan events
if ( ScrollDoneEvent != null )
ScrollDoneEvent( this, hScrollBar1, _zoomState,
new ZoomState( GraphPane, ZoomState.StateType.Scroll ) );
_zoomState = null;
}
}
if ( ScrollEvent != null )
ScrollEvent( scrollBar, e );
}
protected override bool OnScroll(ScrollBar sender, int value)
{
ActivityDesigner designerWithFocus = this.GetDesignerWithFocus();
if (designerWithFocus != null)
{
((IWorkflowDesignerMessageSink) designerWithFocus).OnScroll(sender, value);
}
return false;
}
/// <summary>
/// Called when scroll position is changed
/// </summary>
/// <param name="sender">Scrollbar sending the message</param>
/// <param name="value">New value of the scrolled position</param>
protected virtual void OnScroll(ScrollBar sender, int value)
{
}
internal ImageBoxScrollProperties(ScrollBar scrollBar)
{
_scrollBar = scrollBar;
}
public override void DrawScrollBar (Graphics dc, Rectangle clip, ScrollBar bar)
{
int scrollbutton_width = bar.scrollbutton_width;
int scrollbutton_height = bar.scrollbutton_height;
Rectangle first_arrow_area;
Rectangle second_arrow_area;
Rectangle thumb_pos;
thumb_pos = bar.ThumbPos;
if (bar.vert) {
first_arrow_area = new Rectangle(0, 0, bar.Width, scrollbutton_height);
bar.FirstArrowArea = first_arrow_area;
second_arrow_area = new Rectangle(0, bar.ClientRectangle.Height - scrollbutton_height, bar.Width, scrollbutton_height);
bar.SecondArrowArea = second_arrow_area;
thumb_pos.Width = bar.Width;
bar.ThumbPos = thumb_pos;
Brush VerticalBrush;
/* Background, upper track */
if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
else
VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
Rectangle UpperTrack = new Rectangle (0, 0, bar.ClientRectangle.Width, bar.ThumbPos.Bottom);
if (clip.IntersectsWith (UpperTrack))
dc.FillRectangle (VerticalBrush, UpperTrack);
/* Background, lower track */
if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
else
VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
Rectangle LowerTrack = new Rectangle (0, bar.ThumbPos.Bottom, bar.ClientRectangle.Width, bar.ClientRectangle.Height - bar.ThumbPos.Bottom);
if (clip.IntersectsWith (LowerTrack))
dc.FillRectangle (VerticalBrush, LowerTrack);
/* Buttons */
if (clip.IntersectsWith (first_arrow_area))
CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Up, bar.firstbutton_state);
if (clip.IntersectsWith (second_arrow_area))
CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Down, bar.secondbutton_state);
} else {
first_arrow_area = new Rectangle(0, 0, scrollbutton_width, bar.Height);
bar.FirstArrowArea = first_arrow_area;
second_arrow_area = new Rectangle (bar.ClientRectangle.Width - scrollbutton_width, 0, scrollbutton_width, bar.Height);
bar.SecondArrowArea = second_arrow_area;
thumb_pos.Height = bar.Height;
bar.ThumbPos = thumb_pos;
Brush HorizontalBrush;
//Background, left track
if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
else
HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
Rectangle LeftTrack = new Rectangle (0, 0, bar.ThumbPos.Right, bar.ClientRectangle.Height);
if (clip.IntersectsWith (LeftTrack))
dc.FillRectangle (HorizontalBrush, LeftTrack);
//Background, right track
if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
else
HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
Rectangle RightTrack = new Rectangle (bar.ThumbPos.Right, 0, bar.ClientRectangle.Width - bar.ThumbPos.Right, bar.ClientRectangle.Height);
if (clip.IntersectsWith (RightTrack))
dc.FillRectangle (HorizontalBrush, RightTrack);
/* Buttons */
if (clip.IntersectsWith (first_arrow_area))
CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Left, bar.firstbutton_state);
if (clip.IntersectsWith (second_arrow_area))
CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Right, bar.secondbutton_state);
}
/* Thumb */
ScrollBar_DrawThumb(bar, thumb_pos, clip, dc);
}
/// <summary>
/// Returns an observable sequence wrapping the ImeModeChanged event on the ScrollBar instance.
/// </summary>
/// <param name="instance">The ScrollBar instance to observe.</param>
/// <returns>An observable sequence wrapping the ImeModeChanged event on the ScrollBar instance.</returns>
public static IObservable <EventPattern <EventArgs> > ImeModeChangedObservable(this ScrollBar instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.ImeModeChanged += handler,
handler => instance.ImeModeChanged -= handler));
}
private void SetScrollValue (ScrollBar scrollbar, int val)
{
int max;
if (scrollbar == h_scroll)
max = h_scroll.Maximum - h_scroll.LargeChange + 1;
else
max = v_scroll.Maximum - v_scroll.LargeChange + 1;
if (val > max)
val = max;
else if (val < scrollbar.Minimum)
val = scrollbar.Minimum;
scrollbar.Value = val;
}
private void CreateScrollBar(Control parent)
{
// Do we need to create a scrollbar?
if (_scrollBar == null)
{
// Create the correct type of control
if (Vertical)
_scrollBar = new VScrollBar();
else
_scrollBar = new HScrollBar();
// Hook into scroll position changes
_scrollBar.Scroll += new ScrollEventHandler(OnScrollBarChange);
// Create it hidden
_scrollBar.Hide();
// Set the scrolling values
_scrollBar.Minimum = _min;
_scrollBar.Maximum = _max;
_scrollBar.SmallChange = _smallChange;
_scrollBar.LargeChange = _largeChange;
_scrollBar.Value = _offset;
// Add our new control to the provided parent collection
CommonHelper.AddControlToParent(parent, _scrollBar);
}
}
public ListView ()
{
background_color = ThemeEngine.Current.ColorWindow;
groups = new ListViewGroupCollection (this);
items = new ListViewItemCollection (this);
items.Changed += new CollectionChangedHandler (OnItemsChanged);
checked_indices = new CheckedIndexCollection (this);
checked_items = new CheckedListViewItemCollection (this);
columns = new ColumnHeaderCollection (this);
foreground_color = SystemColors.WindowText;
selected_indices = new SelectedIndexCollection (this);
selected_items = new SelectedListViewItemCollection (this);
items_location = new Point [16];
items_matrix_location = new ItemMatrixLocation [16];
reordered_items_indices = new int [16];
item_tooltip = new ToolTip ();
item_tooltip.Active = false;
insertion_mark = new ListViewInsertionMark (this);
InternalBorderStyle = BorderStyle.Fixed3D;
header_control = new HeaderControl (this);
header_control.Visible = false;
Controls.AddImplicit (header_control);
item_control = new ItemControl (this);
Controls.AddImplicit (item_control);
h_scroll = new ImplicitHScrollBar ();
Controls.AddImplicit (this.h_scroll);
v_scroll = new ImplicitVScrollBar ();
Controls.AddImplicit (this.v_scroll);
h_marker = v_marker = 0;
keysearch_tickcnt = 0;
// scroll bars are disabled initially
h_scroll.Visible = false;
h_scroll.ValueChanged += new EventHandler(HorizontalScroller);
v_scroll.Visible = false;
v_scroll.ValueChanged += new EventHandler(VerticalScroller);
// event handlers
base.KeyDown += new KeyEventHandler(ListView_KeyDown);
SizeChanged += new EventHandler (ListView_SizeChanged);
GotFocus += new EventHandler (FocusChanged);
LostFocus += new EventHandler (FocusChanged);
MouseWheel += new MouseEventHandler(ListView_MouseWheel);
MouseEnter += new EventHandler (ListView_MouseEnter);
Invalidated += new InvalidateEventHandler (ListView_Invalidated);
BackgroundImageTiled = false;
this.SetStyle (ControlStyles.UserPaint | ControlStyles.StandardClick
| ControlStyles.UseTextForAccessibility
, false);
}
private void RemoveScrollBar()
{
// Do we need to remove the scrollbar?
if ((_scrollBar != null) && !_removing)
{
// Prevent recreate of the control during removal, as removing it
// will cause more layout cycles to occur. We put it back to false
// at the end of the remove process.
_removing = true;
// Unhook from events
_scrollBar.Scroll -= new ScrollEventHandler(OnScrollBarChange);
// Hide the scrollbar from view
_scrollBar.Hide();
// Remove scrollbar from containing collection
CommonHelper.RemoveControlFromParent(_scrollBar);
// Destroy the current scrollbar
_scrollBar.Dispose();
_scrollBar = null;
_removing = false;
}
}
/// <summary>
/// Terminates the previous scroll activity if a new scroll event occurs.
/// </summary>
/// <param name="scrollBar">The source of the new Scroll event.</param>
/// <param name="e">The event data associated with the Scroll event.</param>
protected virtual void TerminatePreviousScroll(ScrollBar scrollBar, ScrollEventArgs e) {
if (e.Type != ScrollEventType.EndScroll && scroll != null && scroll.IsStepping) {
ScrollActivity scrollActivity = (ScrollActivity)scroll;
scroll.Terminate();
int newPos;
if (scrollBar is VScrollBar) {
newPos = scrollActivity.newPosition.Y;
} else {
newPos = scrollActivity.newPosition.X;
}
int max = scrollBar.Maximum - scrollBar.LargeChange+1;
switch (e.Type) {
case ScrollEventType.SmallDecrement:
e.NewValue = Math.Max(vScrollBar.Minimum, (newPos - scrollBar.SmallChange));
break;
case ScrollEventType.SmallIncrement:
e.NewValue = Math.Min(max, (newPos + scrollBar.SmallChange));
break;
case ScrollEventType.LargeDecrement:
e.NewValue = Math.Max(vScrollBar.Minimum, (newPos - scrollBar.LargeChange));
break;
case ScrollEventType.LargeIncrement:
e.NewValue = Math.Min(max, (newPos + scrollBar.LargeChange));
break;
}
}
}
public ScrollBarFirstLineButtonAccessibleObject(ScrollBar owningScrollBar) : base(owningScrollBar)
{
}
