コード例 #1
0
/**
 * @brief Handles an input event in this phase.
 * @param event the event
 */
void SelectionMenuConfirmErase::notify_event(InputEvent &event) {

  if (event.is_keyboard_key_pressed(validation_keys)) { // to erase a savegame file we don't allow joypad buttons

    int cursor_position = menu->get_cursor_position();

    if (cursor_position == 5) {
      // the user chose "Yes"
      menu->play_erase_sound();
      delete_save_file(save_number_to_erase);
      menu->set_next_phase(new SelectionMenuSelectFile(menu, save_number_to_erase + 1));
    }
    else if (cursor_position == 4) {
      // the user chose "No"
      menu->play_ok_sound();
      menu->set_next_phase(new SelectionMenuSelectFile(menu, 4));
    }
  }

  if (event.is_direction_pressed()
      && event.get_direction() % 4 == 0) { // right or left

    menu->move_cursor_left_or_right();
  }
}
コード例 #2
0
	bool FrameTrigger::isTriggerInputEventEquivalentTo(InputEvent inputEventReceived)
	{
		//Compare trigger input event with the one received
		std::string inputEventReceivedMedium = inputEventReceived.getMedium();
		std::string inputEventReceivedMode = inputEventReceived.getMode();
		std::string inputEventReceivedTokens = inputEventReceived.getTokens();

		std::transform(inputEventReceivedMedium.begin(), inputEventReceivedMedium.end(), inputEventReceivedMedium.begin(), ::tolower);
		std::transform(inputEventReceivedMode.begin(), inputEventReceivedMode.end(), inputEventReceivedMode.begin(), ::tolower);
		std::transform(inputEventReceivedTokens.begin(), inputEventReceivedTokens.end(), inputEventReceivedTokens.begin(), ::tolower);

		std::string triggerInputEventMedium = triggerInputEvent.getMedium();
		std::string triggerInputEventMode = triggerInputEvent.getMode();
		std::string triggerInputEventTokens = triggerInputEvent.getTokens();

		std::transform(triggerInputEventMedium.begin(), triggerInputEventMedium.end(), triggerInputEventMedium.begin(), ::tolower);
		std::transform(triggerInputEventMode.begin(), triggerInputEventMode.end(), triggerInputEventMode.begin(), ::tolower);
		std::transform(triggerInputEventTokens.begin(), triggerInputEventTokens.end(), triggerInputEventTokens.begin(), ::tolower);

		bool result = (inputEventReceivedMedium == triggerInputEventMedium) &&
			(inputEventReceivedMode == triggerInputEventMode) &&
			(inputEventReceivedTokens == triggerInputEventTokens);

		return result;
	}
コード例 #3
0
void CoreServices::handleEvent(Event *event) {
	if(event->getDispatcher() == core->getInput()) {
		InputEvent *inputEvent = (InputEvent*)event;
		switch(event->getEventCode()) {
			case InputEvent::EVENT_KEYDOWN:
			case InputEvent::EVENT_KEYUP:
				dispatchEvent(new InputEvent(inputEvent->key, inputEvent->charCode, inputEvent->timestamp), inputEvent->getEventCode());			
			break;
			case InputEvent::EVENT_TOUCHES_BEGAN:
			case InputEvent::EVENT_TOUCHES_ENDED:
			case InputEvent::EVENT_TOUCHES_MOVED:						
			{
				InputEvent *event = new InputEvent();
				event->touches = inputEvent->touches;
				event->timestamp = inputEvent->timestamp;
				dispatchEvent(event, inputEvent->getEventCode());
			}
			break;
			default:
				InputEvent *_inputEvent = new InputEvent(inputEvent->mousePosition, inputEvent->timestamp);
				_inputEvent->mouseButton = inputEvent->mouseButton;
				dispatchEvent(_inputEvent, inputEvent->getEventCode());			
			break;
		}
	}
}
コード例 #4
0
ファイル: InputManager.cpp プロジェクト: lince/ginga-srpp
	void InputManager::run() {
		InputEvent* inputEvent;

		while (running && eventBuffer != NULL) {
			eventBuffer->waitEvent();
			if (!running) {
				break;
			}

			inputEvent = eventBuffer->getNextEvent();
			while (inputEvent != NULL) {
				if (inputEvent->isPressedType() &&
						((getCurrentTimeMillis() - timeStamp) > 150)) {

					timeStamp = getCurrentTimeMillis();
					if (!dispatchEvent(inputEvent)) {
						delete inputEvent;
						inputEvent = eventBuffer->getNextEvent();
						continue;
					}
				}

				dispatchProceduralEvent(inputEvent);
				delete inputEvent;
				inputEvent = eventBuffer->getNextEvent();
			}
		}
	}
