예제 #1
0
        void SetupRecoverDialogGestures()
        {
            var gestureListener = GestureService.GetGestureListener(RecoverDialog);

            gestureListener.DragDelta     += RecoverDiag_DragDelta;
            gestureListener.DragCompleted += RecoverDiag_DragEnd;
        }
        public static INavigationService AttachGestures(this INavigationService service, Window window, params Gesture[] gestures)
        {
            var service2        = service as INavigationService2;
            var gesture_service = GestureService.GetForCurrentView(window.CoreWindow);

            foreach (var gesture in gestures)
            {
                switch (gesture)
                {
                case Gesture.Back:
                    AddOnlyOne(gesture_service.BackRequestedCallbacks, service2.FrameFacade.Id, async() => await service.GoBackAsync());
                    break;

                case Gesture.Forward:
                    AddOnlyOne(gesture_service.ForwardRequestedCallbacks, service2.FrameFacade.Id, async() => await service.GoForwardAsync());
                    break;

                case Gesture.Refresh:
                    AddOnlyOne(gesture_service.RefreshRequestedCallbacks, service2.FrameFacade.Id, async() => await service.RefreshAsync());
                    break;
                }
            }
            return(service);

            void AddOnlyOne(Dictionary <string, Action> dictionary, string id, Action action)
            {
                dictionary.Remove(id);
                dictionary.Add(id, action);
            }
        }
    public MyControl()
    {
        InitializeComponent();
        var gl = GestureService.GetGestureListener(asd);

        gl.Flick += new EventHandler <FlickGestureEventArgs>(GestureListener_Flick);
    }
예제 #4
0
 public PrismApplicationBase()
 {
     InternalInitialize();
     (this as IPrismApplicationEvents).WindowCreated += (s, e) =>
     {
         GestureService.SetupForCurrentView(e.Window.CoreWindow);
     };
     base.Suspending += async(s, e) =>
     {
         if (ApplicationData.Current.LocalSettings.Values.ContainsKey("Suspend_Data"))
         {
             ApplicationData.Current.LocalSettings.Values.Remove("Suspend_Data");
         }
         ApplicationData.Current.LocalSettings.Values.Add("Suspend_Data", DateTime.Now.ToString());
         var deferral = e.SuspendingOperation.GetDeferral();
         try
         {
             OnSuspending();
             await OnSuspendingAsync();
         }
         finally
         {
             deferral.Complete();
         }
     };
     base.Resuming += async(s, e) =>
     {
         await InternalStartAsync(new StartArgs(ResumeArgs.Create(ApplicationExecutionState.Suspended), StartKinds.Resume));
     };
 }
        public static INavigationService Create(Frame frame, CoreWindow window, params Gestures[] gestures)
        {
            frame = frame ?? new Frame();
            var gesture_service    = GestureService.GetForCurrentView(window);
            var navigation_service = new NavigationService(frame);

            foreach (var gesture in gestures)
            {
                switch (gesture)
                {
                case Gestures.Back:
                    gesture_service.BackRequested += async(s, e) => await navigation_service.GoBackAsync();

                    break;

                case Gestures.Forward:
                    gesture_service.ForwardRequested += async(s, e) => await navigation_service.GoForwardAsync();

                    break;

                case Gestures.Refresh:
                    gesture_service.RefreshRequested += async(s, e) => await navigation_service.RefreshAsync();

                    break;
                }
            }
            return(navigation_service);
        }
