示例#1
0
        void ChaosDisplayMouseScrolledEvent(object pSender, ScrollEventArgs pArguments)
        {
            //Todo: alter this to scale based on size, but probably on a linear ramp.
            if (!this.Rendering)
            {
                Gdk.EventScroll tmpEventInfo = pArguments.Event;

                switch (tmpEventInfo.Direction)
                {
                case Gdk.ScrollDirection.Up:
                    this._ZoomFactor = Math.Min(this._ZoomFactor + 0.25, 100.0);
                    //this.Write_To_Log ( "Zooming In To 1/"+this.Zoom_Factor.ToString() );
                    this.ChaosDisplayRefactorZoom(this._OutputChaosRenderingMachine._ZoomCenterpointX, this._OutputChaosRenderingMachine._ZoomCenterpointY);
                    break;

                case Gdk.ScrollDirection.Down:
                    this._ZoomFactor = Math.Max(this._ZoomFactor - 0.25, 1.0);
                    //this.Write_To_Log ( "Zooming Out To 1/"+this.Zoom_Factor.ToString() );
                    this.ChaosDisplayRefactorZoom(this._OutputChaosRenderingMachine._ZoomCenterpointX, this._OutputChaosRenderingMachine._ZoomCenterpointY);
                    break;
                }
            }

            pArguments.RetVal = true;
        }
示例#2
0
        internal void OnMouseWheel(object o, ScrollEventArgs args)
        {
            Gdk.EventScroll e = args.Event;

            if (e.Direction == Gdk.ScrollDirection.Down)
            {
                double newValue = dvDisplay.VScroll.Value + dvDisplay.VScroll.Adjustment.StepIncrement;
                if (newValue <= dvDisplay.VScroll.Adjustment.Upper - dvDisplay.VScroll.Adjustment.PageSize)
                {
                    dvDisplay.VScroll.Value = newValue;
                }
                else
                {
                    dvDisplay.VScroll.Value = dvDisplay.VScroll.Adjustment.Upper - dvDisplay.VScroll.Adjustment.PageSize;
                }
            }
            else if (e.Direction == Gdk.ScrollDirection.Up)
            {
                double newValue = dvDisplay.VScroll.Value - dvDisplay.VScroll.Adjustment.StepIncrement;
                if (newValue >= dvDisplay.VScroll.Adjustment.Lower)
                {
                    dvDisplay.VScroll.Value = newValue;
                }
                else
                {
                    dvDisplay.VScroll.Value = dvDisplay.VScroll.Adjustment.Lower;
                }
            }
        }
示例#3
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            bool res = base.OnScrollEvent(evnt);

            CreateEvent(evnt);
            return(res);
        }
示例#4
0
        void CreateEvent(Gdk.EventScroll refEvent)
        {
            int rx, ry;

            tree.BinWindow.GetOrigin(out rx, out ry);
            NativeEventScrollStruct nativeEvent = new NativeEventScrollStruct();

            nativeEvent.type       = refEvent.Type;
            nativeEvent.send_event = 1;
            nativeEvent.window     = tree.BinWindow.Handle;
            nativeEvent.x          = refEvent.XRoot - rx;
            nativeEvent.y          = refEvent.YRoot - ry;
            nativeEvent.x_root     = refEvent.XRoot;
            nativeEvent.y_root     = refEvent.YRoot;
            nativeEvent.time       = refEvent.Time;
            nativeEvent.direction  = refEvent.Direction;
            nativeEvent.state      = (uint)refEvent.State;
            nativeEvent.device     = refEvent.Device.Handle;

            IntPtr ptr = GLib.Marshaller.StructureToPtrAlloc(nativeEvent);

            try {
                Gdk.EventScroll evnt = new Gdk.EventScroll(ptr);
                Gdk.EventHelper.Put(evnt);
            } finally {
                Marshal.FreeHGlobal(ptr);
            }
        }
示例#5
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            if (evnt.Direction == Gdk.ScrollDirection.Down ||
                evnt.Direction == Gdk.ScrollDirection.Up)
            {
                double startX, startY;
                ScreenToDrawingCoords(evnt.X, evnt.Y, out startX, out startY);
                if (evnt.Direction == Gdk.ScrollDirection.Down)
                {
                    scale *= SCROLL_FACTOR;
                }
                else
                {
                    scale /= SCROLL_FACTOR;
                }
                double endX, endY;
                ScreenToDrawingCoords(evnt.X, evnt.Y, out endX, out endY);

                transformX += (endX - startX) * scale;
                transformY += (endY - startY) * scale;

                QueueDraw();
                return(true);
            }
            return(false);
        }
