private static void OnAdjustAdornerForScrollViewerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ScrollContentPresenter scp = (ScrollContentPresenter)d;
ScrollViewer oldScrollViewer = (ScrollViewer)e.OldValue;
ScrollViewer newScrollViewer = (ScrollViewer)d.GetValue(AdjustAdornerForScrollViewerProperty);
ScrollChangedEventHandler scrollChangedEventHandler = (s, ea) =>
{
int children = VisualTreeHelper.GetChildrenCount(scp);
for (int i = 0; i < children; i++)
{
DependencyObject child = VisualTreeHelper.GetChild(scp, i);
if (child is AdornerLayer)
{
AdornerLayer al = child as AdornerLayer;
al.Dispatcher.BeginInvoke(DispatcherPriority.Send, new ThreadStart(al.Update));
}
}
};
if (oldScrollViewer != null)
{
oldScrollViewer.ScrollChanged -= scrollChangedEventHandler;
}
if (newScrollViewer != null)
{
if ((bool)newScrollViewer.GetValue(ShouldAdjustAdornerProperty))
{
newScrollViewer.ScrollChanged += scrollChangedEventHandler;
}
}
}
public RedUnderlineAdorner(SpellTextBox textbox) : base(textbox)
{
sizeChangedEventHandler = new SizeChangedEventHandler(
delegate
{
SignalInvalidate();
});
routedEventHandler = new RoutedEventHandler(
delegate
{
SignalInvalidate();
});
scrollChangedEventHandler = new ScrollChangedEventHandler(
delegate
{
SignalInvalidate();
});
textbox.SizeChanged += sizeChangedEventHandler;
textbox.SpellcheckCompleted += routedEventHandler;
textbox.AddHandler(ScrollViewer.ScrollChangedEvent, scrollChangedEventHandler);
}
private void Popup_Opened(object sender, EventArgs e)
{
LimeMsg.Debug("Popup_Opened");
// Subscribe to every parent scrollviewers to detect scrolling there (and close the DropDown)
if (_ScrollChangedEventHandler == null)
{
_ScrollChangedEventHandler = new ScrollChangedEventHandler(ScrollViewer_ScrollChanged);
foreach (var scrollViewer in GetParentScrollViewers())
{
scrollViewer.ScrollChanged += _ScrollChangedEventHandler;
}
}
// Autosize
if (wxPopup.Placement == PlacementMode.Bottom || wxPopup.Placement == PlacementMode.Top)
{
wxPopupBorder.MinWidth = wxMain.ActualWidth;
wxPopup.HorizontalOffset = wxMain.Margin.Left;
}
var item = WPF.FindFirstChild <TextBox>(wxPicker);
if (item != null)
{
Keyboard.Focus(item);
}
}
internal static new void InvokeHandler(Delegate handler, IntPtr sender, IntPtr args)
{
ScrollChangedEventHandler handler_ = (ScrollChangedEventHandler)handler;
if (handler_ != null)
{
handler_(Extend.GetProxy(sender, false), new ScrollChangedEventArgs(args, false));
}
}
protected virtual void OnScrollChanged(ScrollChangedEventArgs e)
{
ScrollChangedEventHandler handler = ScrollChanged;
if (handler != null)
{
handler(this, e);
}
}
private async void LazyLoad(object sender, ScrollChangedEventArgs e)
{
lock (LazyLoadEventHandler)
{
LazyLoadEventHandler = null;
}
//懒加载的业务代码
FileListViewModel vm = DataContext as FileListViewModel;
await Task.Run(() => vm.LazyLoad());
LazyLoadEventHandler = new ScrollChangedEventHandler(LazyLoad);
}
private async void LazyLoad(object sender, ScrollChangedEventArgs e)
{
lock (LazyLoadEventHandler)
{
LazyLoadEventHandler -= LazyLoad;
}
//懒加载的业务代码
TransferListViewModel vm = DataContext as TransferListViewModel;
await vm.OfflineTask.LazyLoad();
LazyLoadEventHandler += LazyLoad;
}
private void Popup_Opened(object sender, EventArgs e)
{
LimeMsg.Debug("Popup_Opened");
// Subscribe to every parent scrollviewers to detect scrolling there (and close the DropDown)
if (_ScrollChangedEventHandler == null)
{
_ScrollChangedEventHandler = new ScrollChangedEventHandler(ScrollViewer_ScrollChanged);
foreach (var scrollViewer in GetParentScrollViewers())
{
LimeMsg.Debug("LimeDropDown Popup_Opened: subscribe _ScrollChangedEventHandler: {0}", scrollViewer);
scrollViewer.ScrollChanged += _ScrollChangedEventHandler;
}
}
// Autosize
if (wxPopup.Placement == PlacementMode.Bottom || wxPopup.Placement == PlacementMode.Top)
{
wxMenu.MinWidth = wxMain.ActualWidth;
wxPopup.HorizontalOffset = wxMain.Margin.Left;
}
// Readjust value if not yet selected
if (wxMenu.ItemsSource != null && Cache != null)
{
wxMenu.SelectedValue = Cache;
}
ListBoxItem item = null;
if (wxMenu.SelectedItem != null)
{
item = wxMenu.ItemContainerGenerator.ContainerFromItem(wxMenu.SelectedItem) as ListBoxItem;
}
if (item == null)
{
item = WPF.FindFirstChild <ListBoxItem>(wxMenu);
}
if (item != null)
{
Keyboard.Focus(item);
}
}
public RedUnderlineAdorner(TextBox textbox, SpellCheckHelper mySpeller) : base(textbox)
{
this.textbox = textbox;
this.mySpeller = mySpeller;
scrollChangedEventHandler = new ScrollChangedEventHandler(
delegate
{
SignalInvalidate();
});
textChangedEventHandler = new TextChangedEventHandler(
delegate
{
mySpeller.SpellCheck();
SignalInvalidate();
});
textbox.AddHandler(ScrollViewer.ScrollChangedEvent, scrollChangedEventHandler);
textbox.TextChanged += textChangedEventHandler;
}
public MainWindow()
{
api = new Base();
scrollChanged_flows = new ScrollChangedEventHandler(scrollViewer1_ScrollChanged_flows);
scrollChanged_drops = new ScrollChangedEventHandler(scrollViewer1_ScrollChanged_drops);
InitializeComponent();
{
UI.GIFImageControl img = new UI.GIFImageControl()
{
GIFSource = "Resources/ajax-loader.gif",
MaxHeight = 100,
MaxWidth = 100
};
img.PreviewMouseWheel += FAGGUI.XamlHelpers.Bubbler;
BlockUIContainer buic = new BlockUIContainer(img);
buic.PreviewMouseWheel += FAGGUI.XamlHelpers.Bubbler;
FlowDocument doc = new FlowDocument() { TextAlignment = TextAlignment.Center };
doc.PreviewMouseWheel += FAGGUI.XamlHelpers.Bubbler;
doc.Blocks.Add(buic);
loader_fdsv = new FlowDocumentScrollViewer()
{
HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
Document = doc,
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
Background = new SolidColorBrush(Colors.White)
};
loader_fdsv.PreviewMouseWheel += FAGGUI.XamlHelpers.Bubbler;
loader_fdsv.SizeChanged += FAGGUI.XamlHelpers.Resizer;
}
lastExpression = expressionBox.Text;
lastOffset = 0;
LoadFlows();
}
public static void ScrollCommandPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
if (!(sender is ListBox listBox))
{
return;
}
if (!listBox.IsLoaded)
{
listBox.Loaded += (_s, _ev) =>
{
if (!(VisualTreeHelper.GetChildrenCount(listBox) != 0 && VisualTreeHelper.GetChild(listBox, 0) is Border border))
{
return;
}
if (!(border.Child is ScrollViewer scrollViewer))
{
return;
}
if (!(e.NewValue is DelegateCommand command))
{
return;
}
attachedCommand = (object s, ScrollChangedEventArgs ev) =>
{
if (command.CanExecute((s, ev)))
{
command.Execute((s, ev));
}
};
scrollViewer.ScrollChanged += attachedCommand;
};
}
}
}
public RedUnderlineAdorner(SpellTextBox textbox) : base(textbox)
{
timer.Tick += timer_Tick;
timer.Interval = new TimeSpan(0, 0, 0, 0, 200);
stopwatch.Start();
timer.Start();
sizeChangedEventHandler = new SizeChangedEventHandler(
delegate
{
adornerClear = true;
SignalInvalidate();
timer.Start();
});
routedEventHandler = new RoutedEventHandler(
delegate
{
adornerClear = true;
SignalInvalidate();
timer.Start();
});
scrollChangedEventHandler = new ScrollChangedEventHandler(
delegate
{
adornerClear = true;
SignalInvalidate();
timer.Start();
});
textbox.SizeChanged += sizeChangedEventHandler;
textbox.SpellcheckCompleted += routedEventHandler;
textbox.AddHandler(ScrollViewer.ScrollChangedEvent, scrollChangedEventHandler);
}
private async static void ItemsSourceChanged(object sender, EventArgs eventArgs)
{
var itemsControl = (ItemsControl)sender;
if (itemsControl.ItemsSource == null)
{
return;
}
var opacityAnimation = new DoubleAnimation(0, 1, TimeSpan.FromMilliseconds(260), FillBehavior.Stop);
var marginAnimation = new ThicknessAnimation(new Thickness(-20, 0, 20, 0), new Thickness(0),
TimeSpan.FromMilliseconds(240), FillBehavior.Stop)
{
EasingFunction = new CircleEase {
EasingMode = EasingMode.EaseOut
}
};
if (Timers.ContainsKey(itemsControl))
{
Timers[itemsControl].Stop();
Timers.Remove(itemsControl);
}
List <ListBoxItem> visibleItems;
itemsControl.Opacity = 0;
while (true)
{
visibleItems = DependencyObjectExtensions.GetVisibleItemsFromItemsControl(itemsControl,
Window.GetWindow(itemsControl));
if (visibleItems.Count > 0 || itemsControl.Items.Count == 0)
{
break;
}
await Task.Delay(1);
}
Debug.Print("Items to animate: " + visibleItems.Count);
foreach (var item in visibleItems)
{
item.Opacity = 0;
}
itemsControl.Opacity = 1;
DispatcherTimer dispatcherTimer;
var enumerator = visibleItems.GetEnumerator();
if (enumerator.MoveNext())
{
ScrollChangedEventHandler scrollChangedEventHandler = null;
scrollChangedEventHandler = (o, args) =>
{
var handler = scrollChangedEventHandler;
if (handler != null)
{
itemsControl.RemoveHandler(ScrollViewer.ScrollChangedEvent, handler);
}
if (!Timers.ContainsKey(itemsControl) || !Timers[itemsControl].IsEnabled)
{
return;
}
var timer = Timers[itemsControl];
timer.Stop();
while (true)
{
var item = enumerator.Current;
if (item == null)
{
break;
}
item.Opacity = 1;
if (!enumerator.MoveNext())
{
break;
}
}
};
dispatcherTimer = new DispatcherTimer {
Interval = TimeSpan.FromMilliseconds(30)
};
dispatcherTimer.Tick += (s, timerE) =>
{
var item = enumerator.Current;
if (item == null)
{
return;
}
item.BeginAnimation(FrameworkElement.MarginProperty, marginAnimation);
item.BeginAnimation(UIElement.OpacityProperty, opacityAnimation);
item.Opacity = 1;
if (!enumerator.MoveNext())
{
dispatcherTimer.Stop();
itemsControl.RemoveHandler(ScrollViewer.ScrollChangedEvent, scrollChangedEventHandler);
}
};
if (Timers.ContainsKey(itemsControl))
{
Timers.Remove(itemsControl);
}
Timers.Add(itemsControl, dispatcherTimer);
dispatcherTimer.Start();
itemsControl.AddHandler(ScrollViewer.ScrollChangedEvent, scrollChangedEventHandler);
}
}
//-------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// This method is used to perform the proper type casting in order to
/// call the type-safe ScrollChangedEventHandler delegate for the ScrollChangedEvent event.
/// </summary>
/// <param name="genericHandler">The handler to invoke.</param>
/// <param name="genericTarget">The current object along the event's route.</param>
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
{
ScrollChangedEventHandler handler = (ScrollChangedEventHandler)genericHandler;
handler(genericTarget, this);
}
public static void OnAutoScrollChanged(
DependencyObject obj,
DependencyPropertyChangedEventArgs propertyArgs
)
{
var listBox = obj as ListBox;
if (listBox == null)
{
return;
}
ScrollViewer scrollViewer = null;
bool justWheeled = false;
bool userInteracting = false;
bool autoScroll = true;
var collection = listBox.Items.SourceCollection as INotifyCollectionChanged;
var onScrollChanged = new ScrollChangedEventHandler(
(scrollChangedSender, scrollChangedArgs) => {
if (scrollViewer.VerticalOffset + scrollViewer.ViewportHeight == scrollViewer.ExtentHeight)
{
autoScroll = true;
}
else if (justWheeled)
{
justWheeled = false;
autoScroll = false;
}
}
);
var onSelectionChanged = new SelectionChangedEventHandler(
(selectionChangedSender, selectionChangedArgs) => {
autoScroll = false;
}
);
var onGotMouse = new MouseEventHandler(
(gotMouseSender, gotMouseArgs) => {
userInteracting = true;
autoScroll = false;
}
);
var onLostMouse = new MouseEventHandler(
(lostMouseSender, lostMouseArgs) => {
userInteracting = false;
}
);
var onPreviewMouseWheel = new MouseWheelEventHandler(
(mouseWheelSender, mouseWheelArgs) => {
justWheeled = true;
}
);
var onCollectionChangedEventHandler = new NotifyCollectionChangedEventHandler(
(collecitonChangedSender, collectionChangedArgs) => {
if (
(collectionChangedArgs.Action == NotifyCollectionChangedAction.Add) &&
autoScroll &&
!userInteracting &&
(scrollViewer != null)
)
{
scrollViewer.ScrollToBottom();
}
}
);
var hook = new Action(
() => {
if (scrollViewer == null)
{
scrollViewer = Utilities.FindDescendant <ScrollViewer>(listBox);
if (scrollViewer == null)
{
return;
}
else
{
justWheeled = false;
userInteracting = false;
autoScroll = true;
if (scrollViewer != null)
{
scrollViewer.ScrollToBottom();
scrollViewer.ScrollChanged += onScrollChanged;
}
listBox.SelectionChanged += onSelectionChanged;
listBox.GotMouseCapture += onGotMouse;
listBox.LostMouseCapture += onLostMouse;
listBox.PreviewMouseWheel += onPreviewMouseWheel;
collection.CollectionChanged += onCollectionChangedEventHandler;
}
}
}
);
var unhook = new Action(
() => {
if (scrollViewer != null)
{
scrollViewer.ScrollChanged -= onScrollChanged;
listBox.SelectionChanged -= onSelectionChanged;
listBox.GotMouseCapture -= onGotMouse;
listBox.LostMouseCapture -= onLostMouse;
listBox.PreviewMouseWheel -= onPreviewMouseWheel;
collection.CollectionChanged -= onCollectionChangedEventHandler;
scrollViewer = null;
}
}
);
var onLoaded = new RoutedEventHandler(
(loadedSender, loadedArgs) => hook()
);
var onUnloaded = new RoutedEventHandler(
(unloadedSender, unloadedArgs) => unhook()
);
if ((bool)propertyArgs.NewValue)
{
listBox.Loaded += onLoaded;
listBox.Unloaded += onUnloaded;
hook();
}
else
{
listBox.Loaded -= onLoaded;
listBox.Unloaded -= onUnloaded;
unhook();
}
}
public BindableScrollBar()
{
scrollBarValueChangedHandler = OnScrollBarValueChanged;
scrollViewerScrollChangedHandler = OnScrollViewerScrollChanged;
}
