Пример #1
0
	void ModalLayer::_onMsg( const Msg_p& _pMsg )
	{
		Layer::_onMsg(_pMsg);
	
		if( !m_modalHooks.isEmpty() && _findWidget( _pMsg->pointerPos(), WG_SEARCH_ACTION_TARGET ) == this )
		{
			switch( _pMsg->type() )
			{
				case WG_MSG_MOUSE_PRESS:
				{
					MouseButtonMsg_p pMsg = MouseButtonMsg::cast(_pMsg);
					Base::msgRouter()->post( new ModalBlockedPressMsg( pMsg->button(), this) );
				}
				break;
	
				case WG_MSG_MOUSE_RELEASE:
				{
					MouseButtonMsg_p pMsg = MouseButtonMsg::cast(_pMsg);
					Base::msgRouter()->post( new ModalBlockedPressMsg( pMsg->button(), this) );
				}
				break;
	
				case WG_MSG_MOUSE_MOVE:
				{
					Base::msgRouter()->post( new ModalMoveOutsideMsg(this) );
				}
				break;
			}
		}	
	}
Пример #2
0
void MsgRouter::_dispatchQueued()
{
    while( !m_msgQueue.empty() )
    {
        Msg_p pMsg = m_msgQueue.front();
        m_insertPos = m_msgQueue.begin()+1;	// Insert position set to right after current event.

        do
        {
            if( pMsg->hasCopyTo()  )
                pMsg->getCopyTo()->receive( pMsg );

            if( pMsg->hasSource() )
                _dispatchToSourceRoutes( pMsg );

            _dispatchToTypeRoutes( pMsg );
            _broadcast( pMsg );
        }
        while( pMsg->doRepost() );

        m_msgQueue.pop_front();
    }

    m_insertPos = m_msgQueue.begin();		// Insert position set right to start.
}
Пример #3
0
	void Menubar::_receive( const Msg_p& pMsg )
	{
		Widget::_receive(pMsg);
	
		switch( pMsg->type() )
		{
			case MsgType::MouseMove:
			case MsgType::MousePress:
			{
				Coord pos = InputMsg::cast(pMsg)->pointerPos() - globalPos();
	
				uint32_t item = _getItemAtAbsPos( pos.x, pos.y );
	
				if( item && !m_items.get(item-1)->m_bEnabled )
					item = 0;								// Item is disabled and can't be marked.
	
				if(m_markedItem != item)
				{
					m_markedItem = item;
					_requestRender();
				}
	
				// If a menu entry already is selected we should
				// switch to the new marked one.
	
				if( m_selectedItem )
				{
					if( m_markedItem && m_selectedItem != m_markedItem )
					{
						_closeMenu( m_selectedItem );
						_openMenu( m_markedItem );
					}
				}
	
				// If this was a press, we need to select the item and open the menu.
	
				//TODO: A click on an already open entry should close the menu.
	
				if( item && pMsg->type()== MsgType::MousePress )
				{
					_openMenu( item );
				}
	
			}
	
			case MsgType::MouseLeave:
				m_markedItem = 0;
				_requestRender();
			break;
	
		}
	}
Пример #4
0
	bool MsgFilter::_filterType( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
			return true;
	
		return false;
	}
Пример #5
0
	void TextEditor::_receive( const Msg_p& pMsg )
	{
		MsgType type = pMsg->type();

		Widget::_receive( pMsg );
		m_text.receive( pMsg );	
	}
Пример #6
0
	string MsgLogger::_formatCopyTo( const Msg_p& _pMsg ) const
	{
		std::string	out;
	
		if( _pMsg->hasCopyTo() )
		{
			char	temp[64];
			Receiver * pCopyTo = _pMsg->getCopyTo().rawPtr();
	
			const char * pType = pCopyTo->className();
	
			sprintf( temp, " copyTo=%p (%s)", pCopyTo, pType );
			out = temp;
		}
	
		return out;
	}
Пример #7
0
void MsgRouter::_dispatchToSourceRoutes( const Msg_p& pMsg )
{
    Object * pSource = pMsg->sourceRawPtr();

    if( pSource )
    {
        auto it = m_sourceRoutes.find(Object_wp(pSource));
        if( it != m_sourceRoutes.end() )
        {
            Route * pRoute = it->second.first();
            while( pRoute )
            {
                if( pRoute->m_filter == MsgType::Dummy || pRoute->m_filter == pMsg->type() )
                    pRoute->dispatch( pMsg );
                pRoute = pRoute->next();
            }
        }
    }
}
Пример #8
0
	bool MsgFilter::_filterWheelRollMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			int chr = WheelRollMsg::cast(pMsg)->wheel();
	
			if( chr == filter.m_data1 )
				return true;
		}
		return false;
	}
