C++ wxMouseEvent::GetEventType方法代码示例

void wxWebView::OnMouseEvents(wxMouseEvent& event)
{
    event.Skip();
    
    if (!m_impl->page)
        return; 
        
    WebCore::Frame* frame = m_mainFrame->GetFrame();  
    if (!frame || !frame->view())
        return;
    
    wxPoint globalPoint = ClientToScreen(event.GetPosition());

    wxEventType type = event.GetEventType();
    
    if (type == wxEVT_MOUSEWHEEL) {
        if (m_mouseWheelZooms && event.ControlDown() && !event.AltDown() && !event.ShiftDown()) {
            if (event.GetWheelRotation() < 0)
                DecreaseTextSize();
            else if (event.GetWheelRotation() > 0)
                IncreaseTextSize();
        } else {
            WebCore::PlatformWheelEvent wkEvent(event, globalPoint);
            frame->eventHandler()->handleWheelEvent(wkEvent);
        }

        return;
    }
    
    // If an event, such as a right-click event, leads to a focus change (e.g. it 
    // raises a dialog), WebKit never gets the mouse up event and never relinquishes 
    // mouse capture. This leads to WebKit handling mouse events, such as modifying
    // the selection, while other controls or top level windows have the focus.
    // I'm not sure if this is the right place to handle this, but I can't seem to
    // find a precedent on how to handle this in other ports.
    if (wxWindow::FindFocus() != this) {
        while (HasCapture())
            ReleaseMouse();

        frame->eventHandler()->setMousePressed(false);

        return;
    }
        
    int clickCount = event.ButtonDClick() ? 2 : 1;

    if (clickCount == 1 && m_impl->tripleClickTimer.IsRunning()) {
        wxPoint diff(event.GetPosition() - m_impl->tripleClickPos);
        if (abs(diff.x) <= wxSystemSettings::GetMetric(wxSYS_DCLICK_X) &&
            abs(diff.y) <= wxSystemSettings::GetMetric(wxSYS_DCLICK_Y)) {
            clickCount = 3;
        }
    } else if (clickCount == 2) {
        m_impl->tripleClickTimer.Start(getDoubleClickTime(), false);
        m_impl->tripleClickPos = event.GetPosition();
    }
    
    WebCore::PlatformMouseEvent wkEvent(event, globalPoint, clickCount);

    if (type == wxEVT_LEFT_DOWN || type == wxEVT_MIDDLE_DOWN || type == wxEVT_RIGHT_DOWN || 
                type == wxEVT_LEFT_DCLICK || type == wxEVT_MIDDLE_DCLICK || type == wxEVT_RIGHT_DCLICK) {
        frame->eventHandler()->handleMousePressEvent(wkEvent);
        if (!HasCapture())
            CaptureMouse();
    } else if (type == wxEVT_LEFT_UP || type == wxEVT_MIDDLE_UP || type == wxEVT_RIGHT_UP) {
        frame->eventHandler()->handleMouseReleaseEvent(wkEvent);
        while (HasCapture())
            ReleaseMouse();
    } else if (type == wxEVT_MOTION || type == wxEVT_ENTER_WINDOW || type == wxEVT_LEAVE_WINDOW)
        frame->eventHandler()->mouseMoved(wkEvent);
}