コード例 #5
0
void UIComboBox::handleEvent(Event *event) {

	if(event->getDispatcher() == dropDownBox) {
		switch(event->getEventCode()) {
			case InputEvent::EVENT_MOUSEMOVE:
			{
				InputEvent *inputEvent = (InputEvent*) event;
				selectedOffset = floor(inputEvent->getMousePosition().y/comboHeight);
				if(selectedOffset < 0)
					selectedOffset = 0;
					
				if(selectedOffset >= 0 && selectedOffset < items.size())
					selectorBox->setPosition(0,selectedOffset*comboHeight);
			}				
			break;
			case InputEvent::EVENT_MOUSEDOWN:
			{
				setSelectedIndex(selectedOffset);
			}
			break;
		}	
	}
	
	if(event->getDispatcher() == dropDownImage || event->getDispatcher() == bgBox) {
		switch(event->getEventCode()) {
			case InputEvent::EVENT_MOUSEDOWN:
				toggleDropDown();
			break;
		}
	}
}
コード例 #6
0
ファイル: LanguageScreen.cpp プロジェクト: Valodim/solarus
/**
 * @brief This function is called by the main loop when there is an input event.
 * @param event the event to handle
 */
void LanguageScreen::notify_event(InputEvent &event) {

  static const InputEvent::KeyboardKey validation_keys[] = { InputEvent::KEY_SPACE, InputEvent::KEY_RETURN, InputEvent::KEY_NONE };

  if (transition == NULL) {

    if (event.is_direction_pressed()) {

      int direction = event.get_direction();
      if (direction == 2) {
	// up
	set_cursor_position((cursor_position - 1 + nb_languages) % nb_languages);
	Sound::play("cursor");
      }
      else if (direction == 6) {
	// down
	set_cursor_position((cursor_position + 1) % nb_languages);
	Sound::play("cursor");
      }
    }
    else if (event.is_keyboard_key_pressed(validation_keys)
	|| event.is_joypad_button_pressed()) {

	FileTools::set_language(language_codes[cursor_position]);
	transition = Transition::create(Transition::FADE, Transition::OUT);
	transition->start();
    }
  }
}
コード例 #7
0
ファイル: inventory.cpp プロジェクト: nadult/FreeFT
	bool HudInventory::onInput(const InputEvent &event) {
		if(event.isMouseOverEvent() && !isMouseOver(event))
			m_out_of_item_time = s_desc_visible_time;
		if(event.isMouseEvent())
			m_last_mouse_pos = event.mousePos();
		return false;
	}