示例#6
0
 public static void GetPageScrollPixelDeltas(this Gdk.EventScroll evt, double pageSizeX, double pageSizeY,
                                             out double deltaX, out double deltaY)
 {
     if (!GetEventScrollDeltas(evt, out deltaX, out deltaY))
     {
         var direction = evt.Direction;
         deltaX = deltaY = 0;
         if (pageSizeY != 0 && (direction == Gdk.ScrollDirection.Down || direction == Gdk.ScrollDirection.Up))
         {
             deltaY = System.Math.Pow(pageSizeY, 2.0 / 3.0);
             deltaX = 0.0;
             if (direction == Gdk.ScrollDirection.Up)
             {
                 deltaY = -deltaY;
             }
         }
         else if (pageSizeX != 0)
         {
             deltaX = System.Math.Pow(pageSizeX, 2.0 / 3.0);
             deltaY = 0.0;
             if (direction == Gdk.ScrollDirection.Left)
             {
                 deltaX = -deltaX;
             }
         }
     }
 }
            protected override bool OnScrollEvent(Gdk.EventScroll evnt)
            {
                var s = GetRowByPosition((int)evnt.Y);

                Selection = s;

                return(base.OnScrollEvent(evnt));
            }
示例#8
0
 /// <summary>
 /// Creates the mouse wheel event arguments.
 /// </summary>
 /// <param name="e">The scroll event args.</param>
 /// <returns>Mouse event arguments.</returns>
 private static OxyMouseWheelEventArgs GetMouseWheelEventArgs(Gdk.EventScroll e)
 {
     return(new OxyMouseWheelEventArgs
     {
         Delta = e.Direction == Gdk.ScrollDirection.Down ? -120 : 120,
         Position = new ScreenPoint(e.X, e.Y),
         ModifierKeys = ConverterExtensions.GetModifiers(e.State)
     });
 }
示例#9
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            if (can_seek)
            {
                SeekValue += (evnt.Direction.Equals(Gdk.ScrollDirection.Down) ? -1 : 1) * 10000;  // skip 10s
                OnSeekRequested();
            }

            return(base.OnScrollEvent(evnt));
        }
示例#10
0
        protected override bool OnScrollEvent(Gdk.EventScroll scroll)
        {
            if ((scroll.State & Gdk.ModifierType.ControlMask) != 0)
            {
                Zoom += (scroll.Direction == Gdk.ScrollDirection.Up) ? ZOOM_STEP : -ZOOM_STEP;
                return(true);
            }

            return(base.OnScrollEvent(scroll));
        }
 protected override bool OnScrollEvent(Gdk.EventScroll evnt)
 {
     if (evnt.Direction == Gdk.ScrollDirection.Down)
     {
         vscrollbar1.Value = vscrollbar1.Value + 1;
     }
     else if (evnt.Direction == Gdk.ScrollDirection.Up)
     {
         vscrollbar1.Value = vscrollbar1.Value - 1;
     }
     return(base.OnScrollEvent(evnt));
 }
示例#12
0
 public static bool GetEventScrollDeltas(Gdk.EventScroll evt, out double deltaX, out double deltaY)
 {
     if (!scrollDeltasNotSupported)
     {
         try {
             return(gdk_event_get_scroll_deltas(evt.Handle, out deltaX, out deltaY));
         } catch (EntryPointNotFoundException) {
             scrollDeltasNotSupported = true;
         }
     }
     deltaX = deltaY = 0;
     return(false);
 }
示例#13
0
        private bool InternalScrollEvent(Gdk.EventScroll evnt)
        {
            ScrollEventNativeDelegate unmanaged = class_abi.BaseOverride <ScrollEventNativeDelegate>(this.LookupGType(), "scroll_event");

            if (unmanaged == null)
            {
                return(false);
            }

            bool __result = unmanaged(this.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);

            return(__result);
        }
示例#14
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            Gdk.ModifierType state = Gtk.Accelerator.DefaultModMask & evnt.State;
            bool             ret   = base.OnScrollEvent(evnt);

            if (state == Gdk.ModifierType.Mod1Mask)
            {
                return(SwitchRuler(evnt.Direction == Gdk.ScrollDirection.Up) || ret);
            }
            else
            {
                return(Zoom(evnt.X, evnt.Y, evnt.Direction == Gdk.ScrollDirection.Up, evnt.State) || ret);
            }
        }
示例#15
0
        internal bool HandleScroll(Gdk.EventScroll args)
        {
            switch (args.Direction)
            {
            case Gdk.ScrollDirection.Up:
            case Gdk.ScrollDirection.Right:
                Value++;
                return(true);

            case Gdk.ScrollDirection.Down:
            case Gdk.ScrollDirection.Left:
                Value--;
                return(true);
            }

            return(false);
        }
示例#16
0
        private bool InternalScrollEvent(Gdk.EventScroll evnt)
        {
            ScrollEventNativeDelegate unmanaged = null;

            unsafe {
                IntPtr *raw_ptr = (IntPtr *)(((long)this.LookupGType().GetThresholdType().GetClassPtr()) + (long)class_abi.GetFieldOffset("scroll_event"));
                unmanaged = (ScrollEventNativeDelegate)Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ScrollEventNativeDelegate));
            }
            if (unmanaged == null)
            {
                return(false);
            }

            bool __result = unmanaged(this.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);

            return(__result);
        }
示例#17
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            if (evnt.Type != Gdk.EventType.Scroll)
            {
                return(false);
            }

            if (evnt.Direction == Gdk.ScrollDirection.Up)
            {
                AdjustVolume(1);
            }
            else if (evnt.Direction == Gdk.ScrollDirection.Down)
            {
                AdjustVolume(-1);
            }

            return(true);
        }
