void unBindTappedHandlers()
{
// Tapped and point handlers are always managed together
// So if one is set the other is also set.
if (TappedHandler == null)
{
return;
}
manager.InvokeOnUIThread(
() =>
{
if (TappedHandler != null)
{
manager.DisplayGrid.Tapped -= TappedHandler;
TappedHandler = null;
}
if (PointHandler != null)
{
manager.DisplayGrid.PointerPressed -= PointHandler;
PointHandler = null;
}
});
}
public ListViewBaseSelectionExtention(ListViewBase View, Rectangle RectangleInCanvas)
{
this.View = View ?? throw new ArgumentNullException(nameof(View), "Argument could not be null");
this.RectangleInCanvas = RectangleInCanvas ?? throw new ArgumentNullException(nameof(RectangleInCanvas), "Argument could not be null");
this.View.AddHandler(UIElement.PointerPressedEvent, PointerPressedHandler = new PointerEventHandler(View_RectangleDrawStart), true);
this.View.AddHandler(UIElement.PointerReleasedEvent, PointerReleasedHandler = new PointerEventHandler(View_RectangleDrawEnd), true);
this.View.AddHandler(UIElement.PointerCaptureLostEvent, PointerCaptureLostHandler = new PointerEventHandler(View_RectangleDrawEnd), true);
this.View.AddHandler(UIElement.PointerCanceledEvent, PointerCanceledHandler = new PointerEventHandler(View_RectangleDrawEnd), true);
this.View.AddHandler(UIElement.PointerMovedEvent, PointerMovedHandler = new PointerEventHandler(View_PointerMoved), true);
if (View.IsLoaded)
{
InnerScrollView = View.FindChildOfType <ScrollViewer>();
InnerScrollBar = View.FindChildOfType <ScrollBar>();
if (InnerScrollBar != null)
{
InnerScrollBar.Scroll += InnerScrollBar_Scroll;
}
}
else
{
this.View.Loaded += View_Loaded;
}
}
public PointersEvents()
{
_logPointerPressed = new PointerEventHandler((snd, e) =>
{
CreateHandler(PointerPressedEvent, "Pressed", _ptPressedHandle)(snd, e);
if (_ptPressedCapture.IsChecked ?? false)
{
((UIElement)snd).CapturePointer(e.Pointer);
}
});
this.InitializeComponent();
_logPointerEntered = new PointerEventHandler(CreateHandler(PointerEnteredEvent, "Entered", _ptEnteredHandle));
_logPointerMoved = new PointerEventHandler(CreateHandler(PointerMovedEvent, "Moved", _ptMovedHandle));
_logPointerReleased = new PointerEventHandler(CreateHandler(PointerReleasedEvent, "Released", _ptReleasedHandle));
_logPointerExited = new PointerEventHandler(CreateHandler(PointerExitedEvent, "Exited", _ptExitedHandle));
_logPointerCanceled = new PointerEventHandler(CreateHandler(PointerCanceledEvent, "Canceled", _ptCanceledHandle));
_logPointerCaptureLost = new PointerEventHandler(CreateHandler(PointerCaptureLostEvent, "CaptureLost", _ptCaptureLostHandle));
_logManipulationStarting = new ManipulationStartingEventHandler(CreateHandler(ManipulationStartingEvent, "Manip starting", _manipStartingHandle));
_logManipulationStarted = new ManipulationStartedEventHandler(CreateHandler(ManipulationStartedEvent, "Manip started", _manipStartedHandle));
_logManipulationDelta = new ManipulationDeltaEventHandler(CreateHandler(ManipulationDeltaEvent, "Manip delta", _manipDeltaHandle));
_logManipulationCompleted = new ManipulationCompletedEventHandler(CreateHandler(ManipulationCompletedEvent, "Manip completed", _manipCompletedHandle));
_logTapped = new TappedEventHandler(CreateHandler(TappedEvent, "Tapped", _gestureTappedHandle));
_logDoubleTapped = new DoubleTappedEventHandler(CreateHandler(DoubleTappedEvent, "DoubleTapped", _gestureDoubleTappedHandle));
_log.ItemsSource = _eventLog;
_pointerType.ItemsSource = Enum.GetNames(typeof(PointerDeviceType));
_pointerType.SelectedValue = PointerDeviceType.Touch.ToString();
_manipMode.ItemsSource = _manipulationModes.Keys;
_manipMode.SelectedValue = _manipulationModes.First().Key;
_isReady = true;
OnConfigChanged(null, null);
}
public RecycleBin()
{
InitializeComponent();
PointerPressedHandler = new PointerEventHandler(ListViewControl_PointerPressed);
Loaded += RecycleBin_Loaded;
Unloaded += RecycleBin_Unloaded;
}
public void AddLayerPointerDown(ELayerType eLayerType, PointerEventHandler pointerEventHandler)
{
switch (eLayerType)
{
case ELayerType.eLayer_Default:
break;
case ELayerType.eLayer_TransparentFX:
break;
case ELayerType.eLayer_IgnoreRaycast:
break;
case ELayerType.eLayer_Water:
break;
case ELayerType.eLayer_UI:
break;
case ELayerType.eLayer_Map:
OnLayerMapPointerDown += pointerEventHandler;
break;
default:
break;
}
}
public ReaderViewBase()
{
this.DefaultStyleKey = typeof(ReaderViewBase);
_gestureRecognizer = new GestureRecognizer();
_gestureRecognizer.GestureSettings = GestureSettings.ManipulationTranslateX;
_gestureRecognizer.ManipulationStarted += _gestureRecognizer_ManipulationStarted;
_gestureRecognizer.ManipulationUpdated += _gestureRecognizer_ManipulationUpdated;
_gestureRecognizer.ManipulationCompleted += _gestureRecognizer_ManipulationCompleted;
PointerWheelChangedEventHandler = new PointerEventHandler(_PointerWheelChanged);
PointerPressedEventHandler = new PointerEventHandler(_PointerPressed);
PointerMovedEventHandler = new PointerEventHandler(_PointerMoved);
PointerReleasedEventHandler = new PointerEventHandler(_PointerReleased);
PointerCanceledEventHandler = new PointerEventHandler(_PointerCanceled);
TouchTappedEventHandler = new TappedEventHandler(_TouchTapped);
TouchHoldingEventHandler = new HoldingEventHandler(_TouchHolding);
this.AddHandler(UIElement.PointerWheelChangedEvent, PointerWheelChangedEventHandler, true);
this.AddHandler(UIElement.PointerPressedEvent, PointerPressedEventHandler, true);
this.AddHandler(UIElement.PointerMovedEvent, PointerMovedEventHandler, true);
this.AddHandler(UIElement.PointerReleasedEvent, PointerReleasedEventHandler, true);
this.AddHandler(UIElement.PointerCanceledEvent, PointerCanceledEventHandler, true);
this.AddHandler(UIElement.TappedEvent, TouchTappedEventHandler, true);
this.AddHandler(UIElement.HoldingEvent, TouchHoldingEventHandler, true);
this.SizeChanged += ReaderViewBase_SizeChanged;
CreateContentDelayer = new EventDelayer();
_tempOverflowList = new List <RenderOverflow>();
CreateContentDelayer.ResetWhenDelayed = true;
CreateContentDelayer.Arrived += CreateContentWaiter_Arrived;
}
private void RegisterSetPasswordScope()
{
_revealButton = this.GetTemplateChild(RevealButtonPartName) as Button;
if (_revealButton != null)
{
var beginReveal = new PointerEventHandler(BeginReveal);
var endReveal = new PointerEventHandler(EndReveal);
// Button will handle Pressed and Released, so we have subscribe to handled events too
_revealButton.AddHandler(PointerPressedEvent, beginReveal, handledEventsToo: true);
_revealButton.AddHandler(PointerReleasedEvent, endReveal, handledEventsToo: true);
_revealButton.AddHandler(PointerExitedEvent, endReveal, handledEventsToo: true);
_revealButton.AddHandler(PointerCanceledEvent, endReveal, handledEventsToo: true);
_revealButtonSubscription.Disposable = Disposable.Create(() =>
{
_revealButton.RemoveHandler(PointerPressedEvent, beginReveal);
_revealButton.RemoveHandler(PointerReleasedEvent, endReveal);
_revealButton.RemoveHandler(PointerExitedEvent, endReveal);
_revealButton.RemoveHandler(PointerCanceledEvent, endReveal);
});
}
SetPasswordScope(true);
}
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
// Figure out what resolution and orientation we are in and respond appropriately
CheckResolutionAndViewState();
PreviousMediaSize = new Size();
myMediaElement.MediaOpened += myMediaElement_MediaOpened;
myMediaElement.MediaEnded += myMediaElement_MediaEnded;
myMediaElement.MediaFailed += myMediaElement_MediaFailed;
myMediaElement.CurrentStateChanged += myMediaElement_CurrentStateChanged;
//For support Background Audio
MediaControl.PlayPressed += MediaControl_PlayPressed;
MediaControl.PausePressed += MediaControl_PausePressed;
MediaControl.PlayPauseTogglePressed += MediaControl_PlayPauseTogglePressed;
MediaControl.StopPressed += MediaControl_StopPressed;
timelineSlider.ValueChanged += timelineSlider_ValueChanged;
PointerEventHandler pointerpressedhandler = new PointerEventHandler(slider_PointerEntered);
timelineSlider.AddHandler(Control.PointerPressedEvent, pointerpressedhandler, true);
PointerEventHandler pointerreleasedhandler = new PointerEventHandler(slider_PointerCaptureLost);
timelineSlider.AddHandler(Control.PointerCaptureLostEvent, pointerreleasedhandler, true);
}
//private void OnHuePressed(object sender, PointerRoutedEventArgs e)
//{
// this.ChangeHue(e.GetCurrentPoint(this.colorSpectrum).Position.Y);
// this.colorSpectrum.CapturePointer(e.Pointer);
// PointerEventHandler moved = null;
// moved = (s, args) =>
// {
// this.ChangeHue(args.GetCurrentPoint(this.colorSpectrum).Position.Y);
// };
// PointerEventHandler released = null;
// released = (s, args) =>
// {
// this.colorSpectrum.ReleasePointerCapture(args.Pointer);
// this.ChangeHue(args.GetCurrentPoint(this.colorSpectrum).Position.Y);
// this.colorSpectrum.PointerMoved -= moved;
// this.colorSpectrum.PointerReleased -= released;
// };
// this.colorSpectrum.PointerMoved += moved;
// this.colorSpectrum.PointerReleased += released;
//}
private void UIElement_OnPointerPressed(object sender, PointerRoutedEventArgs e)
{
var pos = e.GetCurrentPoint(sender as UIElement).Position;
var p = new Point(pos.X, pos.Y);
this.ChangeHue(p);
this.colorSpectrum.CapturePointer(e.Pointer);
PointerEventHandler moved = null;
moved = (s, args) =>
{
var posMoved = e.GetCurrentPoint(s as UIElement).Position;
var pMoved = new Point(posMoved.X, posMoved.Y);
this.ChangeHue(pMoved);
};
PointerEventHandler released = null;
released = (s, args) =>
{
this.colorSpectrum.ReleasePointerCapture(args.Pointer);
var posMoved = e.GetCurrentPoint(s as UIElement).Position;
var pMoved = new Point(posMoved.X, posMoved.Y);
this.ChangeHue(pMoved);
this.colorSpectrum.PointerMoved -= moved;
this.colorSpectrum.PointerReleased -= released;
};
this.colorSpectrum.PointerMoved += moved;
this.colorSpectrum.PointerReleased += released;
}
void bindTappedHandlers()
{
// Tapped and point handlers are always managed together
// So if one is set the other is also set.
if (TappedHandler != null)
{
return;
}
// Create the handlers
TappedHandler = (s, e) =>
{
TappedFlag = true;
e.Handled = false;
};
PointHandler = (s, e) =>
{
TappedFlag = true;
e.Handled = false;
};
// Bind them - this must happen on the UI thread
manager.InvokeOnUIThread(
() =>
{
manager.DisplayGrid.Tapped += TappedHandler;
manager.DisplayGrid.PointerPressed += PointHandler;
});
}
public PdfReader()
{
InitializeComponent();
PointerWheelChangedEventHandler = new PointerEventHandler(Page_PointerWheelChanged);
if (ApplicationData.Current.LocalSettings.Values["PdfPanelHorizontal"] is bool IsHorizontal)
{
if (IsHorizontal)
{
Flip.ItemsPanel = HorizontalPanel;
PanelToggle.IsChecked = true;
}
else
{
Flip.ItemsPanel = VerticalPanel;
PanelToggle.IsChecked = false;
}
}
else
{
Flip.ItemsPanel = VerticalPanel;
PanelToggle.IsChecked = false;
}
}
public SecureArea()
{
InitializeComponent();
PointerPressedHandler = new PointerEventHandler(SecureGridView_PointerPressed);
Loaded += SecureArea_Loaded;
Unloaded += SecureArea_Unloaded;
SecureCollection.CollectionChanged += SecureCollection_CollectionChanged;
}
protected override void OnElementChanged(ElementChangedEventArgs <Slider> e)
{
base.OnElementChanged(e);
if (e.NewElement != null)
{
if (Control == null)
{
var slider = new FormsSlider();
SetNativeControl(slider);
slider.Ready += (sender, args) =>
{
UpdateThumbColor();
UpdateThumbImage();
};
Control.Minimum = e.NewElement.Minimum;
Control.Maximum = e.NewElement.Maximum;
Control.Value = e.NewElement.Value;
Control.IsThumbToolTipEnabled = false;
slider.ValueChanged += OnNativeValueChanged;
defaultforegroundcolor = slider.Foreground;
defaultbackgroundcolor = slider.Background;
// Even when using Center/CenterAndExpand, a Slider has an oddity where it looks
// off-center in its layout by a smidge. The default templates are slightly different
// between 8.1/UWP; the 8.1 rows are 17/Auto/32 and UWP are 18/Auto/18. The value of
// the hardcoded 8.1 rows adds up to 49 (when halved is 24.5) and UWP are 36 (18). Using
// a difference of about 6 pixels to correct this oddity seems to make them both center
// more correctly.
//
// The VerticalAlignment needs to be set as well since a control would not actually be
// centered if a larger HeightRequest is set.
if (Element.VerticalOptions.Alignment == LayoutAlignment.Center && Control.Orientation == Windows.UI.Xaml.Controls.Orientation.Horizontal)
{
Control.VerticalAlignment = VerticalAlignment.Center;
slider.Margin = new Windows.UI.Xaml.Thickness(0, 7, 0, 0);
}
_pointerPressedHandler = new PointerEventHandler(OnPointerPressed);
_pointerReleasedHandler = new PointerEventHandler(OnPointerReleased);
Control.AddHandler(PointerPressedEvent, _pointerPressedHandler, true);
Control.AddHandler(PointerReleasedEvent, _pointerReleasedHandler, true);
Control.AddHandler(PointerCanceledEvent, _pointerReleasedHandler, true);
}
double stepping = Math.Min((e.NewElement.Maximum - e.NewElement.Minimum) / 1000, 1);
Control.StepFrequency = stepping;
Control.SmallChange = stepping;
UpdateFlowDirection();
UpdateSliderColors();
}
}
public static void RemoveListener(EPointerEvent eventType, PointerEventHandler listener)
{
KPointerEvent e;
if (events.TryGetValue(eventType, out e))
{
e.RemoveListener(listener);
}
}
/* AddOption() */
TextBlock AddOption(string text, int column, int row, object tag, PointerEventHandler handler)
{
var element = AddTextBlock(text, column, row, unselectedBrush);
element.Tag = tag;
element.PointerPressed += handler;
return(element);
}
void AttachPressedEvent()
{
if (_pressedHandler == null)
{
_pressedHandler = new PointerEventHandler(OnPanelPointerPressed);
}
// iOS的ScrollViewer无法AddHandler，暂时取内容，bug
(Owner.Lv.Scroll.Content as UIElement).AddHandler(PointerPressedEvent, _pressedHandler, true);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
PointerPressed += new PointerEventHandler(T_PointerPressed);
PointerReleased += new PointerEventHandler(T_PointerReleased);
PointerMoved += new PointerEventHandler(T_PointerMoved);
equation = e.Parameter as Equation;
DrawGraph();
}
private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
PointerEventHandler pointerpressedhandler = new PointerEventHandler(slider_PointerEntered);
progressbar.AddHandler(Control.PointerPressedEvent, pointerpressedhandler, true);
PointerEventHandler pointerreleasedhandler = new PointerEventHandler(slider_PointerCaptureLost);
progressbar.AddHandler(Control.PointerCaptureLostEvent, pointerreleasedhandler, true);
}
/// <inheritdoc/>
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
PointerEventHandler pointerPressedHandler = RichEditBox_OnPointerPressed;
PointerEventHandler pointerMovedHandler = RichEditBox_OnPointerMoved;
_suggestionPopup = (Popup)GetTemplateChild(PartSuggestionsPopup);
_richEditBox = (RichEditBox)GetTemplateChild(PartRichEditBox);
_suggestionsList = (ListViewBase)GetTemplateChild(PartSuggestionsList);
_suggestionsContainer = (Border)GetTemplateChild(PartSuggestionsContainer);
ConditionallyLoadElement(Header, PartHeaderContentPresenter);
ConditionallyLoadElement(Description, PartDescriptionPresenter);
if (_richEditBox != null)
{
_richEditBox.SizeChanged -= RichEditBox_SizeChanged;
_richEditBox.TextChanging -= RichEditBox_TextChanging;
_richEditBox.TextChanged -= RichEditBox_TextChanged;
_richEditBox.TextCompositionStarted -= RichEditBox_TextCompositionStarted;
_richEditBox.TextCompositionChanged -= RichEditBox_TextCompositionChanged;
_richEditBox.TextCompositionEnded -= RichEditBox_TextCompositionEnded;
_richEditBox.SelectionChanging -= RichEditBox_SelectionChanging;
_richEditBox.SelectionChanged -= RichEditBox_SelectionChanged;
_richEditBox.Paste -= RichEditBox_Paste;
_richEditBox.PreviewKeyDown -= RichEditBox_PreviewKeyDown;
_richEditBox.RemoveHandler(PointerMovedEvent, pointerMovedHandler);
_richEditBox.RemoveHandler(PointerPressedEvent, pointerPressedHandler);
_richEditBox.ProcessKeyboardAccelerators -= RichEditBox_ProcessKeyboardAccelerators;
_richEditBox.SizeChanged += RichEditBox_SizeChanged;
_richEditBox.TextChanging += RichEditBox_TextChanging;
_richEditBox.TextChanged += RichEditBox_TextChanged;
_richEditBox.TextCompositionStarted += RichEditBox_TextCompositionStarted;
_richEditBox.TextCompositionChanged += RichEditBox_TextCompositionChanged;
_richEditBox.TextCompositionEnded += RichEditBox_TextCompositionEnded;
_richEditBox.SelectionChanging += RichEditBox_SelectionChanging;
_richEditBox.SelectionChanged += RichEditBox_SelectionChanged;
_richEditBox.Paste += RichEditBox_Paste;
_richEditBox.PreviewKeyDown += RichEditBox_PreviewKeyDown;
_richEditBox.AddHandler(PointerMovedEvent, pointerMovedHandler, true);
_richEditBox.AddHandler(PointerPressedEvent, pointerPressedHandler, true);
_richEditBox.ProcessKeyboardAccelerators += RichEditBox_ProcessKeyboardAccelerators;
}
if (_suggestionsList != null)
{
_suggestionsList.ItemClick -= SuggestionsList_ItemClick;
_suggestionsList.SizeChanged -= SuggestionsList_SizeChanged;
_suggestionsList.GotFocus -= SuggestionList_GotFocus;
_suggestionsList.ItemClick += SuggestionsList_ItemClick;
_suggestionsList.SizeChanged += SuggestionsList_SizeChanged;
_suggestionsList.GotFocus += SuggestionList_GotFocus;
}
}
public BigbangView()
{
this.DefaultStyleKey = typeof(BigbangView);
this.Loaded += BigbangView_Loaded;
this.Unloaded += BigbangView_Unloaded;
this.SelectionChanged += BigbangView_SelectionChanged;
PointerPressedHandler = new PointerEventHandler(_PointerPressed);
PointerReleasedHandler = new PointerEventHandler(_PointerReleased);
PointerMovedHandler = new PointerEventHandler(_PointerMoved);
}
protected override void OnPointerReleased(PointerRoutedEventArgs e)
{
base.OnPointerReleased(e);
PointerEventHandler handler = CalendarDayButtonMouseUp;
if (null != handler)
{
handler(this, e);
}
}
private void button7_Click(object sender, RoutedEventArgs e)
{
ActionLineLink a = new ActionLineLink(this.Client);
//a.at_PointerPressed += new PointerEventHandler(t_PointerPressed);
//a.PointerReleased += new PointerEventHandler(t_PointerReleased);
//a.PointerMoved += new PointerEventHandler(t_PointerMoved);
//a.ParentPanel = Desktop;
//PointerPressed += new PointerEventHandler(a.at_PointerPressed);
//PointerReleased += new PointerEventHandler(a.at_PointerReleased);
PointerMoved += new PointerEventHandler(a.at_PointerMoved);
}
public static Task <Point> DragAsync(UIElement control, PointerRoutedEventArgs origE, IDragAndDropProgress progress = null)
{
TaskCompletionSource <Point> taskCompletionSource = new TaskCompletionSource <Point>();
UIElement mousePositionWindow = Window.Current.Content;
GeneralTransform gt = Window.Current.Content.TransformToVisual(control);
UIElement root = Window.Current.Content;
Point pointMouseDown = gt.TransformPoint(origE.GetCurrentPoint(mousePositionWindow).Position);
PointerEventHandler pointerMovedHandler = null;
PointerEventHandler pointerReleasedHandler = null;
pointerMovedHandler = (object s, PointerRoutedEventArgs e) =>
{
Point pt = e.GetCurrentPoint(mousePositionWindow).Position;
pt = gt.TransformPoint(pt);
Point delta = new Point
{
X = pt.X - pointMouseDown.X,
Y = pt.Y - pointMouseDown.Y
};
if (!(control.RenderTransform is CompositeTransform compositeTransform))
{
compositeTransform = new CompositeTransform();
control.RenderTransform = compositeTransform;
}
compositeTransform.TranslateX += delta.X;
compositeTransform.TranslateY += delta.Y;
control.RenderTransform = compositeTransform;
pointMouseDown = pt;
if (progress != null)
{
progress.Report(pt);
}
};
pointerReleasedHandler = (object s, PointerRoutedEventArgs e) =>
{
UIElement localControl = (UIElement)s;
localControl.PointerMoved -= pointerMovedHandler;
localControl.PointerReleased -= pointerReleasedHandler;
localControl.ReleasePointerCapture(origE.Pointer);
Point exitPoint = e.GetCurrentPoint(mousePositionWindow).Position;
taskCompletionSource.SetResult(exitPoint);
};
control.CapturePointer(origE.Pointer);
control.PointerMoved += pointerMovedHandler;
control.PointerReleased += pointerReleasedHandler;
return(taskCompletionSource.Task);
}
private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
timelineSlider.ValueChanged += timelineSlider_ValueChanged;
PointerEventHandler pointerpressedhandler = new PointerEventHandler(timelineSlider_PointerEntered);
timelineSlider.AddHandler(Control.PointerPressedEvent, pointerpressedhandler, true);
PointerEventHandler pointerreleasedhandler = new PointerEventHandler(timelineSlider_PointerCaptureLost);
timelineSlider.AddHandler(Control.PointerCaptureLostEvent, pointerreleasedhandler, true);
}
public IncomePivotViewModel(BookKeepingContext bookKeepingContext, PointerEventHandler pointerEventHandler, EventHandler <DataGridColumnEventArgs> DataGrid_ColumnSort_Handler)
{
using (var context = new BookKeepingContext())
{
categories = context.IncomeDBSet.Select(x => x.IncomeCategory).Distinct().ToList();
}
foreach (var category in categories)
{
Add(new IncomeDataGridModel {
PivotHeader = category, DataGrid = datagridFactory.DatagridFactory_Make(category, 0, bookKeepingContext, pointerEventHandler, DataGrid_ColumnSort_Handler)
});
}
}
public MainPage()
{
this.InitializeComponent();
// Gets the default instance of AdaptiveSourceManager which manages Smooth Streaming media sources.
adaptiveSourceManager = AdaptiveSourceManager.GetDefault();
//Property sets are used to indicate what properties of an item or folder should be loaded when binding to an existing item or folder or when loading an item or folder's properties.
// Sets property key value to AdaptiveSourceManager default instance.
// {A5CE1DE8-1D00-427B-ACEF-FB9A3C93DE2D}" must be hardcoded.
propertySet["{A5CE1DE8-1D00-427B-ACEF-FB9A3C93DE2D}"] = adaptiveSourceManager;
//The MediaElement control does not support Smooth Streaming content out-of-box. To enable the Smooth Streaming support,
//you must register the Smooth Streaming byte-stream handler by file name extension and MIME type. To register, you use the
//MediaExtensionManager.RegisterByteStremHandler method of the Windows.Media namespace.
// Registers Smooth Streaming byte-stream handler for ".ism" extension and,
// "text/xml" and "application/vnd.ms-ss" mime-types and pass the propertyset.
// http://*.ism/manifest URI resources will be resolved by Byte-stream handler.
extensions.RegisterByteStreamHandler(
"Microsoft.Media.AdaptiveStreaming.SmoothByteStreamHandler",
".ism",
"text/xml",
propertySet);
extensions.RegisterByteStreamHandler(
"Microsoft.Media.AdaptiveStreaming.SmoothByteStreamHandler",
".ism",
"application/vnd.ms-sstr+xml",
propertySet);
//The source resolver takes a URL or byte stream and creates the appropriate media source for that content.
//The source resolver is the standard way for the applications to create media sources.
//subscribes to the adaptive source open event
adaptiveSourceManager.AdaptiveSourceOpenedEvent += new AdaptiveSourceOpenedEventHandler(mediaElement_AdaptiveSourceOpened);
//adaptiveSourceManager.AdaptiveSourceStatusUpdated += new AdaptiveSourceClosedEventHandler(mediaElement_AdaptiveSourceStatusUpdated);
adaptiveSourceManager.AdaptiveSourceStatusUpdatedEvent += new AdaptiveSourceStatusUpdatedEventHandler(mediaElement_AdaptiveSourceStatusUpdated);
adaptiveSourceManager.AdaptiveSourceStatusUpdatedEvent += adaptiveSourceManager_AdaptiveSourceStatusUpdatedEvent;
//adaptiveSourceManager.AdaptiveSourceClosedEvent += new AdaptiveSourceClosedEventArgs(mediaElement_AdaptiveSourceClosed);
//required to subscribe to the media element events
mediaElement.MediaOpened += MediaOpened;
mediaElement.MediaEnded += MediaEnded;
mediaElement.MediaFailed += MediaFailed;
//code for the media player slider
_dispatcher = Window.Current.Dispatcher;
PointerEventHandler pointerpressedhandler = new PointerEventHandler(sliderProgress_PointerPressed);
//sliderProgress.AddHandler(Control.PointerPressedEvent, pointerpressedhandler, true);
}
public ControllerOverlayPage()
{
this.InitializeComponent();
var app = (App.Current as App);
this.resources = new ResourceLoader();
this.msgService = new UWPMessageService(this.Dispatcher);
this.settings = app.Settings;
this.keyDownHandler = new KeyEventHandler(handleKeyDown);
this.pointerHandler = new PointerEventHandler(handlePointerPressed);
this.pointerMoveHandler = new PointerEventHandler(handlePointerMoved);
this.pointerReleaseHandler = new TypedEventHandler <CoreWindow, PointerEventArgs>(handlePointerReleased);
this.paneOpenHandler = new CallbackDelegate(handlePaneOpening);
this.manualSnapshotButton.DataContext = this.settings;
this.customizeVPadButton.DataContext = this.settings;
this.controllerScaleSlider.DataContext = this.settings;
this.controllerOpacitySlider.DataContext = this.settings;
this.controllerStyleCombobox.DataContext = this.settings;
this.fpsPanel.DataContext = this.settings;
if (app.MainPage == null)
{
app.MainPageCreated += (p) =>
{
this.manager = EmulatorManager.Current;
this.manager.MovedToForeground();
this.manager.Emulator.RenderComponent.FrameRateChanged += this.UpdateFPS;
SetSaveSlotContext(this.manager);
RegisterEvents(app);
};
}
else
{
this.manager = EmulatorManager.Current;
this.manager.MovedToForeground();
this.manager.Emulator.RenderComponent.FrameRateChanged += this.UpdateFPS;
RegisterEvents(app);
}
this.moveBarUp.Completed += MoveBarUp_Completed;
this.moveBarDown.Completed += MoveBarDown_Completed;
this.moveLayoutBarDown.Completed += MoveLayoutBarDown_Completed;
this.moveLayoutBarUp.Completed += MoveLayoutBarUp_Completed;
this.moveLayoutBarFurtherDown.Completed += MoveLayoutBarFurtherDown_Completed;
this.moveLayoutBarHalfUp.Completed += MoveLayoutBarHalfUp_Completed;
this.moveLayoutBarCompletelyUp.Completed += MoveLayoutBarCompletelyUp_Completed;
this.moveLayoutBarCompletelyDown.Completed += MoveLayoutBarCompletelyDown_Completed;
customizationPanel.DataContext = this;
}
public StorySliderUc()
{
InitializeComponent();
PointerEntered += StorySliderUcPointerEntered;
PointerReleased += StorySliderUcPointerReleased;
var pointerCaptureLostHandler = new PointerEventHandler(OnSliderCaptureLost);
XLider.AddHandler(PointerCaptureLostEvent, pointerCaptureLostHandler, true);
var keyUpEventHandler = new KeyEventHandler(OnKeyUp);
XLider.AddHandler(KeyUpEvent, keyUpEventHandler, true);
}
public Task <Point> DragAsync(TutorialControl control, PointerRoutedEventArgs origE, IDragAndDropProgress progress = null)
{
TaskCompletionSource <Point> taskCompletionSource = new TaskCompletionSource <Point>();
UIElement mousePositionWindow = Window.Current.Content;
Point pointMouseDown = origE.GetCurrentPoint(mousePositionWindow).Position;
PointerEventHandler pointerMovedHandler = null;
PointerEventHandler pointerReleasedHandler = null;
pointerMovedHandler = (Object s, PointerRoutedEventArgs e) =>
{
Point pt = e.GetCurrentPoint(mousePositionWindow).Position;
Point delta = new Point();
delta.X = pt.X - pointMouseDown.X;
delta.Y = pt.Y - pointMouseDown.Y;
if (progress != null)
{
progress.Report(pt);
}
this.TranlateReletive(delta);
pointMouseDown = pt;
};
pointerReleasedHandler = (Object s, PointerRoutedEventArgs e) =>
{
TutorialControl localControl = (TutorialControl)s;
localControl.PointerMoved -= pointerMovedHandler;
localControl.PointerReleased -= pointerReleasedHandler;
localControl.ReleasePointerCapture(origE.Pointer);
Point exitPoint = e.GetCurrentPoint(mousePositionWindow).Position;
if (progress != null)
{
progress.PointerUp(exitPoint);
}
taskCompletionSource.SetResult(exitPoint);
};
control.CapturePointer(origE.Pointer);
control.PointerMoved += pointerMovedHandler;
control.PointerReleased += pointerReleasedHandler;
return(taskCompletionSource.Task);
}
private Task whenImageClicked(Image image)
{
var tcs = new TaskCompletionSource <bool>();
PointerEventHandler handler = null;
handler = (s, e) =>
{
tcs.TrySetResult(true);
image.PointerPressed -= handler;
};
image.PointerPressed += handler;
return(tcs.Task);
}
int _zIndexOfTouchFields = Basics.Infinity(); // The touch fields always have to stay on top
#endregion Fields
#region Constructors
// --- Methods of the class ---
/// <summary>The constructor</summary>
/// <param name="gameBoard">The GameBoard to consider as the basis</param>
public GameBoard(Kalaha.Model.GameBoard gameBoard,
Canvas gameBoardCanvas,
PointerEventHandler PointerEnteredHouse,
PointerEventHandler PointerExitedHouse,
RoutedEventHandler TouchFieldSelected)
{
_gameBoard = gameBoard;
_canvasToPaintOn = gameBoardCanvas;
KalahPosition kalahPosition;
kalahPosition = GetKalahPosition();
CreatePitsAndSetCoordinatesAndSizes(kalahPosition);
CreateImagesAndTouchFieldsAndNumFieldsOfHouses(PointerEnteredHouse, PointerExitedHouse, TouchFieldSelected);
CreateImagesAndNumFieldsOfKalahs();
}
private static void AttachEvent(RoutedEvent e, PointerEventHandler Handler)
{
foreach (var item in Panels)
{
if (e == UIElement.PointerPressedEvent)
item.PointerPressed += Handler;
else if (e == UIElement.PointerEnteredEvent)
item.PointerEntered += Handler;
else if (e == UIElement.PointerExitedEvent)
item.PointerExited += Handler;
}
foreach (var item in NonPanels)
{
item.AddHandler(e, Handler, true);
}
}
protected override void OnEdgeLabelUpdated()
{
if (EdgeLabelControl is Control)
{
var ctrl = (Control)EdgeLabelControl;
#if WPF
MouseButtonEventHandler func = (sender, args) => OnLabelMouseDown(args, Keyboard.Modifiers);
ctrl.MouseDown -= func;
ctrl.MouseDown += func;
#elif METRO
PointerEventHandler func = (sender, args) => OnLabelMouseDown(args, null);
ctrl.PointerPressed -= func;
ctrl.PointerPressed += func;
#endif
}
}
private static void DetachEvent(RoutedEvent e, PointerEventHandler Handler)
{
foreach (var item in Panels)
{
if (e == UIElement.PointerPressedEvent)
item.PointerPressed -= Handler;
else if (e == UIElement.PointerEnteredEvent)
item.PointerEntered -= Handler;
else if (e == UIElement.PointerExitedEvent)
item.PointerExited -= Handler;
}
foreach (var item in NonPanels)
{
item.RemoveHandler(e, Handler);
}
}
public HoldListener(UIElement target)
{
_pointerPressedHandler = new PointerEventHandler(Target_PointerPressed);
_pointerMovedHandler = new PointerEventHandler(Target_PointerMoved);
_pointerReleasedHandler = new PointerEventHandler(Target_PointerReleased);
_pointerCanceledHandler = new PointerEventHandler(Target_PointerCanceled);
_pointerCaptureLostHandler = new PointerEventHandler(Target_PointerCaptureLost);
Target = target;
Target.AddHandler(UIElement.PointerPressedEvent, _pointerPressedHandler, true);
Target.Tapped += Target_Tapped;
_timer = new DispatcherTimer
{
Interval = TimeSpan.FromSeconds(0.7)
};
_timer.Tick += Timer_Tick;
}
public static void AddOnDoubleTapped(this Feature element, PointerEventHandler handler)
{
element.PointerPressed += element_PointerPressed;
List<PointerEventHandler> handlers = element.GetValue(DoubleTappedHandlersProperty) as List<PointerEventHandler>;
if (handlers == null)
{
handlers = new List<PointerEventHandler>();
element.SetValue(DoubleTappedHandlersProperty , handlers);
}
handlers.Add(handler);
}
public PivotSwipeLockBehavior()
{
pivotItemPointerPressedHandler = PivotItem_OnPointerPressed;
pivotItemPointerReleasedHandler = PivotItem_OnPointerReleased;
}
public void SetupItems()
{
// initialize
ClearPreviousRecords();
// setup root button
rootButtonVisualContainer.Children.Clear();
rootButtonVisualContainer.Children.Add(Configuration.ButtonVisual);
// setup command
if (Configuration.Command != null)
{
rootButtonCommand = (s, e) => Configuration.Command.Execute(null);
rootButton.PointerPressed += rootButtonCommand;
}
else
{
rootButton.PointerPressed += ToggleRootButtonStatus;
}
// setup each items
var count = Configuration.SubButtonConfigurations.Count();
innerRing.Children.RemoveExceptTypes(typeof(Path));
Configuration.SubButtonConfigurations.Each((item, index) =>
{
// compute coordinates
var innerRingItem = item.ButtonVisual;
double innerRingTheta = ComputeThetaOfQuadrantPart(index, count);
double innerRingX = innerRingWidth - innerRingRadius * Math.Cos(innerRingTheta);
double innerRingY = innerRingHeight - innerRingRadius * Math.Sin(innerRingTheta);
// wrap with container to expand hitbox
var innerRingItemContainer = WrapItemWithContainer(item, innerRingRibbonRadius);
// add to inner ring canvas
Canvas.SetLeft(innerRingItemContainer, innerRingX - innerRingRibbonRadius);
Canvas.SetTop(innerRingItemContainer, innerRingY - innerRingRibbonRadius);
innerRing.Children.Add(innerRingItemContainer);
// setup outer ring
if (item.SubButtonConfigurations.Any())
{
// wrap sub items
var wrapedSubItems = (from subItem in item.SubButtonConfigurations select WrapItemWithContainer(subItem, outerRingRibbonRadius)).ToList();
// create link on inner ring item
innerRingItemContainer.PointerPressed += async (s, e) =>
{
// play blink animation
await RingButtonPressedHandler(s, e);
// setup sub items
SetupSubItems(wrapedSubItems);
};
}
else
{
// setup animation
innerRingItemContainer.PointerPressed += BlinkAndCollapse;
// setup command
if(item.Command!=null)
{
innerRingItemContainer.PointerPressed += (s,e)=> item.Command.Execute(null);
}
}
});
}
//On MainPage Loaded
private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
Volume_text.Text = Slider_ValueChanged.Value.ToString();
TimelineSlider.ValueChanged += timelineSlider_ValueChanged;
PointerEventHandler pointerpressedhandler = new PointerEventHandler(slider_PointerEntered);
TimelineSlider.AddHandler(Control.PointerPressedEvent, pointerpressedhandler, true);
PointerEventHandler pointerreleasedhandler = new PointerEventHandler(slider_PointerCaptureLost);
TimelineSlider.AddHandler(Control.PointerCaptureLostEvent, pointerreleasedhandler, true);
}
/// <summary>
/// Creates the houses (various versions), (invisible) buttons ("touch fields"), and number fields of the houses
/// and paints them onto the canvas.
/// </summary>
/// <param>Callback methods that are to be called when an according event occurs</param>
private void CreateImagesAndTouchFieldsAndNumFieldsOfHouses(PointerEventHandler PointerEnteredHouse,
PointerEventHandler PointerExitedHouse,
RoutedEventHandler TouchFieldSelected)
{
int numHouses = GetNumOfHousesPerPlayer();
// Paint the pits of both players.
// Loop over the number of pits per player:
for (int houseIndex = 0; houseIndex < numHouses; ++houseIndex)
{
// Loop over south and north
for (int positionIndex = 0; positionIndex < 2; ++positionIndex)
{
// Select the index to consider for the rest of the loop (either southern or northern hemisphere):
int curHouseIndex = houseIndex + (positionIndex * (numHouses + 1));
Player curPlayer = (positionIndex == 0 ? Presenter.I.GetSouthernPlayer() : Presenter.I.GetNorthernPlayer());
// -------- Images --------
// Loop over the three image types we have for houses:
for (int imageIndex = 0; imageIndex < 3; ++imageIndex)
{
string houseFileName = "";
Pit.ImageType imageType = Pit.ImageType.Normal;
Visibility visibility = Visibility.Collapsed;
switch (imageIndex)
{
case (int)Pit.ImageType.Normal: houseFileName = KalahaResources.I.GetNormalHouseFileName();
imageType = Pit.ImageType.Normal;
visibility = Visibility.Visible;
break;
case (int)Pit.ImageType.Highlighted: houseFileName = KalahaResources.I.GetHighlightedHouseFileName();
imageType = Pit.ImageType.Highlighted;
break;
case (int)Pit.ImageType.Selected: houseFileName = KalahaResources.I.GetSelectedHouseFileName();
imageType = Pit.ImageType.Selected;
break;
}
// Create a new southern normal pit for the given pitIndex:
Image houseImage = new Image()
{
Source = new BitmapImage(new Uri("ms-appx:/" + ThemeHandler.I.GetCurrentThemesDir() + "/" + houseFileName)),
HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch,
VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Stretch,
Width = PSTScreen.I.ToScreenX(_pit[curHouseIndex].GetWidth()),
Height = PSTScreen.I.ToScreenY(_pit[curHouseIndex].GetHeight()),
Visibility = visibility
};
Canvas.SetLeft(houseImage, PSTScreen.I.ToScreenX(GetTopLeftCornerOfPit(curPlayer, houseIndex).X));
Canvas.SetTop(houseImage, PSTScreen.I.ToScreenY(GetTopLeftCornerOfPit(curPlayer, houseIndex).Y));
Canvas.SetZIndex(houseImage, _zIndexOfHouse);
// Having created the image, inform the current pit about it:
_pit[curHouseIndex].SetImage(houseImage, imageType);
// Add the pit image to the canvas:
_canvasToPaintOn.Children.Add(houseImage);
} // for imageIndex
// -------- Touch Fields --------
// Create an invisible button ("touch field") for the currently considered southern house:
Button houseTouchField = new Button()
{
HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch,
VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Stretch,
Width = PSTScreen.I.ToScreenX(_pit[curHouseIndex].GetWidth()),
Height = PSTScreen.I.ToScreenY(_pit[curHouseIndex].GetHeight()),
// Equivalent to setting the Style "{StaticResource FieldButtonStyle}" in XAML:
Style = Application.Current.Resources["FieldButtonStyle"] as Style,
Content = curHouseIndex.ToString()
};
// Set event handlers:
houseTouchField.Click += TouchFieldSelected;
houseTouchField.PointerEntered += PointerEnteredHouse;
houseTouchField.PointerExited += PointerExitedHouse;
Canvas.SetLeft(houseTouchField, PSTScreen.I.ToScreenX(GetTopLeftCornerOfPit(curPlayer, houseIndex).X));
Canvas.SetTop(houseTouchField, PSTScreen.I.ToScreenY(GetTopLeftCornerOfPit(curPlayer, houseIndex).Y));
Canvas.SetZIndex(houseTouchField, _zIndexOfTouchFields);
// Having created the touch field, inform the current pit about it:
_pit[curHouseIndex].SetTouchField(houseTouchField);
// Add the touch field to the canvas:
_canvasToPaintOn.Children.Add(houseTouchField);
// -------- Number Fields --------
// Create a new number field for the given houseIndex:
TextBlock numberField = new TextBlock()
{
// Equivalent to setting the Style "{StaticResource SeedNumberStyle}" in XAML:
Style = Application.Current.Resources["SeedNumberStyle"] as Style,
Visibility = (Settings.I.NumberFieldsShallBeShown() ? Visibility.Visible : Visibility.Collapsed)
};
// Define the angle of the displayed number:
numberField.RenderTransformOrigin = new Point(0.5,0.5); // Rotate around the center
RotateTransform myRotateTransform = new RotateTransform();
// Put the number upside down if we are in Tablet mode and the player is North:
myRotateTransform.Angle = ((Presenter.I.TabletModeIsActive() && (curPlayer.GetPosition() == Player.Position.North)) ? 180 : 0);
numberField.RenderTransform = myRotateTransform;
// Having created the number field, inform the current pit about it:
_pit[curHouseIndex].SetNumberField(numberField);
// Add the touch field to the canvas:
_canvasToPaintOn.Children.Add(numberField);
} // for positionIndex
} // for pitIndex
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="T:WinRTXamlToolkit.Controls.Calendar" /> class.
/// </summary>
public Calendar()
{
DefaultStyleKey = typeof(Calendar);
UpdateDisplayDate(this, this.DisplayDate, DateTime.MinValue);
GotFocus += new RoutedEventHandler(Calendar_GotFocus);
LostFocus += new RoutedEventHandler(Calendar_LostFocus);
IsEnabledChanged += new DependencyPropertyChangedEventHandler(OnIsEnabledChanged);
PointerReleased += new PointerEventHandler(Calendar_PointerReleased);
BlackoutDates = new CalendarBlackoutDatesCollection(this);
SelectedDates = new SelectedDatesCollection(this);
RemovedItems = new List<object>();
}
/// <summary>
/// Initializes the gameboard and other objects when a new game is started.
/// </summary>
public void InitializeAtGameStart(Canvas gameBoardCanvas,
PointerEventHandler PointerEnteredHouse,
PointerEventHandler PointerExitedHouse,
RoutedEventHandler TouchFieldSelected)
{
GameStatus gameStatus = GetGameStatus();
if ((gameStatus != GameStatus.StartedNew) && (gameStatus != GameStatus.Continued))
{
throw new PSTException("Presenter.InitializeAtGameStart: Unexpected game status: " + GetGameStatus() + ".");
}
if (gameStatus == GameStatus.StartedNew)
{
// Define the size of the game board:
_modelGameBoard.SetSize(Settings.I.GetNumberOfHousesPerPlayer(), Settings.I.GetNumberOfSeedsPerHouse());
// Set the current player:
_currentPlayer = _playerWhoIsFirst;
// We set this to true initially in order to avoid an initial toggle in "DecideWhoIsNext()":
_playerMayMoveAgain = true;
// Initialize the undo manager:
_undoManager.Inititalize();
}
// Create a new "ModelView" GameBoard:
_viewModelGameBoard = new Kalaha.View.Model.GameBoard(_modelGameBoard, gameBoardCanvas,
PointerEnteredHouse,
PointerExitedHouse,
TouchFieldSelected);
switch(gameStatus)
{
case GameStatus.StartedNew:
// In a new game we start with the initial number of seeds:
_viewModelGameBoard.InitializeNumbersOfSeeds();
break;
case GameStatus.Continued:
// An existing game is to be continued, so we copy the number of seeds per pit from the "Model" GameBoard to the "ViewModel" GameBoard:
_viewModelGameBoard.CopySeedNumbersOfGameBoard();
break;
}
}