void CtrlRegisterList::mouseEvent(wxMouseEvent& evt)
{
	int xOffset, yOffset;
	((wxScrolledWindow*) this)->GetViewStart(&xOffset, &yOffset);

	wxClientDC dc(this);
	wxPoint pos = evt.GetPosition();
	int x = dc.DeviceToLogicalX(pos.x) + xOffset;
	int y = dc.DeviceToLogicalY(pos.y) + yOffset * rowHeight;

	if (evt.GetEventType() == wxEVT_RIGHT_UP)
	{
		if (y >= rowHeight)
		{
			int row = (y-rowHeight)/rowHeight;
			if (row != currentRows[category] && row < cpu->getRegisterCount(category))
				setCurrentRow(row);
		}

		wxMenu menu;
		int bits = cpu->getRegisterSize(category);

		menu.AppendRadioItem(ID_REGISTERLIST_DISPLAY32,		L"Display 32 bit");
		menu.AppendRadioItem(ID_REGISTERLIST_DISPLAY64,		L"Display 64 bit");
		menu.AppendRadioItem(ID_REGISTERLIST_DISPLAY128,	L"Display 128 bit");
		menu.AppendSeparator();

		if (bits >= 64)
		{
			menu.Append(ID_REGISTERLIST_CHANGELOWER,	L"Change lower 64 bit");
			menu.Append(ID_REGISTERLIST_CHANGEUPPER,	L"Change upper 64 bit");
		} else {
			menu.Append(ID_REGISTERLIST_CHANGEVALUE,	L"Change value");
		}

		switch (maxBits)
		{
		case 128:
			menu.Check(ID_REGISTERLIST_DISPLAY128,true);
			break;
		case 64:
			menu.Check(ID_REGISTERLIST_DISPLAY64,true);
			break;
		case 32:
			menu.Check(ID_REGISTERLIST_DISPLAY32,true);
			break;
		}

		menu.Connect(wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&CtrlRegisterList::onPopupClick, NULL, this);
		PopupMenu(&menu,evt.GetPosition());
		return;
	}

	if (evt.ButtonIsDown(wxMOUSE_BTN_LEFT) || evt.ButtonIsDown(wxMOUSE_BTN_RIGHT))
	{
		if (y < rowHeight)
		{
			int piece = GetSize().x/cpu->getRegisterCategoryCount();
			int cat = std::min<int>(x/piece,cpu->getRegisterCategoryCount()-1);

			if (cat != category)
			{
				category = cat;
				Refresh();
			}
		} else {
			int row = (y-rowHeight)/rowHeight;
			if (row != currentRows[category] && row < cpu->getRegisterCount(category))
				setCurrentRow(row);
		}

		SetFocus();
		SetFocusFromKbd();
	}
}