Пример #9
0
	bool MsgFilter::_filterNativeKeyMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			KeyMsg_p p = KeyMsg::cast(pMsg);
	
			if( p->nativeKeyCode() == filter.m_data1 )
				return true;
		}
		return false;
	}
Пример #10
0
	bool MsgFilter::_filterCharacterMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			int chr = CharacterMsg::cast(pMsg)->character();
	
			if( chr == filter.m_data1 )
				return true;
		}
		return false;
	}
Пример #11
0
	bool MsgFilter::_filterItemToggleMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			int itemId = ItemToggleMsg::cast(pMsg)->itemId();
	
			if( itemId == filter.m_data1 )
				return true;
		}
		return false;
	}
Пример #12
0
	string MsgLogger::_formatSource( const Msg_p& _pMsg ) const
	{
		std::string	out;
	
		if( _pMsg->sourceRawPtr() )
		{
			char	temp[64];
			Object * pObject = _pMsg->sourceRawPtr();
	
			static const char def_type[] = "deleted";
			const char * pType = def_type;
	
			if( pObject )
				pType = pObject->className();
	
			sprintf( temp, " source=%p (%s)", pObject, pType );
			out = temp;
		}
	
		return out;
	}
Пример #13
0
	bool MsgFilter::_filterItemMousePressMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			ItemMousePressMsg_p pMsg = ItemMousePressMsg::cast(pMsg);
	
			if( (filter.m_data1 == -1 || pMsg->itemId() == filter.m_data1) ||
				(filter.m_data2 == -1 || pMsg->button() == filter.m_data2) )
				return true;
		}
		return false;
	}
Пример #14
0
	void InputHandler::receive( const Msg_p& pMsg )
	{
		
		if( pMsg->type() == MsgType::Tick ) {
					
			int64_t timestamp = TickMsg::cast(pMsg)->timestamp();
	
			_handleButtonRepeats( timestamp );
			_handleKeyRepeats( timestamp );

			m_timeStamp = timestamp;			
		}		
	}
Пример #15
0
void MsgRouter::_dispatchToTypeRoutes( const Msg_p& pMsg )
{
    auto it = m_typeRoutes.find(pMsg->type());
    if( it != m_typeRoutes.end() )
    {
        Route * pRoute = it->second.first();

        while( pRoute )
        {
            pRoute->dispatch( pMsg );
            pRoute = pRoute->next();
        }
    }
}
Пример #16
0
	void MsgRouter::_finalizeMsg( const Msg_p& pMsg )
	{
		// Fill in missing information in the event-class.
	
		pMsg->m_timestamp	= m_time;
		pMsg->m_modKeys	= m_modKeys;
	
		// Only global POINTER_ENTER & POINTER_MOVE events have these members
		// set, the rest needs to have them filled in.
	
		if( pMsg->hasCopyTo() || (pMsg->type() != WG_MSG_MOUSE_MOVE && pMsg->type() != WG_MSG_MOUSE_ENTER) )
		{
			pMsg->m_pointerPos = m_pointerPos;
		}
	
		// Msg specific finalizations
	
		switch( pMsg->type() )
		{
	
			// Key events need translation of keycodes.
	
			case WG_MSG_KEY_PRESS:
			case WG_MSG_KEY_RELEASE:
			case WG_MSG_KEY_REPEAT:
			{
				KeyMsg* p = static_cast<KeyMsg*>(pMsg.rawPtr());
				p->m_translatedKeyCode = Base::translateKey(p->m_nativeKeyCode);
			}
			break;
	
	
			default:
				break;
		}
	
	}
Пример #17
0
	bool MsgFilter::_filterMouseButtonMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			if( filter.m_data1 == 0 )
				return true;
			else
			{
				MouseButtonMsg_p p = MouseButtonMsg::cast(pMsg);
	
				if( p->button() == filter.m_data1 )
					return true;
			}
		}
		return false;
	}
Пример #18
0
	bool MsgFilter::_filterKeyMsgs( const Msg_p& pMsg, const MsgFilter& filter )
	{
		if( pMsg->type() == filter.msgType() )
		{
			if( filter.m_data1 == 0 )
				return true;
			else
			{
				KeyMsg_p p = KeyMsg::cast(pMsg);
	
				if( p->translatedKeyCode() == filter.m_data1 )
					return true;
			}
		}
		return false;
	}
Пример #19
0
	void AnimPlayer::_onMsg( const Msg_p& pMsg )
	{
		Widget::_onMsg( pMsg );
	
		switch( pMsg->type() )
		{
			case WG_MSG_TICK:
			{
				if( !m_pAnim || !m_state.isEnabled() )
					return;
	
				m_playPos += TickMsg::cast(pMsg)->millisec() * m_speed;
				_playPosUpdated();
	
			}
			break;
		}
	}