コード例 #8
0
//-----------------------------------------------------------------------------
// name: on_event_1()
// desc: ...
//-----------------------------------------------------------------------------
t_CKUINT AudicleFaceShredder::on_event_1( const AudicleEvent & event )
{
    static t_CKUINT m_mouse_down = FALSE;
    static Point2D last;
    map<t_CKUINT, Shred_Data *>::iterator iter;
    t_CKBOOL hit = FALSE;
    Point2D diff;

    if( event.type == ae_event_INPUT )
    {
        InputEvent * ie = (InputEvent *)event.data;
        if( ie->type == ae_input_MOUSE )
        {
            ie->popStack();
            
            for( iter = m_map.begin(); iter != m_map.end(); iter++ )
            {
                if( ie->checkID( (*iter).second->name ) )
                {
                    hit = TRUE;
                    if( ie->state == ae_input_DOWN )
                        (*iter).second->mouse_down = 1;
                    else
                    {
                        if( (*iter).second->mouse_down == 1 )
                            (*iter).second->mouse_clicked = 1;
                        (*iter).second->mouse_down = 0;
                        if( m_mouse_down )
                            m_mouse_down = FALSE;
                        fprintf( stderr, "click: %s\n", (*iter).second->stat->name.c_str() );
                    }
                }
            }

            if( hit == FALSE )
            {
                if( ie->state == ae_input_DOWN )
                {
                    m_mouse_down = TRUE;
                    last = ie->pos;
                }
                else
                    m_mouse_down = FALSE;
            }
        }
        else if( ie->type == ae_input_MOTION )
        {
            if( m_mouse_down )
            {
                m_eye_y += ( ie->pos - last ).length() * ( ie->pos[1] < last[1] ? 2.0 : -2.0 );
                last = ie->pos;
                //render_view();
            }
        }
    }

    return AudicleFace::on_event( event );
}
コード例 #9
0
void PolycodeConsole::handleEvent(Event *event) {

	if(event->getDispatcher() == CoreServices::getInstance()->getLogger()) {
		if(event->getEventCode() == Event::NOTIFY_EVENT) {
			LoggerEvent *loggerEvent = (LoggerEvent*)event;
			_print(loggerEvent->message);
		}
	} else if(event->getDispatcher() == consoleWindow->clearButton) {
		if(event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
			debugTextInput->setText("");
		}
	} else if(event->getDispatcher() == consoleWindow->hideConsoleButton) {
		globalFrame->hideConsole();
	}

	if(event->getDispatcher() == consoleTextInput) {
		if(event->getEventCode() == Event::COMPLETE_EVENT && event->getEventType() == "" && consoleTextInput->getText() != "") {
			_print(">"+consoleTextInput->getText()+"\n");
			if(debugger) {
				if(!debugger->isConnected()) {
					_print("Unable to inject code. No debugger clients connected.\n");
				} else {
					debugger->injectCode(consoleTextInput->getText());
				}
			}
			
			consoleHistory.push_back(consoleTextInput->getText());
			if (consoleHistory.size() > consoleHistoryMaxSize) { consoleHistory.erase(consoleHistory.begin()); }
			consoleHistoryPosition = consoleHistory.size();
			
			consoleTextInput->setText("");
		}
	}

	if (event->getDispatcher() == CoreServices::getInstance()->getCore()->getInput()) {
		if (consoleTextInput->hasFocus && event->getEventCode() == InputEvent::EVENT_KEYDOWN) {
			InputEvent *inputEvent = (InputEvent*)event;
			if (inputEvent->keyCode() == KEY_UP) { 
				consoleHistoryPosition--;
				if (consoleHistoryPosition >= 0) {
					consoleTextInput->setText(consoleHistory.at(consoleHistoryPosition));
				} else {
					consoleHistoryPosition = -1;
					consoleTextInput->setText("");
				}
			}
			if (inputEvent->keyCode() == KEY_DOWN) { 
				consoleHistoryPosition++;
				if (consoleHistoryPosition < consoleHistory.size()) {
					consoleTextInput->setText(consoleHistory.at(consoleHistoryPosition));
				} else {
					consoleHistoryPosition = consoleHistory.size();
					consoleTextInput->setText("");
				}
			}
		}
	}
}
void InputPublisherAndConsumerTest::PublishAndConsumeKeyEvent() {
    status_t status;

    const uint32_t seq = 15;
    const int32_t deviceId = 1;
    const int32_t source = AINPUT_SOURCE_KEYBOARD;
    const int32_t action = AKEY_EVENT_ACTION_DOWN;
    const int32_t flags = AKEY_EVENT_FLAG_FROM_SYSTEM;
    const int32_t keyCode = AKEYCODE_ENTER;
    const int32_t scanCode = 13;
    const int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
    const int32_t repeatCount = 1;
    const nsecs_t downTime = 3;
    const nsecs_t eventTime = 4;

    status = mPublisher->publishKeyEvent(seq, deviceId, source, action, flags,
                                         keyCode, scanCode, metaState, repeatCount, downTime, eventTime);
    ASSERT_EQ(OK, status)
            << "publisher publishKeyEvent should return OK";

    uint32_t consumeSeq;
    InputEvent* event;
    status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
    ASSERT_EQ(OK, status)
            << "consumer consume should return OK";

    ASSERT_TRUE(event != NULL)
            << "consumer should have returned non-NULL event";
    ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event->getType())
            << "consumer should have returned a key event";

    KeyEvent* keyEvent = static_cast<KeyEvent*>(event);
    EXPECT_EQ(seq, consumeSeq);
    EXPECT_EQ(deviceId, keyEvent->getDeviceId());
    EXPECT_EQ(source, keyEvent->getSource());
    EXPECT_EQ(action, keyEvent->getAction());
    EXPECT_EQ(flags, keyEvent->getFlags());
    EXPECT_EQ(keyCode, keyEvent->getKeyCode());
    EXPECT_EQ(scanCode, keyEvent->getScanCode());
    EXPECT_EQ(metaState, keyEvent->getMetaState());
    EXPECT_EQ(repeatCount, keyEvent->getRepeatCount());
    EXPECT_EQ(downTime, keyEvent->getDownTime());
    EXPECT_EQ(eventTime, keyEvent->getEventTime());

    status = mConsumer->sendFinishedSignal(seq, true);
    ASSERT_EQ(OK, status)
            << "consumer sendFinishedSignal should return OK";

    uint32_t finishedSeq = 0;
    bool handled = false;
    status = mPublisher->receiveFinishedSignal(&finishedSeq, &handled);
    ASSERT_EQ(OK, status)
            << "publisher receiveFinishedSignal should return OK";
    ASSERT_EQ(seq, finishedSeq)
            << "publisher receiveFinishedSignal should have returned the original sequence number";
    ASSERT_TRUE(handled)
            << "publisher receiveFinishedSignal should have set handled to consumer's reply";
}
コード例 #11
0
ファイル: audicle_ui_base.cpp プロジェクト: ccrma/audicle
void
UIButton::handleMouse ( const InputEvent &e  ) { 
    _selected = e.checkID(_id);
    if ( _selected && _menu ) { 
        InputEvent sub = e;
        sub.popStack();
        _menu->handleMouse( sub );            
    }
}
コード例 #12
0
ファイル: audicle_ui_base.cpp プロジェクト: ccrma/audicle
void
UIScrollBar::handleMouse(const InputEvent &e) {  
    _selected = false;
    if ( e.checkID(_id) ) { 
        if ( e.state == ae_input_DOWN ) _selected = true;
        InputEvent sub = e;
        sub.popStack();
	    _box.handleMouse ( sub );
    }
}
コード例 #13
0
ファイル: audicle_ui_base.cpp プロジェクト: ccrma/audicle
void
UIMenu::handleMouse( const InputEvent &e ) { 
    _selected = e.checkID ( _id );
    if ( _selected ) { 
        InputEvent sub = e;
        sub.popStack();
        for ( int i = 0; i < _options.size(); i++ ) 
            _options[i].button.handleMouse(sub);
    }
}
コード例 #14
0
/**
 * @brief Handles an input event in this phase.
 * @param event the event
 */