void
SliderBar::OnMouseEvents (wxMouseEvent &ev)
{
    if (!IsEnabled()) {
        ev.Skip();
        return;
    }

    if (ev.Entering() && !_dragging) {
        _barbrush.SetColour(_overbarcolor);
        do_redraw();
    }
    else if (ev.Leaving() && !_dragging) {
        _barbrush.SetColour(_barcolor);
        do_redraw();
    }



    if (ev.Dragging() && _dragging)
    {
        int delta = ev.GetX() - _last_x;
        float fdelta = delta * _val_scale;

        if (ev.ControlDown()) {
            fdelta *= 0.5f;
            if (ev.ShiftDown()) {
                fdelta *= 0.5f;
            }
        }

        float newval = _value + fdelta;

        //cerr << "dragging: " << ev.GetX() << "  " << delta << "  " << fdelta << "  "  << newval << endl;

        if (_snap_mode == IntegerSnap) {
            newval = nearbyintf (newval);
        }

        newval = max (min (newval, _upper_bound), _lower_bound);

        if (newval != _value) {
            _value = newval;

            value_changed (get_value()); // emit

            update_value_str();
            do_redraw();
            //cerr << "new val is: " << _value << endl;


            _last_x = ev.GetX();
        }
    }
    else if (ev.Moving()) {
        // do nothing
    }
    else if (ev.GetEventType() == wxEVT_MOUSEWHEEL)
    {
        float fscale = 0.02f * (ev.ControlDown() ? 0.5f: 1.0f);
        float newval;

        if (_snap_mode == IntegerSnap) {
            newval = _value + ((ev.GetWheelRotation() > 0) ? 1 : -1);
        }
        else {
            if (ev.GetWheelRotation() > 0) {
                newval = _value + (_upper_bound - _lower_bound) * fscale;
            }
            else {
                newval = _value - (_upper_bound - _lower_bound) * fscale;
            }
        }


        if (_snap_mode == IntegerSnap) {
            newval = nearbyintf (newval);
        }

        newval = max (min (newval, _upper_bound), _lower_bound);


        _value = newval;

        value_changed (get_value()); // emit

        update_value_str();
        do_redraw();
    }
    else if (ev.RightDown()) {
        this->PopupMenu ( _popup_menu, ev.GetX(), ev.GetY());
    }
    else if (ev.RightUp()) {
        //this->PopupMenu ( _popup_menu, ev.GetX(), ev.GetY());
    }
    else if (ev.ButtonDown())
    {
        CaptureMouse();
        _dragging = true;
        _last_x = ev.GetX();
//.........这里部分代码省略.........

void wxMultiColumnListCtrl::OnMouseEvent(wxMouseEvent& event)
{
    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
    {
        int dir = event.GetWheelRotation();

        if (dir > 0)
        {
            m_items.SetSelection(m_items.GetSelection() - 1);
            if (m_items.GetSelection() < 0)
                m_items.SetSelection(m_items.GetItemCount() - 1);

            AdvanceToNextSelectableItem(-1);
        }
        else if (dir < 0)
        {
            m_items.SetSelection(m_items.GetSelection() + 1);
            if (m_items.GetSelection() >= m_items.GetItemCount())
                m_items.SetSelection(0);

            AdvanceToNextSelectableItem(1);
        }

        GenerateSelectionEvent();

        Refresh();
    }
    else if (event.GetButton() == wxMOUSE_BTN_NONE)
    {   // Mouse move
        bool bCanSelectItem = true;
        if (m_ptMouse.x != -2 && m_ptMouse.y != -2)
        {   // If ==-2 => Don't select item on mouse pointer : used when user select the window with keyboard
            if (m_ptMouse.x != -1 && m_ptMouse.y != -1)
            {   // If ==-1 => The client already move the mouse, select the item under the mouse cursor
                wxPoint ptCurrent = ClientToScreen(event.GetPosition());
                if (abs(ptCurrent.x - m_ptMouse.x) >= 3 || abs(ptCurrent.y - m_ptMouse.y) >= 3)
                {   // the user has moved the mouse over a 3 pixels square
                    m_ptMouse.x = m_ptMouse.y = -1; // Accept to select an item
                }
                else
                {   // Select this item is not allowed for the moment, the user must move the mouse
                    bCanSelectItem = false;
                }
            }
            if (bCanSelectItem)
            {
                int idx = m_items.HitTest(event.GetPosition());
                if (idx != wxNOT_FOUND)
                {
                    m_items.SetSelection(idx);
                    GenerateSelectionEvent();
                    Refresh();
                }
            }
        }
    }
    else if (event.LeftDown())
    {
        m_ptMouse.x = m_ptMouse.y = -1; // Accept to select an item
        SendCloseEvent();
        SetFocus();
    }
}

void wxTabbedCtrl::OnMouse(wxMouseEvent &ev) {
    wxPoint mouse = ev.GetPosition();
    int page = HitTest(ev.GetPosition());
    if(ev.GetEventType()==wxEVT_MOTION) {
        bool xhover = mouse.x >= x_rect.x && mouse.x <= x_rect.x+x_rect.width && mouse.y >= x_rect.y && mouse.y <= x_rect.y+x_rect.height;
        bool nhover = (mouse.x >= Next_rect.x && mouse.x <= Next_rect.x + Next_rect.width && mouse.y >= Next_rect.y && mouse.y <= Next_rect.y + Next_rect.height ) &&
                      ( m_intLastPage < ( GetPageCount() - 1 ) );
        bool phover = (mouse.x >= Prev_rect.x && mouse.x <= Prev_rect.x + Prev_rect.width && mouse.y >= Prev_rect.y && mouse.y <= Prev_rect.y + Prev_rect.height ) &&
                      ( m_intStartPage > 0 );
        bool mhover = (mouse.x >= Menu_rect.x && mouse.x <= Menu_rect.x + Menu_rect.width && mouse.y >= Menu_rect.y && mouse.y <= Menu_rect.y + Menu_rect.height );
        if(hover != xhover) {
            hover = xhover;
            wxClientDC dc(this);
            DrawX(hover, dc);
        }
        else if(hover_next != nhover) {
            hover_next = nhover;
            wxClientDC dc(this);
            DrawNext(hover_next, dc);
        }
        else if(hover_prev != phover) {
            hover_prev = phover;
            wxClientDC dc(this);
            DrawPrev(hover_prev, dc);
        }
        else if ( hover_menu != mhover ) {
            hover_menu = mhover;
            wxClientDC dc(this);
            DrawMenu(hover_menu, dc);
        }
        else {
            wxToolTip * tooltip = GetToolTip();
            if ( page != wxNOT_FOUND ) {
                if ( tipTab != page ) {
                    tipTab = page;
                    tooltip->Enable( true );
                    wxString info;
                    int pg = page + 1;
                    info << pg << " of " << GetPageCount() << " - " << GetPageText( page );
                    tooltip->SetTip( info );
                }
            }
            else {
                tipTab = -1;
                tooltip->Enable( false );
            }
        }
    }
    else if( ev.GetEventType()==wxEVT_LEFT_UP ) {
        if(hover ) {
            wxClientDC dc(this);
            DrawX(false, dc);
            SetVisible( active );
            wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, Menu_Close );
            GetEventHandler()->ProcessEvent( event );
        }
        else if( hover_next ) {
            wxClientDC dc(this);
            DrawNext(false, dc);
            if( GetPageCount() > ( m_intStartPage + 1 ) && ( m_intLastPage + 1 ) < GetPageCount() ) {
                m_intStartPage++;
                Refresh();
            }
        }
        else if( hover_prev ) {
            wxClientDC dc(this);
            DrawPrev(false, dc);
            if( m_intStartPage > 0 ) {
                m_intStartPage--;
                Refresh();
            }
        }
        else if( hover_menu ) {
            hover_menu = false;
            wxClientDC dc(this);
            DrawMenu(false, dc);
            GenerateConextMenu( mouse );
        }
        else {
            if(page != wxNOT_FOUND)
                SetSelection(page);
        }
    }
    else if( ev.GetEventType() == wxEVT_RIGHT_UP && page == wxNOT_FOUND ) {
        GenerateConextMenu( mouse );
    }
}

void AxScrolledWindow::OnMouseEvent( wxMouseEvent &event )
{
    if (event.Dragging())
    {
        if (!m_bitmap)
            return;
        if (event.m_x > m_bitmap->GetWidth())
            return;
        if (event.m_y > m_bitmap->GetHeight())
            return;
        if (m_selection)
        {
            wxPoint newPosition = event.GetPosition();
            RedrawDraggingArea(newPosition,true);
        }
    }
    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
    {
        if (event.LeftIsDown()) 
            return;

        int x, y;
        this->GetViewStart( &x, &y );
        int rot = 0;
        if ( event.m_wheelDelta != 0)
            rot = event.m_wheelRotation / event.m_wheelDelta * 6;
        //if (!m_shiftDown)
		if (!event.ShiftDown())
            this->Scroll( x, max(0, y - rot) );
        else
            this->Scroll( max( 0, x - rot ), y );
    }
    if (event.GetEventType() == wxEVT_LEAVE_WINDOW)
    {
        if (!m_bitmap)
            return;
			
		wxASSERT_MSG(m_imControlPtr,"Image controller cannot be NULL");
        wxPoint start, end;
        GetSelectionPoints(&start, &end);
		//m_imControlPtr->CloseDraggingSelection(start, end); // WARNING : commented to have superimposition ractivated using points added by hand. 
																// Not checked for pre-processing selection in recognition
        //m_isDragging = false;
        //this->SetCursor(*wxSTANDARD_CURSOR);
        m_endPosition = event.GetPosition();
    }
    if (event.GetEventType() == wxEVT_ENTER_WINDOW)
    {
        if (!m_bitmap)
            return;
        if (m_isDragging && event.m_leftDown)
            this->SetCursor(*wxCROSS_CURSOR);
		else // button has been released outside the window
		{
			this->SetCursor(*wxSTANDARD_CURSOR);
			m_isDragging = false;
		}
    }
    if (event.GetEventType() == wxEVT_LEFT_DOWN)
    {
        if (!m_bitmap)
            return;
        if (event.m_x > m_bitmap->GetWidth())
            return;
        if (event.m_y > m_bitmap->GetHeight())
            return;
        if (m_selection)
        {
            m_isDragging = true;
            this->SetCursor(*wxCROSS_CURSOR);
            RedrawDraggingArea(m_lastPosition,false);
            m_startPosition = event.GetPosition();
            m_lastPosition = m_startPosition;
        }
    }
    if (event.GetEventType() == wxEVT_LEFT_UP)
    {

        if (!m_bitmap)
            return;

        if (m_selection)
        {
            wxASSERT_MSG(m_imControlPtr,"Image controller cannot be NULL");
            wxPoint start, end;
            GetSelectionPoints(&start, &end);
            m_imControlPtr->CloseDraggingSelection(start, end);
            m_isDragging = false;
            this->SetCursor(*wxSTANDARD_CURSOR);
            m_endPosition = event.GetPosition();
            RedrawDraggingArea(m_lastPosition,true);
        }
    }
	if (event.GetEventType() == wxEVT_LEFT_DCLICK )
	{
        if (!m_bitmap)
            return;
		if (event.m_x > m_bitmap->GetWidth())
            return;
        if (event.m_y > m_bitmap->GetHeight())
//.........这里部分代码省略.........

void wxGL_PMFCanvas::OnMouseEvt(wxMouseEvent& event)
{
	bool update_omnipoints = false;

	if(event.Leaving() || event.ButtonUp()){
		mainpanel->control_panel->push_undo();
	}

	//if(!event.Leaving()){
	//	if(this != FindFocus()){
	//		previus_focus = FindFocus();
	//		SetFocus();
	//	}
	//}else{
	//	if(previus_focus)previus_focus->SetFocus();
	//}

	if (!model.GetSOBJCount())
	{
		event.Skip();
		return;
	}
	
	//glsz
	if (event.GetEventType() == wxEVT_LEFT_DOWN || 
		event.GetEventType() == wxEVT_RIGHT_DOWN )
	{
		mouse_start = wxPoint(event.GetX(), event.GetY());
	}
	else if (event.GetEventType() == wxEVT_MOTION && 
				event.Dragging())
	{
//########################start mouse movement code########################//
		if(event.m_controlDown){
	//------------------------start omnipoint code------------------------//
			//if control is down we move the selected omnipoint
			if(omni.point.size() > 0 && omni_selected_list >-1 && omni_selected_list < (int)omni.point.size() && omni_selected_item >-1 && omni_selected_item < (int)omni.point[omni_selected_list].size()){
				//but only if we have omnipoints and our selected coords are valid

				omnipoint&point = omni.point[omni_selected_list][omni_selected_item];

				double M[16], P[16];
				int v[4];
				glGetDoublev(GL_MODELVIEW_MATRIX, M);
				glGetDoublev(GL_PROJECTION_MATRIX, P);
				glGetIntegerv(GL_VIEWPORT, v);

				
				vector3d start;
				vector3d start_dir;
				vector3d end;
				vector3d end_dir;

				ray_cast(event.GetX(), event.GetY(), end, end_dir);
				ray_cast(mouse_start.x, mouse_start.y, start, start_dir);

				vector3d global_point = point.pos+model.get_model_offset(point.model);
					
					bool s = true, s2 = true;

				vector3d delta(0,0,0);

				if(event.m_leftDown){

					delta = filter_movement_delta(	plane_line_intersect(global_point, get_movement_plane_norm(),end, end_dir, &s)
														-	plane_line_intersect(global_point, get_movement_plane_norm(),start, start_dir, &s2));
					//if left button is down we move along x and y
				}else if(event.m_rightDown){
					//if right is down we move along y
					delta = closest_point_between_lines(global_point, get_movement_plane_norm(), end, end_dir)
										-closest_point_between_lines(global_point, get_movement_plane_norm(), start, start_dir);
				}
				if(s &&s2 && !null_vec(delta)){
					point.pos = point.pos + delta;
					update_omnipoints = true;
				}
			}
	//------------------------end omnipoint code------------------------//
		} else if(event.m_altDown){
			//------------------------start transform code------------------------//
			if(event.m_leftDown){
				//if left button is down we move along x and y
				bool s = true, s2 = true;
				vector3d start;
				vector3d start_dir;
				vector3d end;
				vector3d end_dir;

				ray_cast(event.GetX(), event.GetY(), end, end_dir);
				ray_cast(mouse_start.x, mouse_start.y, start, start_dir);

				// XXX: Should this have a value?
				vector3d global_point = vector3d();
				vector3d delta;

				delta = filter_movement_delta(	plane_line_intersect(global_point, get_movement_plane_norm(),end, end_dir, &s)
						-	plane_line_intersect(global_point, get_movement_plane_norm(),start, start_dir, &s2));
				if(s &&s2 && !null_vec(delta)){
					mainpanel->control_panel->transform(matrix(), delta);
				}
//.........这里部分代码省略.........

void wxFixWidthImportCtrl::OnMouse(wxMouseEvent &event)
{
    if (event.GetEventType() == wxEVT_MOUSEWHEEL && !m_captured)
    {
        size_t curposOld = m_curposL;
        int wheelRot = event.GetWheelRotation();
        int lines = wheelRot / event.GetWheelDelta();
        int pos = (int)m_curposL - lines; //New position tried
        if (pos < 0)
            m_curposL = 0;
        else
        {   m_curposL = (size_t)pos;
            pos = m_scrbarV->GetRange() - m_scrbarV->GetThumbSize(); //Max pos
            if (m_curposL > (size_t)pos)
                m_curposL = (size_t)pos;
            if (pos < 0) //This should never happen
                m_curposL = 0;
        }
        if (curposOld != m_curposL)
        {
            m_scrbarV->SetThumbPosition((int)m_curposL);
            Refresh();
        }
        return;
    }

    bool drawNew  = false; //Draw a new delimiter
    bool deleVal  = false; //Delete a value
    bool addVal   = false; //Add a value
    bool changeCl = false; //Change file line's colour
    bool paintIt  = false; //Refresh it all
    bool isOnRect = false; //Click is inside strings rect
    wxCoord xm = event.GetPosition().x;
    wxCoord ym = event.GetPosition().y;
    size_t n = 0;

    //Where is the mouse?
    if (xm >= m_rS.xmin && ym >= m_rS.ymin) //Below upper left corner
        isOnRect = true;

    wxClientDC dc( this );
    dc.SetFont(*m_Ffont);
    wxDouble fontS = dc.GetCharWidth() + FONTPADDING;
    //the nearest mark to the mouse
    wxCoord mA = xm; //mouse actual
    mA = (wxCoord)((double) (mA - m_rS.xmin - m_margin) / fontS + 0.5);
    int markVal = (int) mA + m_curposX; //can be < 0 because of CaptureMouse
    //x coordinate of the mark
    mA = mA * fontS + m_rS.xmin + m_margin;

    //Delete previus delimiter
    if ( m_delPrev )
        DrawDelimiter(&dc, m_Lc, wxXOR);
    m_delPrev = false;

    //Decide what to do (stored in m_LAct)
    if (event.LeftDown()) //Fired at first click
    {
        m_captured = true;
        CaptureMouse(); //We want to get LeftUp even cursor is out of window

        if ( isOnRect ) //at text
            m_LAct = 2;
        else if ( xm < m_rS.xmin || xm > m_rS.xmax
                 || markVal >= (int) m_maxLen || markVal < 1 //out of bounds
                 || !deliEnabled ) //or delimiters not enabled
            m_LAct = 0;
        else //at scale
        {   m_LAct = 1;
            m_Lc = mA;
            drawNew = true; //Delimiter changes colour
            //check if click was on a existing delimiter
            if ( m_values.Index(markVal) != wxNOT_FOUND )
                deleVal = true; //Keep m_delPrev=false, keep changed colour
            else
                m_delPrev = true;
            //store values for later comparation
            for ( n = 0; n < m_values.GetCount(); n++)
                m_valuesB.Add(m_values.Item(n));
        }
    }

    else if (event.Dragging() && event.LeftIsDown() && m_LAct == 1)
    {
        //Should we draw a new delimiter?
        if (mA >= m_rS.xmin && mA <= m_rS.xmax
            && markVal < (int) m_maxLen && markVal > 0)
        {
             drawNew = true;
             m_delPrev = true;
        }
    }

    else if (event.LeftUp()) //Finishing
    {
        if ( m_captured )
        {   ReleaseMouse();
            m_captured = false;
        }
        SetFocus(); //Needed to response to mouseWheel
//.........这里部分代码省略.........

//.........这里部分代码省略.........
    }
  }
  else
  if (event.LeftUp())
  { // ACTIVATE
    if (mStyle & mmMB_TOGGLE)
    { // TOGGLE
      if (mIsSelected)
        selected_changed = TRUE;
      mIsSelected = FALSE;
      toggle_changed = TRUE;
      mIsToggleDown = !mIsToggleDown;
      if (HasCapture()) ReleaseMouse();
    }
    else
    if (mStyle & mmMB_WHOLEDROPDOWN)
    { // WHOLEDROPDOWN
      if (mIsSelected)
        selected_changed = TRUE;
      mIsSelected = FALSE;
      if (!mIsWholeDropToggleDown)
        if (HasCapture()) ReleaseMouse();
    }
    /*
    else
    if (mStyle & mmMB_DROPDOWN)
    { // DROPDOWN
      if (mIsSelected)
        selected_changed = TRUE;
      mIsSelected = FALSE;
      if (mp.x > w-gDownBM.GetWidth()-mBorderSize && mp.x < w &&
	      mp.y > mBorderSize && mp.y < h-mBorderSize)
      { // Drop down arrow pressed
        if (!mIsDropToggleDown)
          if (HasCapture()) ReleaseMouse();
      }
      else
      if (MouseIsOnButton())
      { // Button (not arrow) pressed
        if (mIsDropToggleDown)
          droptoggle_changed = TRUE;
	mIsDropToggleDown = FALSE;
	if (!droptoggle_changed)
          mIsActivated = TRUE; // NOTE! SEND ACTIVATE SIGNAL!
        if (HasCapture()) ReleaseMouse();
      }
    }
    */
    else
    { // 'Normal' button
      if (mIsSelected)
        selected_changed = TRUE;
      mIsSelected = FALSE;
      mIsActivated = TRUE; // NOTE! SEND ACTIVATE SIGNAL!
      if (HasCapture()) ReleaseMouse();
    }
  }

  // Redraw only if neccessary
  if (focus_changed || selected_changed || wholedroptoggle_changed || droptoggle_changed || toggle_changed)
  {
    Refresh();
    // Generate events to let derived class know what happened
    if (focus_changed)
    { // ENTER/LEAVE
      wxCommandEvent ev(event.GetEventType(),GetId());
      if (mHasFocus)
        ev.SetEventType(wxEVT_ENTER_WINDOW);
      else
        ev.SetEventType(wxEVT_LEAVE_WINDOW);
      GetEventHandler()->ProcessEvent(ev); // Neccessary?
    }
    if (toggle_changed)
    { // TOGGLE
      wxCommandEvent ev(mmEVT_TOGGLE,GetId());
      GetEventHandler()->ProcessEvent(ev);
    }
    if (wholedroptoggle_changed)
    { // WHOLEDROPDOWN
      wxCommandEvent ev(mmEVT_WHOLEDROP_TOGGLE,GetId());
      GetEventHandler()->ProcessEvent(ev);
    }
    if (droptoggle_changed)
    { // DROPDOWN
      wxCommandEvent ev(mmEVT_DROP_TOGGLE,GetId());
      GetEventHandler()->ProcessEvent(ev);
    }
    if (selected_changed)
    { // SELECT
      wxCommandEvent ev(wxEVT_COMMAND_LEFT_CLICK,GetId());
      GetEventHandler()->ProcessEvent(ev);
    }
    if (mIsActivated)
    { // ACTIVATE
      wxCommandEvent ev(wxEVT_COMMAND_BUTTON_CLICKED,GetId());
      GetEventHandler()->ProcessEvent(ev);
    }
  } // if
  event.Skip();
} // OnMouse

void TileMapPanel::OnMouseEvent(wxMouseEvent &event)
{
    if(!m_tilemap || !m_tileset)
        return;

    //Get the current tile position (column and row)
    unsigned int currentColumn, currentRow;
    wxPoint mousePos = CalcUnscrolledPosition(event.GetPosition());
    GetTileAt(mousePos, currentColumn, currentRow);

    if(currentColumn >= m_tilemap->GetColumnsCount() || currentRow >= m_tilemap->GetRowsCount())
        return; //Stop if the position is out of range

    if(m_insertionMode == PencilMode)
    {
        if(event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_RIGHT_DOWN || event.GetEventType() == wxEVT_MOTION)
        {
            if(event.LeftIsDown()) //Left mouse button pressed
            {
                //Add a tile to the current position (only if the tile has not been set before)
                if(m_tilemap->GetTile(m_mapCurrentLayer, currentColumn, currentRow) != m_tileToBeInserted)
                    m_commandProcessor.Submit(new ChangeTileCommand(*m_tilemap, m_mapCurrentLayer, currentColumn, currentRow, m_tileToBeInserted));
                Refresh();
            }
            else if(event.RightIsDown())
            {
                //Remove the tile
                m_commandProcessor.Submit(new ChangeTileCommand(*m_tilemap, m_mapCurrentLayer, currentColumn, currentRow, -1));
                Refresh();
            }
        }
    }
    else if(m_insertionMode == RectangleMode)
    {
        if(event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_RIGHT_DOWN)
        {
            m_isDrawingRectangle = true;
            m_beginCol = m_endCol = currentColumn;
            m_beginRow = m_endRow = currentRow;

            Update();
        }
        else if(event.GetEventType() == wxEVT_MOTION)
        {
            m_endCol = currentColumn;
            m_endRow = currentRow;
            Update();
        }
        else if(event.GetEventType() == wxEVT_LEFT_UP)
        {
            m_endCol = currentColumn;
            m_endRow = currentRow;
            m_isDrawingRectangle = false;

            m_commandProcessor.Submit(new ChangeTileCommand(*m_tilemap, m_mapCurrentLayer, std::min(m_beginCol, m_endCol),
                                                                                           std::min(m_beginRow, m_endRow),
                                                                                           std::max(m_beginCol, m_endCol),
                                                                                           std::max(m_beginRow, m_endRow),
                                                                                           m_tileToBeInserted));

            Update();
        }
        else if(event.GetEventType() == wxEVT_RIGHT_UP)
        {
            m_endCol = currentColumn;
            m_endRow = currentRow;
            m_isDrawingRectangle = false;

            m_commandProcessor.Submit(new ChangeTileCommand(*m_tilemap, m_mapCurrentLayer, std::min(m_beginCol, m_endCol),
                                                                                           std::min(m_beginRow, m_endRow),
                                                                                           std::max(m_beginCol, m_endCol),
                                                                                           std::max(m_beginRow, m_endRow),
                                                                                           -1));

            Update();
        }
    }
    else if(m_insertionMode == FillMode)
    {
        if(event.GetEventType() == wxEVT_LEFT_DOWN)
        {
            m_commandProcessor.Submit(new FloodFillCommand(*m_tilemap, m_mapCurrentLayer, currentColumn, currentRow, m_tileToBeInserted));

            Update();
        }
    }
}