예제 #6
0
        static int setSwipeListener(int L)
        {
            if (!LuaCommon.CheckAndShowArgsError(L, LConst.UserData, LConst.Function))
            {
                return(0);
            }

            Object control   = Lua.Lua_touserdata(L, 2);
            int    callbackF = Lua.LuaL_ref(L, Lua._LUA_REGISTRYINDEX);

            if (control != null && callbackF != 0)
            {
                var pi = control.GetType().GetProperty("View_");
                var fe = pi.GetValue(control, null);

                if (EventsList.Any(c => (c.FE == fe as FrameworkElement) && c.EventsName.Equals("setSwipeListener")))
                {
                    ClearLastUselessEvents(fe as FrameworkElement, "setSwipeListener");
                }

                var lisenter = GestureService.GetGestureListener(fe as FrameworkElement);
                EventHandler <Microsoft.Phone.Controls.FlickGestureEventArgs> FlickGestureHandler = null;
                lisenter.Flick += FlickGestureHandler = (s, e) =>
                {
                    Dictionary <string, object> dict = new Dictionary <string, object>();
                    string value = string.Empty;
                    if (e.Direction == Orientation.Horizontal)
                    {
                        if (e.HorizontalVelocity > 0)
                        {
                            value = "right";
                        }
                        else
                        {
                            value = "left";
                        }
                    }
                    else if (e.Direction == Orientation.Vertical)
                    {
                        if (e.VerticalVelocity > 0)
                        {
                            value = "down";
                        }
                        else
                        {
                            value = "up";
                        }
                    }
                    dict.Add("direction", value);

                    LuaManager.GetLuaManager(L).ExecuteCallBackFunctionWithAnyParams(callbackF, dict, control);
                };

                EventsList.Add(new GestureEventRegisterInfo()
                {
                    FE = fe as FrameworkElement, EventsName = "setSwipeListener", FlickGestureEventHandler = FlickGestureHandler
                });
            }
            return(0);
        }
예제 #7
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            _propertyInfos = typeof(Survelem).GetProperties().ToList();

            gestureListener        = GestureService.GetGestureListener(this);
            gestureListener.Flick += this.GlFlick;

            if (e.NavigationMode == NavigationMode.Back)
            {
                return;
            }



            cmb1.SelectionChanged += cmb1_SelectionChanged;

            _questions = StateService.CurrentQuestionGroup.Questions;


            if (_questions == null)
            {
                return;
            }

            _currentQuestion = _questions.First();

            tb1ForCmb1.TextChanged += tb1ForCmb1_TextChanged;

            await LoadQuestionData();
        }
예제 #8
0
        void CreateGameGrid()
        {
            currentTime = new TimeSpan(0, 0, 0);
            //Settings.Grid.Clear();

            gameGrid                    = new GameGrid();
            gameGrid.NextLevel         += new EventHandler(gameGrid_NextLevel);
            gameGrid.EndGame           += new EventHandler(gameGrid_EndGame);
            gameGrid.ManipulationDelta += new EventHandler <ManipulationDeltaEventArgs>(gameGrid_ManipulationDelta);
            var gl = GestureService.GetGestureListener(gameGrid);

            //gl.PinchStarted += new EventHandler<PinchStartedGestureEventArgs>(gl_PinchStarted);
            //gl.PinchDelta += new EventHandler<PinchGestureEventArgs>(gl_PinchDelta);
            gl.DoubleTap            += new EventHandler <Microsoft.Phone.Controls.GestureEventArgs>(gl_DoubleTap);
            scale                    = new ScaleTransform();
            scale.ScaleX             = 1.0;
            scale.ScaleY             = 1.0;
            gameGrid.RenderTransform = scale;

            ContentPanel.Children.Add(gameGrid);

            tbTime.Text = String.Format("{0:D2}:{1:D2}", Settings.GameTime.Minutes, Settings.GameTime.Seconds);
            myDispatcherTimer.Interval = new TimeSpan(0, 0, 1);
            myDispatcherTimer.Tick    += new EventHandler(Each_Tick);
            myDispatcherTimer.Start();
        }