Пример #20
0
void cbDragWidget( const Msg_p& _pMsg, const Object_p& pObject )
{
	Widget_p pWidget = Widget::cast(pObject);
	
	if( _pMsg->type() != WG_MSG_MOUSE_DRAG || !pWidget->parent() )
		return;

	const MouseDragMsg_p pMsg = MouseDragMsg::cast(_pMsg);



	Coord	dragDistance = pMsg->draggedTotal();

	Coord	ofs = dragStartPos + dragDistance;

//	printf( "AccDistance: %d, %d\n", dragDistance.x, dragDistance.y );
	printf( "ofs: %d, %d   start: %d %d   distance: %d, %d\n", ofs.x, ofs.y, dragStartPos.x, dragStartPos.y, dragDistance.x, dragDistance.y );

	FlexHook_p pHook = FlexHook::cast(pWidget->hook());
	pHook->setOfs(dragStartPos+dragDistance);
}
Пример #21
0
void cbMoveResize( const Msg_p& _pMsg, const Object_p& _pWidget )
{
	static Coord posAtPress[MouseButton_Max];
	
	auto	pWidget = Widget::cast(_pWidget);
	FlexHook_p 	pHook = FlexHook::cast(pWidget->hook());

	switch( _pMsg->type() )
	{
		case MsgType::MousePress:
		{
			auto pMsg = MousePressMsg::cast(_pMsg);
			posAtPress[(int)pMsg->button()] = pWidget->pos();
			
		}
		break;
		case MsgType::MouseDrag:
		{
			auto pMsg = MouseDragMsg::cast(_pMsg);
			if( pMsg->button() == MouseButton::Right )
			{
				pHook->setSize( pHook->size() + pMsg->draggedNow().toSize() );
			}
			else if( pMsg->button() == MouseButton::Middle )
			{
				pHook->setOfs( posAtPress[(int)MouseButton::Middle] + pMsg->draggedTotal() );
			}
		}
		break;
		case MsgType::MouseRelease:
		break;
		
		default:
		break;
	}
}
Пример #22
0
	void FpsDisplay::_onMsg( const Msg_p& pMsg )
	{
		Widget::_onMsg(pMsg);
	
		switch( pMsg->type() )
		{
			case WG_MSG_TICK:
			{
				// Update tick buffer
	
				m_tickBufferOfs = (++m_tickBufferOfs) % TICK_BUFFER;
	
				int msDiff = TickMsg::cast(pMsg)->millisec();
				if( msDiff > 0 )
					m_pTickBuffer[m_tickBufferOfs] = msDiff;
				else
					m_pTickBuffer[m_tickBufferOfs] = 1;
	
				// Update valueTexts from tick-buffer
	
				const int	cCurrentFrames = 10;
				int currOfs = ((int)m_tickBufferOfs) - cCurrentFrames;
				if( currOfs < 0 )
					currOfs += TICK_BUFFER;
	
				int	currTotal = 0;
				for( int i = 0 ; i < cCurrentFrames ; i++ )
				{
					currTotal += m_pTickBuffer[currOfs++];
					currOfs %= TICK_BUFFER;
				}
				float	fpsCurrent = 1000.f / (currTotal / (float) cCurrentFrames);
	
				//____
	
				int	avg = 0;
				for( int i = 0 ; i < TICK_BUFFER ; i++ )
					avg += m_pTickBuffer[i];
				float fpsAvg = 1000.f / (((float)avg)/TICK_BUFFER);
	
				//____
	
				int	min = 1000000000;
				for( int i = 0 ; i < TICK_BUFFER ; i++ )
					if( min > m_pTickBuffer[i] )
						min = m_pTickBuffer[i];
				float fpsMax = 1000.f / min;
	
				//____
	
				int	max = 0;
				for( int i = 0 ; i < TICK_BUFFER ; i++ )
					if( max < m_pTickBuffer[i] )
						max = m_pTickBuffer[i];
				float fpsMin = 1000.f / max;
	
				//____
		
				char	temp[100];
				sprintf( temp, "%.2f/n%.2f/n%.2f/n%.2f/n", fpsCurrent, fpsMin, fpsAvg, fpsMax );
				m_valuesText.set(temp);
	
				_requestRender();
			}
			default:
				break;
		}
	}