示例#18
0
        protected override bool OnScrollEvent(Gdk.EventScroll evnt)
        {
            switch (evnt.Direction)
            {
            case Gdk.ScrollDirection.Up:
                if ((evnt.State & Gdk.ModifierType.ControlMask) != 0)
                {
                    ServiceManager.PlayerEngine.Volume += PlayerEngine.VolumeDelta;
                }
                else if ((evnt.State & Gdk.ModifierType.ShiftMask) != 0)
                {
                    ServiceManager.PlayerEngine.Position += PlayerEngine.SkipDelta;
                }
                else
                {
                    ServiceManager.PlaybackController.Next();
                }
                break;

            case Gdk.ScrollDirection.Down:
                if ((evnt.State & Gdk.ModifierType.ControlMask) != 0)
                {
                    if (ServiceManager.PlayerEngine.Volume < PlayerEngine.VolumeDelta)
                    {
                        ServiceManager.PlayerEngine.Volume = 0;
                    }
                    else
                    {
                        ServiceManager.PlayerEngine.Volume -= PlayerEngine.VolumeDelta;
                    }
                }
                else if ((evnt.State & Gdk.ModifierType.ShiftMask) != 0)
                {
                    ServiceManager.PlayerEngine.Position -= PlayerEngine.SkipDelta;
                }
                else
                {
                    ServiceManager.PlaybackController.Previous();
                }
                break;
            }
            return(true);
        }
示例#19
0
        /// <summary>
        /// Creates the mouse wheel event arguments.
        /// </summary>
        /// <param name="e">The scroll event args.</param>
        /// <returns>Mouse event arguments.</returns>
        private static OxyMouseWheelEventArgs GetMouseWheelEventArgs(Gdk.EventScroll e)
        {
            int delta;

#if NETSTANDARD2_0
            if (e.Direction == Gdk.ScrollDirection.Smooth)
            {
                delta = e.DeltaY < 0 ? 120 : -120;
            }
            else
#endif
            delta = e.Direction == Gdk.ScrollDirection.Down ? -120 : 120;
            return(new OxyMouseWheelEventArgs
            {
                Delta = delta,
                Position = new ScreenPoint(e.X, e.Y),
                ModifierKeys = ConverterExtensions.GetModifiers(e.State)
            });
        }
示例#20
0
 protected virtual bool OnScrollEvent(Gdk.EventScroll evnt)
 {
     return(InternalScrollEvent(evnt));
 }
示例#21
0
 protected override bool OnScrollEvent(Gdk.EventScroll evnt)
 {
     _editorScene.ZoomCamera(evnt.Direction == Gdk.ScrollDirection.Up);
     return(true);
 }
示例#22
0
 protected override bool OnScrollEvent(Gdk.EventScroll args)
 {
     return(HandleScroll(args));
 }
 protected override bool OnScrollEvent(Gdk.EventScroll e)
 {
     e.Direction = DetermineScrollDirection(e);
     return(base.OnScrollEvent(e));
 }
        private Gdk.ScrollDirection DetermineScrollDirection(Gdk.EventScroll e)
        {
            var nativeScrollEvent = (GdkNativeScrollStruct)System.Runtime.InteropServices.Marshal.PtrToStructure(e.Handle, typeof(GdkNativeScrollStruct));

            return(nativeScrollEvent.delta_y > 0 ? Gdk.ScrollDirection.Down : Gdk.ScrollDirection.Up);
        }
示例#25
0
 protected override bool OnScrollEvent(Gdk.EventScroll evnt)
 {
     QueueDraw();
     return(base.OnScrollEvent(evnt));
 }
示例#26
0
 protected override bool OnScrollEvent(Gdk.EventScroll evnt)
 {
     return(entry.HandleScroll(evnt));
 }
示例#27
0
		void CreateEvent (Gdk.EventScroll refEvent)
		{
			int rx, ry;
			tree.BinWindow.GetOrigin (out rx, out ry);
			NativeEventScrollStruct nativeEvent = new NativeEventScrollStruct (); 
			nativeEvent.type = refEvent.Type;
			nativeEvent.send_event = 1;
			nativeEvent.window = tree.BinWindow.Handle;
			nativeEvent.x = refEvent.XRoot - rx;
			nativeEvent.y = refEvent.YRoot - ry;
			nativeEvent.x_root = refEvent.XRoot;
			nativeEvent.y_root = refEvent.YRoot;
			nativeEvent.time = refEvent.Time;
			nativeEvent.direction = refEvent.Direction;
			nativeEvent.state = (uint) refEvent.State;
			nativeEvent.device = refEvent.Device.Handle;

			IntPtr ptr = GLib.Marshaller.StructureToPtrAlloc (nativeEvent); 
			try {
				Gdk.EventScroll evnt = new Gdk.EventScroll (ptr); 
				Gdk.EventHelper.Put (evnt); 
			} finally {
				Marshal.FreeHGlobal (ptr);
			}
		}