void SelectionMenuSelectFile::notify_event(InputEvent &event) {

  if (!menu->has_transition()) {
    
    if (event.is_keyboard_key_pressed(validation_keys) || event.is_joypad_button_pressed()) {

      menu->play_ok_sound();
      int cursor_position = menu->get_cursor_position();
    
      if (cursor_position == 5) {
	// the user chose "Options"
	menu->set_next_phase(new SelectionMenuOptions(menu));
      }
      else if (cursor_position == 4) {
	// the user chose "Erase"
	menu->set_next_phase(new SelectionMenuEraseFile(menu));
      }
      else {
	// the user chose a save

	Savegame **savegames = menu->get_savegames();
	if (savegames[cursor_position - 1]->is_empty()) {
	  // the savegame doesn't exist: ask the name
	  menu->set_next_phase(new SelectionMenuChooseName(menu));
	}
	else {
	  // the savegame exists: choose the mode and then start the game
	  menu->set_next_phase(new SelectionMenuChooseMode(menu));
	}
      }
    }

    if (event.is_direction_pressed()) {

      switch (event.get_direction()) {

	case 6: // down
	  menu->move_cursor_down();
	  break;

	case 2: // up
	  menu->move_cursor_up();
	  break;

	case 0: // right
	case 4: // left
	  menu->move_cursor_left_or_right();
	  break;

	default:
	  break;
      }
    }
  }
}
コード例 #15
0
	void InputManager::run(Real elapsedTime)
	{
		RL_LONGLONG start = CoreSubsystem::getSingleton().getClock();
		CEGUI::System::getSingleton().injectTimePulse(elapsedTime);

		if (mScheduledInputSwitch == SWITCH_TO_BUFFERED)
		{
			switchMouseToBuffered();
			mScheduledInputSwitch = SWITCH_NO_SWITCH;
			return;
		}
		else if (mScheduledInputSwitch == SWITCH_TO_UNBUFFERED)
		{
			switchMouseToUnbuffered();
			mScheduledInputSwitch = SWITCH_NO_SWITCH;
			return;
		}

		if (mNumActiveWindowsKeyboardInput == 0)
		{
			mInputReader->capture();
			while (mEventQueue->getSize() > 0)
			{
				InputEvent* ie = mEventQueue->pop();
				if(ie->getID() == KeyEvent::KE_KEY_PRESSED)
					keyPressed(static_cast<KeyEvent*>(ie));
				else if(ie->getID() == KeyEvent::KE_KEY_RELEASED)
					keyReleased(static_cast<KeyEvent*>(ie));
				else if(ie->getID() == KeyEvent::KE_KEY_CLICKED)
					keyClicked(static_cast<KeyEvent*>(ie));
                delete ie;
			}			
		}

		if (!mBuffered)
		{
			int pressedButtonMask = 0, releasedButtonMask = 0; 
			checkMouseButton(0, MouseEvent::BUTTON0_MASK, pressedButtonMask, releasedButtonMask);
			checkMouseButton(1, MouseEvent::BUTTON1_MASK, pressedButtonMask, releasedButtonMask);
			checkMouseButton(2, MouseEvent::BUTTON2_MASK, pressedButtonMask, releasedButtonMask);
			checkMouseButton(3, MouseEvent::BUTTON3_MASK, pressedButtonMask, releasedButtonMask);

			if (releasedButtonMask != 0 && mCharacterController!=NULL)
				mCharacterController->injectMouseUp(releasedButtonMask);

			if (pressedButtonMask != 0 && mCharacterController!=NULL)
				mCharacterController->injectMouseDown(pressedButtonMask);
		}		
		Logger::getSingleton().log(
			Logger::CORE, 
			Logger::LL_TRIVIAL, 
			"    IM time "
			 + Ogre::StringConverter::toString(
					Ogre::Real((double)(CoreSubsystem::getSingleton().getClock()-start))));
	}