Пример #23
0
void LegacyTextEditor::_onMsg( const Msg_p& pMsg )
{
    Widget::_onMsg(pMsg);

    MsgType type 				= pMsg->type();

    if( type == MsgType::Tick )
    {
        if( isSelectable() && m_state.isFocused() )
        {
            m_text.incTime( TickMsg::cast(pMsg)->timediff() );
            _requestRender();					//TODO: Should only render the cursor and selection!
        }
        return;
    }



    if( m_state.isFocused() && (type == MsgType::MousePress || type == MsgType::MouseDrag) && MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
    {
        MouseButtonMsg_p p = MouseButtonMsg::cast(pMsg);

        ModifierKeys modKeys 	= p->modKeys();
        Coord pointerPos = p->pointerPos();

        if( isSelectable() && (modKeys & MODKEY_SHIFT) )
        {
            m_text.setSelectionMode(true);
        }

        m_text.cursorGotoCoord( pointerPos, globalGeo() );

        if(isSelectable() && type == MsgType::MousePress && !(modKeys & MODKEY_SHIFT))
        {
            m_text.clearSelection();
            m_text.setSelectionMode(true);
        }
    }
    else if( type == MsgType::MouseRelease  )
    {
        if(m_state.isFocused() && MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left)
            m_text.setSelectionMode(false);
    }
    else if( !m_state.isFocused() && isEditable() && type == MsgType::MousePress && MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
    {
        grabFocus();
    }


    if( type == MsgType::TextInput )
    {
        if( isEditable() )
        {
            String text = TextInputMsg::cast(pMsg)->text();

            for( int i = 0 ; i < text.length() ; i++ )
            {
                unsigned short chr = text.chars()[i].getGlyph();

                if( chr >= 32 && chr != 127)
                {
                    _insertCharAtCursor(chr);
                }
                else if( chr == 13 )
                {
                    _insertCharAtCursor('\n');
                }
                else if( chr == '\t' && m_bTabLock )
                {
                    _insertCharAtCursor( '\t' );
                }
            }
        }
    }

    if( type == MsgType::KeyRelease )
    {
        switch( KeyMsg::cast(pMsg)->translatedKeyCode() )
        {
        case Key::Shift:
            if(!Base::inputHandler()->isButtonPressed(MouseButton::Left))
                m_text.setSelectionMode(false);
            break;
        }
    }

    if( (type == MsgType::KeyPress || type == MsgType::KeyRepeat) && isEditable() )
    {
        KeyMsg_p p = KeyMsg::cast(pMsg);
        ModifierKeys modKeys = p->modKeys();

        switch( p->translatedKeyCode() )
        {
        case Key::Left:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            if( modKeys & MODKEY_CTRL )
                m_text.gotoPrevWord();
            else
                m_text.goLeft();
            break;
        case Key::Right:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            if( modKeys & MODKEY_CTRL )
                m_text.gotoNextWord();
            else
                m_text.goRight();
            break;

        case Key::Up:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            m_text.cursorGoUp( 1, globalGeo() );
            break;

        case Key::Down:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            m_text.cursorGoDown( 1, globalGeo() );
            break;

        case Key::Backspace:
            if(m_text.hasSelection())
                m_text.delSelection();
            else if( modKeys & MODKEY_CTRL )
                m_text.delPrevWord();
            else
                m_text.delPrevChar();
            break;

        case Key::Delete:
            if(m_text.hasSelection())
                m_text.delSelection();
            else if( modKeys & MODKEY_CTRL )
                m_text.delNextWord();
            else
                m_text.delNextChar();
            break;

        case Key::Home:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            if( modKeys & MODKEY_CTRL )
                m_text.goBot();
            else
                m_text.goBol();
            break;

        case Key::End:
            if( modKeys & MODKEY_SHIFT )
                m_text.setSelectionMode(true);

            if( modKeys & MODKEY_CTRL )
                m_text.goEot();
            else
                m_text.goEol();
            break;

        default:
            break;
        }
    }

    // Let text object handle its actions.
    /*
    	bool bChanged = m_text.onAction( action, button_key, globalGeo(), Coord(info.x, info.y) );
    	if( bChanged )
    		RequestRender();
    */

    // Swallow message depending on rules.

    if( pMsg->isMouseButtonMsg() && isSelectable() )
    {
        if( MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
            pMsg->swallow();
    }
    else if( pMsg->isKeyMsg() && isEditable() )
    {
        Key key = KeyMsg::cast(pMsg)->translatedKeyCode();
        if( KeyMsg::cast(pMsg)->isMovementKey() == true ||
                key == Key::Delete || key == Key::Backspace || key == Key::Return || (key == Key::Tab && m_bTabLock) )
            pMsg->swallow();

        //TODO: Would be good if we didn't forward any character-creating keys either...
    }
    else if( type == MsgType::TextInput )
        pMsg->swallow();
}
Пример #24
0
	void LineEditor::_receive( const Msg_p& pMsg )
	{
		Widget::_receive(pMsg);
	
		MsgRouter_p	pHandler = Base::msgRouter();
		MsgType event = pMsg->type();
	
		if( event == MsgType::Tick )
		{
			if( _isSelectable() && m_state.isFocused() )
			{
				m_text.incTime( TickMsg::cast(pMsg)->timediff() );
				_requestRender();					//TODO: Should only render the cursor and selection!
			}
			return;
		}
	
		if( (event == MsgType::MousePress || event == MsgType::MouseDrag) && MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
		{
			MouseButtonMsg_p pButtonMsg = MouseButtonMsg::cast(pMsg);
			
			if( !m_state.isFocused() )
				grabFocus();
	
			if( m_state.isFocused() )
			{
				if( _isSelectable() && (pButtonMsg->modKeys() & MODKEY_SHIFT) )
				{
					m_text.setSelectionMode(true);
				}
	
				Coord ofs = pButtonMsg->pointerPos() - globalPos();
				int x = ofs.x + m_viewOfs;
				int y = 0;
	
				if( m_bPasswordMode )
				{
					TextAttr	attr;
					m_text.getBaseAttr( attr );
	
					Pen	pen;
					pen.setAttributes( attr );
					pen.setChar(m_pwGlyph);
					pen.advancePos();
	
					int spacing = pen.getPosX();
					int height = pen.getLineSpacing();
	
					int line = y/height;
					int col = (x+spacing/2)/spacing;
					if(col < 0)
					{
						col = 0;
						line = 0;
					}
					m_text.gotoSoftPos(line,col);
				}
				else
				{
					m_text.cursorGotoCoord( Coord(x, 0), Rect(0,0,1000000,1000000) );
				}
	
				if(_isSelectable() && event == MsgType::MousePress && !(pButtonMsg->modKeys() & MODKEY_SHIFT))
				{
					m_text.clearSelection();
					m_text.setSelectionMode(true);
				}
			}
			_adjustViewOfs();
		}
	
		if( event == MsgType::MouseRelease )
		{
			if( m_state.isFocused() && MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
				m_text.setSelectionMode(false);
		}		
	
		if( event == MsgType::TextInput )
		{
			String str = TextInputMsg::cast(pMsg)->text();
	
			if( _isEditable() && m_state.isFocused() )
			{
				if(m_text.hasSelection())
					m_text.delSelection();
				m_text.setSelectionMode(false);

				bool bModified = false;
				for( int i = 0 ; i < str.length() ; i++ )
				{
					unsigned short ch = str.chars()[i].getGlyph();
					
					if( ch >= 32 && ch != 127 )
					{
						if( m_text.putChar( ch ) )
							bModified = true;
					}
				}

				if( bModified )
				{
					if( pHandler )
						pHandler->post( new TextEditMsg(text.ptr(),false) );

					_adjustViewOfs();
				}
	
			}
		}
	
		if( event == MsgType::KeyRelease && m_state.isFocused() )
		{
			Key key = KeyMsg::cast(pMsg)->translatedKeyCode();
			switch( key )
			{
				case Key::Shift:
					if(!Base::inputHandler()->isButtonPressed(MouseButton::Left))
						m_text.setSelectionMode(false);
				break;
			}
		}
	
		if( (event == MsgType::KeyPress || event == MsgType::KeyRepeat) && _isEditable() && m_state.isFocused() )
		{
			KeyMsg_p pKeyMsg = KeyMsg::cast(pMsg);
			Key key = pKeyMsg->translatedKeyCode();
			switch( key )
			{
				case Key::Left:
					if( pKeyMsg->modKeys() & MODKEY_SHIFT )
						m_text.setSelectionMode(true);
	
					if( pKeyMsg->modKeys() & MODKEY_CTRL )
					{
						if( m_bPasswordMode )
							m_text.goBol();
						else
							m_text.gotoPrevWord();
					}
					else
					{
						m_text.goLeft();
					}
					break;
				case Key::Right:
					if( pKeyMsg->modKeys() & MODKEY_SHIFT )
						m_text.setSelectionMode(true);
	
					if( pKeyMsg->modKeys() & MODKEY_CTRL )
					{
						if( m_bPasswordMode )
							m_text.goEol();
						else
							m_text.gotoNextWord();
					}
					else
					{
						m_text.goRight();
					}
					break;
	
				case Key::Backspace:
				{
					if(m_text.hasSelection())
						m_text.delSelection();
					else if( (pKeyMsg->modKeys() & MODKEY_CTRL) && !m_bPasswordMode)
						m_text.delPrevWord();
					else
						m_text.delPrevChar();
	
					if( pHandler )
						pHandler->post( new TextEditMsg(text.ptr(),false) );
					break;
				}
	
				case Key::Delete:
				{
					if(m_text.hasSelection())
						m_text.delSelection();
					else if( (pKeyMsg->modKeys() & MODKEY_CTRL) && !m_bPasswordMode)
						m_text.delNextWord();
					else
						m_text.delNextChar();
	
					if( pHandler )
						pHandler->post( new TextEditMsg(text.ptr(),false) );
					break;
				}
	
				case Key::Home:
	
					/*
					 *	I am not sure if this is the proper way to this, but in my opinion, the default
					 *	"actions" has to be separated from any modifier key action combination
					 */
					switch( pKeyMsg->modKeys() )
					{
	
					case MODKEY_CTRL:
						break;
	
					default: // no modifier key was pressed
						if(pKeyMsg->modKeys() & MODKEY_SHIFT )
							m_text.setSelectionMode(true);
	
						m_text.goBol();
						break;
					}
	
					break;
	
				case Key::End:
	
					/*
				 	 *	I am not sure if this is the proper way to this, but in my opinion, the default
			 		 *	"actions" has to be separated from any modifier key action combination
					 */
					switch( pKeyMsg->modKeys() )
					{
	
					case MODKEY_CTRL:
						break;
	
					default: // no modifier key was pressed
						if( pKeyMsg->modKeys() & MODKEY_SHIFT )
							m_text.setSelectionMode(true);
	
						m_text.goEol();
						break;
					}
	
					break;
	
				default:
					break;
			}
			_adjustViewOfs();
		}
	
		// Swallow message depending on rules.
	
		if( pMsg->isMouseButtreceive() )
		{
			if( MouseButtonMsg::cast(pMsg)->button() == MouseButton::Left )
				pMsg->swallow();
		}
		else if( pMsg->isKeyMsg() )
		{
			Key key = KeyMsg::cast(pMsg)->translatedKeyCode();
			if( KeyMsg::cast(pMsg)->isMovementKey() == true ||
				key == Key::Delete || key == Key::Backspace )
					pMsg->swallow();
			
			//TODO: Would be good if we didn't forward any character-creating keys either...
		}
	}
Пример #25
0
	void MsgLogger::receive( const Msg_p& _pMsg )
	{
		if( m_msgFilter[(int)_pMsg->type()] == false )
			return;
	
		string	source;
		string	copyTo;
	
		char	params[256]; params[0] = 0;			// Msg specific parameters
	
		
		switch( _pMsg->type() )
		{
			case MsgType::Dummy:
				break;
			case MsgType::Tick:
				sprintf( params, " millisec=%d", TickMsg::cast(_pMsg)->timediff() );
				break;
			case MsgType::PointerChange:
				sprintf( params, " style=%s", _formatPointerStyle( PointerChangeMsg::cast(_pMsg)).c_str() );
				break;
			case MsgType::MouseEnter:
				break;
			case MsgType::MouseMove:
				break;
			case MsgType::MouseLeave:
				break;
			case MsgType::MousePress:
				sprintf( params, " button=%s", _formatMouseButton(MousePressMsg::cast(_pMsg)->button()).c_str() );
				break;
			case MsgType::MouseRepeat:
				sprintf( params, " button=%s", _formatMouseButton(MouseRepeatMsg::cast(_pMsg)->button()).c_str() );
				break;
			case MsgType::MouseDrag:
			{
				MouseDragMsg_p pMsg = MouseDragMsg::cast(_pMsg);
	
				Coord	now		= pMsg->currPos();
				Coord 	prev	= pMsg->prevPos();
				Coord	start	= pMsg->startPos();
	
				Coord	dragNow	= pMsg->draggedNow();
				Coord	dragTotal=pMsg->draggedTotal();
	
				sprintf( params, " button=%s position(start=%d,%d prev=%d,%d now=%d,%d) dragged(now=%d,%d total=%d,%d)",
						_formatMouseButton(pMsg->button()).c_str(), start.x, start.y, prev.x, prev.y, now.x, now.y, dragNow.x, dragNow.y, dragTotal.x, dragTotal.y );
				break;
			}
			case MsgType::MouseRelease:
			{
				MouseReleaseMsg_p pMsg = MouseReleaseMsg::cast(_pMsg);
	
				const static char outside[] = "outside";
				const static char inside[] = "inside";
				const char * pPress = outside;
				const char * pRelease = outside;
		
				if( pMsg->releaseInside() )
					pRelease = inside;
	
				sprintf( params, " button=%s release=%s", _formatMouseButton(pMsg->button()).c_str(), pRelease );
				break;
			}
			case MsgType::MouseClick:
				sprintf( params, " button=%s", _formatMouseButton(MouseClickMsg::cast(_pMsg)->button()).c_str() );
				break;
			case MsgType::MouseDoubleClick:
				sprintf( params, " button=%s", _formatMouseButton(MouseDoubleClickMsg::cast(_pMsg)->button()).c_str() );
				break;
	
			case MsgType::KeyPress:
			{
				KeyPressMsg_p pMsg = KeyPressMsg::cast(_pMsg);
				sprintf( params, " wg_keycode=%d native_keycode=%d", pMsg->translatedKeyCode(), pMsg->nativeKeyCode() );
				break;
			}
			case MsgType::KeyRepeat:
			{
				KeyRepeatMsg_p pMsg = KeyRepeatMsg::cast(_pMsg);
				sprintf( params, " wg_keycode=%d native_keycode=%d", pMsg->translatedKeyCode(), pMsg->nativeKeyCode() );
				break;
			}
			case MsgType::KeyRelease:
			{
				KeyReleaseMsg_p pMsg = KeyReleaseMsg::cast(_pMsg);
				sprintf( params, " wg_keycode=%d native_keycode=%d", pMsg->translatedKeyCode(), pMsg->nativeKeyCode() );
				break;
			}
			case MsgType::TextInput:
				sprintf( params, " chars=%s", TextInputMsg::cast(_pMsg)->text().chars() );
				break;
				
			case MsgType::EditCommand:
				sprintf( params, " cmd=%s", _formatEditCommand(EditCommandMsg::cast(_pMsg)->command()).c_str() );
				break;
				
			case MsgType::WheelRoll:
			{
				WheelRollMsg_p pMsg = WheelRollMsg::cast(_pMsg);
				sprintf( params, "wheel=%d distance=(%d,%d)", pMsg->wheel(), pMsg->distance().x, pMsg->distance().y );
				break;
			}
	
			case MsgType::Select:
				break;
	
			case MsgType::Toggle:
				sprintf( params, " set=%d", (int) (ToggleMsg::cast(_pMsg)->isSet()) );
				break;
	
			case MsgType::ValueUpdate:
			{
				ValueUpdateMsg_p pMsg = ValueUpdateMsg::cast(_pMsg);
				sprintf( params, " value=%ld fraction=%f", pMsg->value(), pMsg->fraction() );
				break;
			}
	
			case MsgType::RangeUpdate:
			{
				RangeUpdateMsg_p pMsg = RangeUpdateMsg::cast(_pMsg);
				sprintf( params, " offset=%d length=%d fracOfs=%f fracLen=%f final=%s", pMsg->offset(), pMsg->length(), pMsg->fracOffset(), pMsg->fracLength(), pMsg->isFinal()?"true":"false" );
				break;
			}
	
			case MsgType::TextEdit:
			{
				TextEditMsg_p pMsg = TextEditMsg::cast(_pMsg);
				break;
			}
	
			case MsgType::ItemToggle:
			{
				ItemToggleMsg_p pMsg = ItemToggleMsg::cast(_pMsg);
				sprintf( params, " set=%s id=%d object=%p", pMsg->isSet()?"true":"false", pMsg->itemId(), pMsg->itemObject().rawPtr() );
				break;
			}
			case MsgType::ItemMousePress:
			{
				ItemMousePressMsg_p pMsg = ItemMousePressMsg::cast(_pMsg);
				sprintf( params, " id=%d mouseButton=%s", pMsg->itemId(), _formatMouseButton(pMsg->button()).c_str() );
				break;
			}
					
			case MsgType::ItemsSelect:
			{
				ItemsSelectMsg_p pMsg = ItemsSelectMsg::cast(_pMsg);
				sprintf( params, " nbItems=%d", pMsg->nbItems() );
				break;
			}
	
			case MsgType::ItemsUnselect:
			{
				ItemsUnselectMsg_p pMsg = ItemsUnselectMsg::cast(_pMsg);
				sprintf( params, " nbItems=%d", pMsg->nbItems() );
				break;
			}

			case MsgType::LinkMouseEnter:
			case MsgType::LinkMouseLeave:
			case MsgType::LinkSelect:
			{
				LinkMsg_p pMsg = LinkMsg::cast(_pMsg);
				sprintf( params, " link=%p string=\"%s\"", pMsg->link().rawPtr(), pMsg->link()->link().c_str() );
				break;
			}

			case MsgType::LinkMousePress:
			case MsgType::LinkMouseRepeat:
			case MsgType::LinkMouseRelease:
			case MsgType::LinkMouseClick:
			case MsgType::LinkMouseDoubleClick:
			{
				LinkMouseButtonMsg_p pMsg = LinkMouseButtonMsg::cast(_pMsg);
				sprintf( params, " link=%p button=%s", pMsg->link().rawPtr(), _formatMouseButton(pMsg->button()).c_str() );
				break;
			}
			case MsgType::ModalMoveOutside:
				break;
			case MsgType::ModalBlockedPress:
				sprintf( params, " button=%s", _formatMouseButton(ModalBlockedPressMsg::cast(_pMsg)->button()).c_str() );
				break;
			case MsgType::ModalBlockedRelease:
				sprintf( params, " button=%s", _formatMouseButton(ModalBlockedReleaseMsg::cast(_pMsg)->button()).c_str() );
				break;
	
			default:
				break;
		};
	
		source = _formatSource( _pMsg );
		copyTo = _formatCopyTo( _pMsg );

		string	timestamp;
		string	modkeys;
		string	pointerPos;

		if( _pMsg->isInstanceOf( InputMsg::CLASSNAME ) )
		{
			InputMsg_p p = InputMsg::cast(_pMsg);
			timestamp = _formatTimestamp( p->timestamp() );
			modkeys = _formatModkeys( p );
			pointerPos = _formatPointerPos( p );
		}
		
		m_out << " - " << _pMsg->className() << " - " << source << copyTo << pointerPos << modkeys << params;
		m_out << std::endl;
	}
Пример #26
0
	void TestWidget::_receive( const Msg_p& pMsg )
	{
		switch( pMsg->type() )
		{
			case MsgType::Tick:
			{
                const TickMsg_p pTick = TickMsg::cast(pMsg);
				
				Rect area( 0,0, size() );
				
				
				if( !m_bPointsInitialized )
				{
					for( int i = 0 ; i < 2 ; i+=2 )
					{
						Coord& c = m_coord[i];
						
						c.x = 0;
						c.y = 0;

						c = m_coord[i+1];

						c.x = 100000;
						c.y = 100000;
						
					}
					m_bPointsInitialized = true;
				}
				
				
				for( int i = 0 ; i < 2 ; i++ )
				{
					Coord& c = m_coord[i];
					
					if( c.x < area.x )
						c.x = area.x;
						
					if( c.y < area.y )
						c.y = area.y;

					if( c.x > area.x + area.w )
						c.x = area.x + area.w;

					if( c.y > area.y + area.h )
						c.y = area.y + area.h;					

					
					
					if( (c.y == area.y) && (c.x < area.x + area.w) )
						c.x++;
					else if( (c.x == area.x + area.w) && (c.y < area.y + area.h) )
						c.y++;
					else if( (c.y == area.y + area.h) && (c.x > area.x) )
						c.x--;
					else
						c.y--;
				}
				
				_requestRender();

			}
			break;

			default:
			break;
		}
	}
Пример #27
0
void Button::_receive( const Msg_p& _pMsg )
{
    State state = m_state;
    MsgRouter_p	pHandler = Base::msgRouter();

    switch( _pMsg->type() )
    {
    case MsgType::KeyPress:
        if( KeyPressMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
        {
            m_bReturnPressed = true;
            _pMsg->swallow();
        }
        break;

    case MsgType::KeyRepeat:
        if( KeyRepeatMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
            _pMsg->swallow();
        break;

    case MsgType::KeyRelease:
        if( KeyReleaseMsg::cast(_pMsg)->translatedKeyCode() == Key::Return )
        {
            m_bReturnPressed = false;
            pHandler->post( new SelectMsg(this) );
            _pMsg->swallow();
        }
        break;

    case MsgType::MouseEnter:
        state.setHovered(true);
        break;
    case MsgType::MouseLeave:
        state.setHovered(false);
        break;
    case MsgType::MousePress:
        if( MousePressMsg::cast(_pMsg)->button() == MouseButton::Left )
        {
            m_bPressed = true;
            _pMsg->swallow();
        }
        break;
    case MsgType::MouseRelease:
        if( MouseReleaseMsg::cast(_pMsg)->button() == MouseButton::Left )
        {
            m_bPressed = false;
            _pMsg->swallow();
        }
        break;
    case MsgType::MouseClick:
        if( MouseClickMsg::cast(_pMsg)->button() == MouseButton::Left )
        {
            pHandler->post( new SelectMsg(this) );
            _pMsg->swallow();
        }
        break;
    case MsgType::MouseDoubleClick:
    case MsgType::MouseRepeat:
    case MsgType::MouseDrag:
        if( MouseButtonMsg::cast(_pMsg)->button() == MouseButton::Left )
            _pMsg->swallow();
        break;

    case MsgType::FocusGained:
        state.setFocused(true);
        break;
    case MsgType::FocusLost:
        state.setFocused(false);
        m_bReturnPressed = false;
        m_bPressed = false;
        break;

    default:
        break;
    }


    if( m_bReturnPressed || (m_bPressed && (m_bDownOutside || state.isHovered() )) )
        state.setPressed(true);
    else
        state.setPressed(false);

    if( state != m_state )
        _setState(state);
}