예제 #9
0
        /// <summary>
        /// Gets all the template parts and initializes the corresponding state.
        /// </summary>
        public override void OnApplyTemplate()
        {
            if (_track != null)
            {
                _track.SizeChanged -= SizeChangedHandler;
            }
            if (_thumb != null)
            {
                _thumb.SizeChanged -= SizeChangedHandler;
            }
            base.OnApplyTemplate();
            _root = GetTemplateChild(SwitchRootPart) as Grid;
            UIElement background = GetTemplateChild(SwitchBackgroundPart) as UIElement;

            _backgroundTranslation = background == null ? null : background.RenderTransform as TranslateTransform;
            _track            = GetTemplateChild(SwitchTrackPart) as Grid;
            _thumb            = GetTemplateChild(SwitchThumbPart) as Border;
            _thumbTranslation = _thumb == null ? null : _thumb.RenderTransform as TranslateTransform;
            if (_root != null && _track != null && _thumb != null && (_backgroundTranslation != null || _thumbTranslation != null))
            {
                GestureListener gestureListener = GestureService.GetGestureListener(_root);
                gestureListener.DragStarted   += DragStartedHandler;
                gestureListener.DragDelta     += DragDeltaHandler;
                gestureListener.DragCompleted += DragCompletedHandler;
                _track.SizeChanged            += SizeChangedHandler;
                _thumb.SizeChanged            += SizeChangedHandler;
            }
            ChangeVisualState(false);
        }
예제 #10
0
        public ShellPage(IDialogService dialogService, IDataService dataService, IEventAggregator eventAggregator)
        {
            InitializeComponent();

            if (win.ApplicationModel.DesignMode.DesignModeEnabled)
            {
                return;
            }

            _dialogService = dialogService;
            _dataService   = dataService;

            _gestureService = GestureService.GetForCurrentView();
            _gestureService.MenuRequested   += (s, e) => ShellView.IsPaneOpen = true;
            _gestureService.SearchRequested += (s, e) =>
            {
                ShellView.IsPaneOpen = true;
                ShellView.AutoSuggestBox?.Focus(FocusState.Programmatic);
            };

            _eventAggregator = eventAggregator;
            _eventAggregator.GetEvent <Messages.ShowEditorMessage>().Subscribe(item =>
            {
                EditSplitView.IsPaneOpen = true;
                SideEditView.DataContext = item;
            });

            ShellView.Initialize();
        }
            public GestureListenerBehavioursBehaviour(Control element)
            {
                var gestureListener = GestureService.GetGestureListener(element);

                gestureListener.Tap       += TapCalled;
                gestureListener.DoubleTap += DoubleTapCalled;
                //element.MouseEnter += new MouseEventHandler(MouseIsOverChanged);
            }
예제 #12
0
 private void _startAll()
 {
     LoggingService.Start();
     AlertService.Start();
     AppService.Start();
     RenderingService.Start();
     GestureService.Start(this);
 }
 /// <summary>
 /// Create a new LoopingSelectorItem.
 /// </summary>
 public LoopingSelectorItem()
 {
     DefaultStyleKey      = typeof(LoopingSelectorItem);
     MouseLeftButtonDown += LoopingSelectorItem_MouseLeftButtonDown;
     MouseLeftButtonUp   += LoopingSelectorItem_MouseLeftButtonUp;
     LostMouseCapture    += LoopingSelectorItem_LostMouseCapture;
     GestureService.GetGestureListener(this).Tap += new EventHandler <GestureEventArgs>(LoopingSelectorItem_Tap);
 }
예제 #14
0
 public override void RegisterTypes(IContainerRegistry container)
 {
     container.Register <IDataService, DataService>();
     container.Register <IJumpListService, JumpListService>();
     container.RegisterInstance(new Lazy <IGestureService>(() => GestureService.GetForCurrentView()));
     container.RegisterForNavigation <MainPage, MainPageViewModel>(nameof(MainPage));
     container.RegisterForNavigation <ItemPage, ItemPageViewModel>(nameof(ItemPage));
 }
예제 #15
0
 internal static void ForwardWindowCreated(WindowCreatedEventArgs args)
 {
     GestureService.SetupWindowListeners(args.Window.CoreWindow);
     foreach (var item in WindowCreatedCallBacks.ToArray())
     {
         item.Value?.Invoke(args);
     }
     _instances.Add(args.Window);
 }