コード例 #16
0
ファイル: audicle_ui_console.cpp プロジェクト: ccrma/audicle
void 
AlertBox::handleMouse( const InputEvent & e ) { 
    UIRectangle::handleMouse( e );
    if ( _selected ) { 
        InputEvent sub = e;
        sub.popStack();
        _dismissButton.handleMouse ( sub ) ;
        if ( _dismissButton.selected() ) { 
            _time_ends = AudicleWindow::main()->get_current_time() + 0.5;
        }
    }
}
コード例 #17
0
ファイル: console.cpp プロジェクト: ChunHungLiu/FreeFT
	bool HudConsole::onInput(const InputEvent &event) {
		if(event.keyDown('`') || (event.mouseButtonDown(InputButton::left) && !isMouseOver(event))) {
			setVisible(false);
			return true;
		}
		if(isVisible() && event.key() >= 32 && event.key() <= 127)
			return true;
		
		//TODO: fixme

		return false;
	}
コード例 #18
0
ファイル: Game.cpp プロジェクト: GVatinno/miner
    void Game::processInput(InputEvent& e)
    {
        //User requests quit
        if( ! e.getConsumed() && e.getEvent().type == SDL_QUIT )
        {
            e.setConsumed(true);
            setGameRunning(false);
        }

        DEBUG_ASSERT( m_sceneManagerPtr->getCurrentScenePtr() != NULL )
        m_sceneManagerPtr->processInput(e);
    }
