protected override bool OnButtonReleaseEvent (EventButton evnt)
		{
			if (click && hovered)
				OnClicked (EventArgs.Empty);
			click = false;
			return base.OnButtonReleaseEvent (evnt);
		}

		protected override bool OnWidgetEvent (Gdk.Event evnt)
		{
			// This method is hooked to block the event as soon as possible if required
			
			if(evnt.Window.Equals (this.GdkWindow))
			{
				switch(evnt.Type)
				{
					case Gdk.EventType.ButtonPress:
					case Gdk.EventType.ButtonRelease:
					case Gdk.EventType.ThreeButtonPress:
					case Gdk.EventType.TwoButtonPress:
						Gdk.EventButton eb = new Gdk.EventButton (evnt.Handle);
						return PropagateEventGivenCoordinate (evnt, eb.X, eb.XRoot, eb.Y, eb.YRoot);
					
					case Gdk.EventType.MotionNotify:
						Gdk.EventMotion em = new Gdk.EventMotion (evnt.Handle);
						return PropagateEventGivenCoordinate (evnt, em.X, em.XRoot, em.Y, em.YRoot);
					
					case Gdk.EventType.LeaveNotify:
						foreach(Widget w in lastHoveredWidgets)
						{
							w.ProcessEvent (evnt);
						}
						lastHoveredWidgets.Clear();
						return base.OnWidgetEvent (evnt);
				}
			}
			return base.OnWidgetEvent (evnt);
		}

 private void OnCanvasEvent(object obj, CanvasEventArgs args)
 {
     EventButton ev = new EventButton (args.Event.Handle);
     switch (ev.Type)
     {
         case EventType.ButtonPress:
             if (ev.Button == 1)
             {
                 holding= true;
                 firstCell = taskArea.GetCellAt (ev.X, ev.Y);
                 StartDrawing (ev);
             }
             break;
         case EventType.MotionNotify:
             if (holding && stask != null)
             {
                 curCell = taskArea.GetCellAt (ev.X, ev.Y);
                 stask.Y2 = ev.Y;
             }
             break;
         case EventType.ButtonRelease:
             holding = false;
             double rounded = RoundDownTask (ev.Y);
             stask.Y2 = rounded;
             PointToTime (firstCell, curCell, stask.Task, firstX, firstY, ev.X, rounded);
             break;
         default:
             break;
     }
 }

        protected override bool OnButtonPressEvent(EventButton evnt)
        {
            TreePath[] paths = Selection.GetSelectedRows();

            if((evnt.Type == EventType.ButtonPress) && (evnt.Button == 3))
            {
                // We don't want to unselect the play when several
                // plays are selected and we clik the right button
                // For multiedition
                if(paths.Length <= 1) {
                    base.OnButtonPressEvent(evnt);
                    paths = Selection.GetSelectedRows();
                }

                if(paths.Length == 1) {
                    TimeNode selectedTimeNode = GetValueFromPath(paths[0]) as TimeNode;
                    if(selectedTimeNode is Play) {
                        deleteKeyFrame.Sensitive = (selectedTimeNode as Play).HasDrawings;
                        MultiSelectMenu(false);
                        menu.Popup();
                    } else {
                        playersMenu.Popup();
                    }
                }
                else if(paths.Length > 1) {
                    MultiSelectMenu(true);
                    menu.Popup();
                }
            }
            else
                base.OnButtonPressEvent(evnt);
            return true;
        }

 protected override bool OnButtonPressEvent(EventButton evnt)
 {
     Console.WriteLine("Button pressed");
     if (evnt.Button == 1)
     {
         _dragStartTime = evnt.Time;
         GetPathAtPos((int) evnt.X, (int) evnt.Y, out _dragStartPath);
     }
     return base.OnButtonPressEvent(evnt);
 }

        bool OnPanButtonReleaseEvent(EventButton evnt)
        {
            if (evnt.Button != 2) {
                // Restrict to middle mouse button.
                return false;
            }

            System.Diagnostics.Debug.Assert (InPanMotion);
            InPanMotion = false;

            // Reset cursor
            GdkWindow.Cursor = null;
            return true;
        }

        protected override bool OnButtonPressEvent(EventButton args)
        {
            base.GrabFocus ();

            if (args.Button != 3)
                return false;

            Point grid = WindowCoordsToGridPoint ( (int) args.X, (int) args.Y);
            if (map.GetGridInformation (grid) == GridInformation.Invalid)
                return false;

            highlight_grid = grid;
            UIActions.Instance.WorldViewContextMenu.Popup ();

            return true;
        }

        protected override bool OnButtonPressEvent(EventButton evnt)
        {
            if((evnt.Type == EventType.ButtonPress) && (evnt.Button == 3))
            {
                TreePath path;

                GetPathAtPos((int)evnt.X,(int)evnt.Y,out path);
                if(path!=null) {
                    Model.GetIter(out selectedIter,path);
                    selectedSubcat = (ISubCategory) Model.GetValue(selectedIter, 0);
                    edit.Sensitive = selectedSubcat is TagSubCategory;
                    menu.Popup();
                }
            }
            return base.OnButtonPressEvent(evnt);
        }

        bool OnPanButtonPressEvent(EventButton evnt)
        {
            if (evnt.Button != 2) {
                // Restrict to middle mouse button.
                return false;
            }

            System.Diagnostics.Debug.Assert (!InPanMotion);
            InPanMotion = true;

            // Track starting point of panning movement.
            pan_anchor.X = (int)evnt.X;
            pan_anchor.Y = (int)evnt.Y;

            // Set to crosshair pointer
            GdkWindow.Cursor = new Cursor (CursorType.Fleur);
            return true;
        }

		protected override bool OnButtonPressEvent (EventButton ev)
		{
			if (surface == null)
				return false;

			switch (ev.Button) {
			case 1:
				DrawBrush (ev.X, ev.Y);
				break;
			case 3:
				ClearSurface ();
				QueueDraw ();
				break;
			default:
				break;
			}
			return true;
		}

        protected override bool OnButtonReleaseEvent(EventButton evnt)
        {
            if (evnt.Button == 1)
            {
                if (_dragStartTime > 0 && evnt.Time - _dragStartTime > 500)
                {
                    TreePath endPath;
                    if (!GetPathAtPos((int) evnt.X, (int) evnt.Y, out endPath))
                    {
                        GetPathAtPos(1, 1, out endPath);
                    }
                    if (_dragStartPath.Compare(endPath) < 0)
                        Selection.SelectRange(_dragStartPath, endPath);
                    else
                        Selection.SelectRange(endPath, _dragStartPath);
                }

                _dragStartTime = 0;
                Console.WriteLine("Button released {0}", _dragStartTime);
            }
            return base.OnButtonReleaseEvent(evnt);
        }

		protected override bool OnButtonPressEvent (EventButton evnt)
		{
			foreach (HotSpot hp in hostSpots) {
				if (hp.Rect.Contains ((int)evnt.X, (int)evnt.Y) && hp.Action != null) {
					hp.Action ();
					break;
				}
			}
			return base.OnButtonPressEvent (evnt);
		}

		protected override bool OnButtonReleaseEvent (EventButton evnt)
		{
			Close ();
			return base.OnButtonReleaseEvent (evnt);
		}

		protected override bool OnButtonReleaseEvent (EventButton evnt)
		{
			ClearGrab ();
			UpdatePrelightState (evnt.X, evnt.Y);
			return base.OnButtonReleaseEvent (evnt);
		}

		protected override bool OnButtonReleaseEvent (EventButton e)
		{
			buttonPressed = false;
			return base.OnButtonReleaseEvent (e);
		}

 protected override bool OnButtonReleaseEvent(EventButton evnt)
 {
     if (State == StateType.Selected)
         OnClicked (EventArgs.Empty);
     State = IsInside (evnt.X, evnt.Y) ? StateType.Prelight : StateType.Normal;;
     hoverState = StateType.Prelight;
     return true;
 }

		void Item_Event (object obj, Gnome.CanvasEventArgs args) {
			EventButton ev = new EventButton (args.Event.Handle);
			CanvasRE item = (CanvasRE) obj;

			switch (ev.Type) {
			case EventType.ButtonPress:
				if (ev.Button == 1) {
					remember_x = ev.X;
					remember_y = ev.Y;
					args.RetVal = true;
					return;
				} else if (ev.Button == 3) {
					item.Destroy ();
					args.RetVal = true;
					return;
				}
				break;
			case EventType.TwoButtonPress:
				ChangeItemColor (item);
				args.RetVal = true;
				return;
			case EventType.MotionNotify:
				Gdk.ModifierType state = (Gdk.ModifierType) ev.State;
				if ((state & Gdk.ModifierType.Button1Mask) != 0) {
					double new_x = ev.X, new_y = ev.Y;
					item.Move (new_x - remember_x, new_y - remember_y);
					remember_x = new_x;
					remember_y = new_y;
					args.RetVal = true;
					return;
				}
				break;
			case EventType.EnterNotify:
				item.WidthUnits = 3.0;
				args.RetVal = true;
				return;
			case EventType.LeaveNotify:
				item.WidthUnits = 1.0;
				args.RetVal = true;
				return;
			}

			args.RetVal = false;
			return;
		}

		protected override bool OnButtonPressEvent (EventButton evnt)
		{
			if (evnt.Button == 1 && hovered) 
				click = true;
			return base.OnButtonPressEvent (evnt);
		}

        bool OnSelectionButtonReleaseEvent(EventButton evnt)
        {
            if (evnt.Button != 1)
                return false;

            is_dragging_selection = false;
            is_moving_selection = false;
            fixed_width = fixed_height = false;

            SelectionSetPointer ((int)evnt.X, (int)evnt.Y);
            return true;
        }

			protected override bool OnButtonReleaseEvent (EventButton evnt)
			{
				if (dragPosition >= 0) {
					Gdk.Pointer.Ungrab (grabTime);
					dragPosition = -1;
				}
				return base.OnButtonReleaseEvent (evnt);
			}