예제 #16
0
        // Constructor
        public MainPage()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(MainPage_Loaded);
            var gl = GestureService.GetGestureListener(LayoutRoot);

            gl.Flick     += new EventHandler <FlickGestureEventArgs>(GestureListener_Flick);
            gl.DragDelta += new EventHandler <DragDeltaGestureEventArgs>(GestureListener_DragDelta);
            gl.DoubleTap += new EventHandler <Microsoft.Phone.Controls.GestureEventArgs>(GestureListener_Doubletap);
        }
예제 #17
0
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            _image = GetTemplateChild("ImgZoom") as Image;
            var gl = GestureService.GetGestureListener(_image);

            gl.PinchDelta    += OnPinchDelta;
            gl.PinchStarted  += OnPinchStarted;
            gl.DragDelta     += OnDragDelta;
            _image.DoubleTap += OnDoubleTap;
        }
예제 #18
0
        static void ClearLastUselessEvents(FrameworkElement fe, string eventName)
        {
            var lisenter = GestureService.GetGestureListener(fe as FrameworkElement);
            List <GestureEventRegisterInfo> uselessEventsList_ = new List <GestureEventRegisterInfo>();

            foreach (var e in EventsList)
            {
                if (e.FE == fe as FrameworkElement)
                {
                    if (e.EventsName.Equals(eventName))
                    {
                        if (e.EventsName.Equals("setTapListener") && e.TapGestureEventHandler != null)
                        {
                            fe.Tap -= e.TapGestureEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setDoubleTapListener") && e.TapGestureEventHandler != null)
                        {
                            fe.DoubleTap -= e.TapGestureEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setLongTapListener") && e.GestureEventHandler != null)
                        {
                            lisenter.Hold -= e.GestureEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setSwipeListener") && e.FlickGestureEventHandler != null)
                        {
                            lisenter.Flick -= e.FlickGestureEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setDragListener") && e.DragDeltaGestureEventHandler != null)
                        {
                            fe.ManipulationDelta -= e.DragDeltaGestureEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setRotationListener") && e.RotationDeltaEventHandler != null)
                        {
                            fe.ManipulationDelta -= e.RotationDeltaEventHandler;
                            uselessEventsList_.Add(e);
                        }
                        else if (e.EventsName.Equals("setScaleListener") && e.ScaleDeltaEventHandler != null)
                        {
                            fe.ManipulationDelta -= e.ScaleDeltaEventHandler;
                            uselessEventsList_.Add(e);
                        }
                    }
                }
            }
            foreach (var e in uselessEventsList_)
            {
                EventsList.Remove(e);
            }
        }
        public SwipeContentControl()
        {
            this.RenderTransform = new TranslateTransform();

            this.DefaultStyleKey = typeof(ContentControl);

            GestureListener listener = GestureService.GetGestureListener(this);

            listener.DragStarted   += DragStarted;
            listener.DragDelta     += DragDelta;
            listener.DragCompleted += DragCompleted;
        }
예제 #20
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            ThemeService.FirstRun();

            SetContentView(Resource.Layout.activity_main);
            this.WireUpControls();
            this.SetToolbarWithDrawer(Toolbar, Drawer, 0, 0);

            Ioc.Resolve <PermissionsService>().SetActivity(this);
            Ioc.Resolve <FileService>().SetActivity(this);

            NavigationService = Ioc.Resolve <NavigationService>()
                                .SetFragmentManager(SupportFragmentManager)
                                .SetFragmentContainerId(Resource.Id.FragmentContainerView);

            GestureService = Ioc.Resolve <GestureService>();

            this.WhenActivated((CompositeDisposable disposable) =>
            {
                Observable.FromEventPattern <GestureEventArgs>(
                    h => GestureService.GoBackRequested += h,
                    h => GestureService.GoBackRequested -= h)
                .Subscribe(x =>
                {
                    if (!x.EventArgs.Handled && NavigationService.CanGoBack())
                    {
                        NavigationService.GoBack();
                        x.EventArgs.Handled = true;
                    }
                })
                .DisposeWith(disposable);

                Ioc.Resolve <IShellEvents>()
                .WhenTitleSet()
                .Throttle(TimeSpan.FromMilliseconds(150))
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(title => Toolbar.Title = title)
                .DisposeWith(disposable);

                Disposable
                .Create(() =>
                {
                })
                .DisposeWith(disposable);
            });

            NavigationService.NavigateTo(PageKeys.HomePage);
        }
예제 #21
0
 public bool HandleTouchDown(Vector3 screenPos)
 {
     dragged    = null;
     isDragging = false;
     touched    = null;
     if (!GestureService.IsOnUI())
     {
         var t = Utils.GetInputTargetOnGrid(screenPos, sceneSystem, cameraService.activeCamera, gridService);
         if (t != null && !t.hasGrid || (t != null && t.hasGrid && t.grid.cells.Count > 0))
         {
             touched = t;
         }
     }
     return(false);
 }
        private void CreateEventHandlers()
        {
            SizeChanged += new SizeChangedEventHandler(LoopingSelector_SizeChanged);

            GestureListener listener = GestureService.GetGestureListener(this);

            listener.DragStarted   += new EventHandler <DragStartedGestureEventArgs>(listener_DragStarted);
            listener.DragDelta     += new EventHandler <DragDeltaGestureEventArgs>(listener_DragDelta);
            listener.DragCompleted += new EventHandler <DragCompletedGestureEventArgs>(listener_DragCompleted);
            listener.Flick         += new EventHandler <FlickGestureEventArgs>(listener_Flick);
            listener.Tap           += new EventHandler <GestureEventArgs>(listener_Tap);

            AddHandler(MouseLeftButtonDownEvent, new MouseButtonEventHandler(LoopingSelector_MouseLeftButtonDown), true);
            AddHandler(MouseLeftButtonUpEvent, new MouseButtonEventHandler(LoopingSelector_MouseLeftButtonUp), true);
        }
예제 #23
0
        /// <summary>
        /// Invoked when the application is launched normally by the end user.  Other entry points
        /// will be used when the application is launched to open a specific file, to display
        /// search results, and so forth.
        /// </summary>
        /// <param name="args">Details about the launch request and process.</param>
        protected override void OnLaunched(LaunchActivatedEventArgs args)
        {
            // Do not repeat app initialization when already running, just ensure that
            // the window is active
            if (args.PreviousExecutionState == ApplicationExecutionState.Running)
            {
                Window.Current.Activate();
                return;
            }

            if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
            {
                //TODO: Load state from previously suspended application
            }

            //// Create a Frame to act navigation context and navigate to the first page
            //var rootFrame = new Frame();
            //if (!rootFrame.Navigate(typeof(MainPage)))
            //{
            //    throw new Exception("Failed to create initial page");
            //}

            LoggingService.Init(AppDatabase.Current);
            LoggingService.Start();
            LoggingService.LogInformation("launching app...", "App.OnLaunched");

            AlertService.Init(AppDatabase.Current);
            AlertService.Start();
            LoggingService.LogInformation("initialized alerts...", "App.OnLaunched");

            GestureService.Init();
            LoggingService.LogInformation("initialized gensture manager...", "App.OnLaunched");

            AppDatabase.Current.LoadInstances();
            LoggingService.LogInformation("loaded appstate ...", "App.OnLaunched");

            AppService.Init();
            AppService.Start();
            LoggingService.LogInformation("initialized app services ...", "App.OnLaunched");

            WindowLayoutService.Init();
            LoggingService.LogInformation("initialized window layout services ...", "App.OnLaunched");


            // Place the frame in the current Window and ensure that it is active
            Window.Current.Content = new MasterPage(false); //rootFrame;
            Window.Current.Activate();
        }
예제 #24
0
        public UCPullToRefreshListBox()
        {
            Application.Current.Resources.Source = new Uri(
                "/PullToRefreshListBox;component/Ressources/Ressources.xaml", UriKind.Relative);
            Style = (Style)Application.Current.Resources["PullToRefreshListBoxStyle2"];

            Loaded += OnLoaded;

            #region GestureListenerConfig

            var gl = GestureService.GetGestureListener(this);
            gl.DragDelta     += GestureListener_OnDragDelta;
            gl.DragCompleted += GestureListener_OnDragCompleted;

            #endregion
        }
        private void AddItem()
        {
            Border b = new Border()
            {
                Width           = 100, Height = 100,
                Background      = new SolidColorBrush(Color.FromArgb(255, (byte)rnd.Next(256), (byte)rnd.Next(256), (byte)rnd.Next(256))),
                BorderThickness = new Thickness(2), Margin = new Thickness(8)
            };

            b.BorderBrush = (SolidColorBrush)Resources["PhoneForegroundBrush"];

            GestureListener listener = GestureService.GetGestureListener(b);

            listener.Tap += new EventHandler <GestureEventArgs>(WrapPanelSample_Tap);

            wrapPanel.Children.Add(b);
        }
예제 #26
0
 protected override void OnAttached()
 {
     base.OnAttached();
     AssociatedObject.RenderTransform = new CompositeTransform();
     _listener                = GestureService.GetGestureListener(AssociatedObject);
     _listener.PinchDelta    += OnPinchDelta;
     _listener.PinchStarted  += OnPinchStarted;
     _listener.DragStarted   += OnDragStarted;
     _listener.DragDelta     += OnDragDelta;
     _listener.DragCompleted += OnDragCompleted;
     _listener.Flick         += OnFlick;
     _listener.Tap           += OnTap;
     _listener.DoubleTap     += OnDoubleTap;
     // wait for the RootVisual to be initialized
     //Dispatcher.BeginInvoke(() =>
     //    ((PhoneApplicationFrame)Application.Current.RootVisual).OrientationChanged += OrientationChanged);
 }
예제 #27
0
        private void _cleanUpAll()
        {
            SettingsPane.GetForCurrentView().CommandsRequested -= _vm.onCommandsRequested;
            //SearchPane.GetForCurrentView().QuerySubmitted -= _vm.onQuerySubmitted;

            RenderingService.Stop();
            GestureService.Stop(this);

            ccDrawingSurfaceBottom.Content = null;
            ccDrawingSurfaceTop.Content    = null;


            _fvm.ChangeState -= _fvm_ChangeState;
            DownloadService.Current.DownloadCountChanged -= Current_DownloadCountChanged;

            Messenger.Default.Unregister <GeneralSystemWideMessage>(this, DoGeneralSystemWideMessageCallback);
            AppService.NetworkConnectionChanged      -= AppService_NetworkConnectionChanged;
            WindowLayoutService.OnWindowLayoutRaised -= WindowLayoutService_OnWindowLayoutRaised;
        }
예제 #28
0
        public ShellPage(IDialogService dialogService, IDataService dataService)
        {
            InitializeComponent();

            if (win.ApplicationModel.DesignMode.DesignModeEnabled)
            {
                return;
            }

            _gestureService = GestureService.GetForCurrentView();
            _dialogService  = dialogService;
            _dataService    = dataService;

            ShellView.Initialize();
            ShellView.Loaded += (s, e) =>
            {
                SetupGestures();
            };
        }
예제 #29
0
        public ThreadPageSlideView()
        {
            InitializeComponent();

            this._toggleAppBar = ToggleAppBarDummy;

            HideTitleOverlay();
            VisualStateManager.GoToState(this, "Loading", false);

            var gestures = GestureService.GetGestureListener(this.LayoutRoot);

            gestures.DoubleTap += ShowThreadTitle;

            gestures.PinchStarted   += OnLayoutPinchStarted;
            gestures.PinchDelta     += OnLayoutPinchDelta;
            gestures.PinchCompleted += OnLayoutPinchCompleted;

            Loaded   += OnLoad;
            Unloaded += OnUnload;
        }
예제 #30
0
        public bool HandleDragStart(Vector3 screenPos)
        {
            if (!GestureService.IsOnUI())
            {
                inertia    = false;
                isDragging = true;
                currentPos = screenPos;
                StartDragEntity();

                #if UNITY_EDITOR
                startPos = currentPos;
                #endif
            }
            else
            {
                inertia    = false;
                isDragging = false;
            }

            return(false);
        }