コード例 #19
0
/**
 * @brief Handles an input event in this phase.
 * @param event the event
 */
void SelectionMenuOptions::notify_event(InputEvent &event) {

  if (event.is_direction_pressed()) {

    int direction = event.get_direction();
    if (!modifying) {

      if (direction == 2) { // up
        move_cursor_up();
      }
      else if (direction == 6) { // down
        move_cursor_down();
      }
    }
    else {

      if (direction == 0) { // right
        set_option_next_value();
      }
      else if (direction == 4) { // left
        set_option_previous_value();
      }
    }
  }

  else if (event.is_keyboard_key_pressed(validation_keys) || event.is_joypad_button_pressed()) {

    if (cursor_position < nb_options) { // set an option

      if (!modifying) {
        menu->play_ok_sound();
        left_arrow_sprite->restart_animation();
        right_arrow_sprite->restart_animation();
        label_texts[cursor_position]->set_text_color(Color::get_white());
        value_texts[cursor_position]->set_text_color(Color::get_yellow());
        menu->set_title_text("selection_menu.phase.options.changing");
        modifying = true;
      }
      else {
        menu->play_letter_sound();
        label_texts[cursor_position]->set_text_color(Color::get_yellow());
        value_texts[cursor_position]->set_text_color(Color::get_white());
        menu->set_title_text("selection_menu.phase.options");
        modifying = false;
      }
    }
    else if (cursor_position == nb_options) { // back
      menu->play_ok_sound();
      menu->set_next_phase(new SelectionMenuSelectFile(menu, 5));
    }
  }
}
コード例 #20
0
ファイル: menu_button.cpp プロジェクト: Censacrof/godot
void MenuButton::_unhandled_key_input(InputEvent p_event) {


	if (p_event.is_pressed() && !p_event.is_echo() && (p_event.type==InputEvent::KEY || p_event.type==InputEvent::ACTION || p_event.type==InputEvent::JOYSTICK_BUTTON)) {

		if (!get_parent() || !is_visible() || is_disabled())
			return;


		if (popup->activate_item_by_event(p_event))
			accept_event();
	}
}
コード例 #21
0
void TrackballCamera::handleEvent(Event *event) {
	if(event->getDispatcher() == trackballShape) {
		InputEvent *inputEvent = (InputEvent*) event;
		switch(event->getEventCode()) {
			case InputEvent::EVENT_MOUSEDOWN:
				if(isNavKeyDown() || inputEvent->mouseButton == CoreInput::MOUSE_BUTTON3) {
					if(coreInput->getKeyState(KEY_LSHIFT) || coreInput->getKeyState(KEY_RSHIFT)) {
						mouseMode = MOUSE_MODE_PANNING;
						trackBallMouseStart = Vector2(
							inputEvent->getMousePosition().x / trackballShape->getWidth(),
							inputEvent->getMousePosition().y / trackballShape->getHeight()
						);
						trackBallMouseEnd = trackBallMouseStart;
					} else if(coreInput->getKeyState(KEY_LCTRL) || coreInput->getKeyState(KEY_RCTRL)) {
						mouseMode = MOUSE_MODE_ZOOMING;
						trackBallMouseStart = Vector2(
							inputEvent->getMousePosition().x / trackballShape->getWidth(),
							inputEvent->getMousePosition().y / trackballShape->getHeight()
						);
						trackBallMouseEnd = trackBallMouseStart;												
					} else {
                        if(!rotationDisabled) {
                            mouseMode = MOUSE_MODE_ORBITING;
							trackBallMouseStart = trackBallMouseEnd = Vector2(
								inputEvent->getMousePosition().x / trackballShape->getWidth(),
								inputEvent->getMousePosition().y / trackballShape->getHeight()
							);
                        }
					}
				}
			break;
			case InputEvent::EVENT_MOUSEUP:
			case InputEvent::EVENT_MOUSEUP_OUTSIDE:
				mouseMode = MOUSE_MODE_IDLE;
			break;
			case InputEvent::EVENT_MOUSEMOVE:
				processMouseMovement(inputEvent->getMousePosition());
			break;
			case InputEvent::EVENT_MOUSEWHEEL_UP:
				cameraDistance *= 0.9;
				updateCamera();
			break;
			case InputEvent::EVENT_MOUSEWHEEL_DOWN:
				cameraDistance *= 1.1;
				updateCamera();
			break;
		}		
		return;
	}
}
コード例 #22
0
void InputEventBase::execSyncV(      FieldContainer    &oFrom,
                                        ConstFieldMaskArg  whichField,
                                        AspectOffsetStore &oOffsets,
                                        ConstFieldMaskArg  syncMode,
                                  const UInt32             uiSyncInfo)
{
    InputEvent *pThis = static_cast<InputEvent *>(this);

    pThis->execSync(static_cast<InputEvent *>(&oFrom),
                    whichField,
                    oOffsets,
                    syncMode,
                    uiSyncInfo);
}
コード例 #23
0
ファイル: audicle_ui_coding.cpp プロジェクト: ccrma/audicle
void
ShredInstance::handleMouse( const InputEvent & e ) { 
    DragManager * dm = DragManager::instance();
    selected = false;
    if ( e.checkID(pickID) ) { 
        InputEvent sub = e;
        sub.popStack();
        _killButton->handleMouse(sub);
        if ( e.state == ae_input_DOWN ) selected = true;
        dragAction( dm );
    }
    
    
}
コード例 #24
0
ファイル: base_button.cpp プロジェクト: lonesurvivor/godot
void BaseButton::_unhandled_input(InputEvent p_event) {

	if (!is_disabled() && is_visible() && p_event.is_pressed() && !p_event.is_echo() && shortcut.is_valid() && shortcut->is_shortcut(p_event)) {

		if (get_viewport()->get_modal_stack_top() && !get_viewport()->get_modal_stack_top()->is_a_parent_of(this))
			return; //ignore because of modal window

		if (is_toggle_mode()) {
			set_pressed(!is_pressed());
			emit_signal("toggled",is_pressed());
		}

		emit_signal("pressed");
	}
}
コード例 #25
0
ファイル: audicle_gfx.cpp プロジェクト: alltom/taps
//-----------------------------------------------------------------------------
// name: main_mouse()
// desc: ...
//-----------------------------------------------------------------------------
void AudicleWindow::main_mouse( int button, int state, int x, int y)
{

    assert( this == AudicleWindow::main() );
    set_mouse_coords( x, y );


    //fetch pick stack
    main_pick();
    t_CKUINT * temp_stack = (t_CKUINT*) malloc ( m_pick_size * sizeof(t_CKUINT) );
    memcpy ( (void*)temp_stack, (void*)m_pick_top, m_pick_size * sizeof(t_CKUINT) );

    // create mouse input event
    InputEvent* ev = new InputEvent ( ae_input_MOUSE, m_cur_pt, button, state );
    ev->setMods( glutGetModifiers() );
    ev->setStack( temp_stack , m_pick_size );
    ev->time = get_current_time();

    InputEvent sub = *ev;

    //START AN AUDICLE EVENT 
    //make_mouse_event( m_cur_pt,  button, state );

    AudicleEvent event;
    event.type = ae_event_INPUT;
    event.message = 2;
    event.param1 = button;
    event.param2 = state;
    event.data = (void *) ev;

    Audicle::instance()->face()->on_event( event );

    sub.popStack();

//    if( m_console )
//    {
//        m_console->handleMouse( sub );
//        m_console->handleMouseAlerts( sub ); 
//    }

    free (temp_stack);
    delete ev; //XXX assumes unqueued...

    //    if ( wm ) wm->handleMouse(button, state, cur_pt);

    //    if ( DragManager::instance()->object() ) { } 

}
コード例 #26
0
ファイル: TitleScreen.cpp プロジェクト: ziz/solarus
/**
 * @brief This function is called by the main loop when there is an input event.
 * @param event the event to handle
 */
void TitleScreen::notify_event(InputEvent &event) {

  static const InputEvent::KeyboardKey keys[] = { InputEvent::KEY_SPACE, InputEvent::KEY_RETURN, InputEvent::KEY_NONE };

  if (event.is_keyboard_key_pressed(InputEvent::KEY_ESCAPE)) {
    solarus.set_exiting();
  }
  else if (current_phase == PHASE_TITLE
      && (event.is_joypad_button_pressed() || event.is_keyboard_key_pressed(keys))
      && counter >= 1
      && !transition_out->is_started()
      && !transition_out->is_finished()) {

    transition_out->start();
  }
}
コード例 #27
0
ファイル: audicle_ui_editor.cpp プロジェクト: ccrma/audicle
void
TextContent::handleMouse(const InputEvent &e) { 

    _inp.setEvent(e, _viewport.vpToLocal(e.pos));
    
    //_inp.lastPos.printnl();
    if ( e.state == ae_input_DOWN ) { 
        _selected = e.checkID(_id);
    }

    //check the parse tree?
    if ( _selected ) { 

        if ( _inp.isDepressed ) { 
            _loc = mouseToLoc( _inp.lastPos );
            _magicCharPos = _loc.chr;
            _markLoc = _loc;
        }

        _markSpan = TextSpan(_loc, _markLoc );
    
        _buf->closeEdit();

    }
}
コード例 #28
0
ファイル: audicle_ui_console.cpp プロジェクト: ccrma/audicle
void
ConsoleWindow::handleMouseUI( const InputEvent & e ) 
{

    if ( e.state == ae_input_DOWN && _selected ) activate();

    for ( int i = 0 ; i < 6 ; i ++ ) { 
        if ( e.state == ae_input_DOWN && e.checkID(_cubeSides[i].id()) ) { 
            Audicle::instance()->move_to( i );
            setCubes();
        }
    }

    _timeLabel.handleMouse(e);
    _timeDisplay.handleMouse(e);
    _curLabel.handleMouse(e);
    _curDisplay.handleMouse(e);
    _prevLabel.handleMouse(e);
    _prevDisplay.handleMouse(e);
    _cubeWindow.handleMouse(e);
    _sizeBox.handleMouse(e);

    if ( e.state == ae_input_DOWN && _sizeBox.selected() ) { 
        deactivate();
    }


}
コード例 #29
0
ファイル: audicle_ui_base.cpp プロジェクト: ccrma/audicle
void 
UIRectangle::handleMouse ( const InputEvent & e) { 
    _selected = false;
    if ( e.state == ae_input_UP || e.size == 0 ) return ; 
    _selected = e.checkID(_id );

}
コード例 #30
0
bool InputActionMapper::handleEvent( const InputEvent& event )
{
  // See if we have a global input action for this event
  InputActionStack* foundAction = find( event );

  // If we couldn't find the action for the event, the input event may be
  //  handled by one of the other methods of mapping input events to actions
  if( !foundAction )
  {
    // First check to see if it's handled by any of the active key ranges
    if( event.isKeyType() )
    {
      int rangeCount = actionsByKeyRange.size();
      for( int i=0; i<rangeCount; ++i )
      {
        InputKeyRange&                keyRange = actionsByKeyRange[i].first;
        if( event.keyEvent.keyCode >= keyRange.keyCodeLow
         && event.keyEvent.keyCode <= keyRange.keyCodeHigh )
        {
          foundAction = actionsByKeyRange[i].second;
        }
      }
    }
  }

  // If we were able to find an action for the event, try to handle the event
  if( foundAction && foundAction->execute( event ) );
    return true;

  return false;
}