Ejemplo n.º 1
0
/**
 * Parses the text contained within the given token stack
 */
int CodeParser::parseKeyword( Scope* scope, TokenStack* stack, const char* keyword ) {
	int errorCode = 0;

	// TODO delete, do-while, for, foreach
	// TODO if-else, try-catch, throw, while

	// handle the keyword
	switch( state->lookupKeyword( keyword ) ) {
		case KW_ABSTRACT:	errorCode = updateModifiers( ABSTRACT, stack ); break;
		case KW_CLASS:		errorCode = parseKeyword_Class( scope, stack ); break;
		case KW_FINAL:		errorCode = updateModifiers( FINAL, stack ); break;
		case KW_IMPORT:		errorCode = parseKeyword_Import( scope, stack ); break;
		case KW_NAMESPACE:	errorCode = parseKeyword_NameSpace( scope, stack ); break;
		case KW_NEW:		errorCode = parseKeyword_New( scope, stack ); break;
		case KW_PACKAGED:	errorCode = updateModifiers( PACKAGE, stack ); break;
		case KW_PRIVATE:	errorCode = updateModifiers( PRIVATE, stack ); break;
		case KW_PROTECTED:	errorCode = updateModifiers( PROTECTED, stack ); break;
		case KW_PUBLIC:		errorCode = updateModifiers( PUBLIC, stack ); break;
		case KW_RETURN:		errorCode = parseKeyword_Return( scope, stack ); break;
		case KW_STATIC:		errorCode = updateModifiers( STATIC, stack ); break;
		case KW_VIRTUAL:	errorCode = updateModifiers( VIRTUAL, stack ); break;
		default:
			char *message = new char[256];
			sprintf( message, "Keyword '%s' was not handled", keyword );
			SYNTAX_ERROR( message, stack->last() );
			delete message;
			errorCode = -1;
	}

	// success
	return errorCode;
}
Ejemplo n.º 2
0
void
CInputFilter::sendEvent(CEvent& event)
{
	CEvent::Type type = event.getType();
	// process keyboard modifiers here
	if (type == IPlatformScreen::getKeyDownEvent() ||
		type == IPlatformScreen::getKeyUpEvent() || 
		type == IPlatformScreen::getKeyRepeatEvent()) {
		// get CKeyInfo from event
		IPlatformScreen::CKeyInfo* kinfo =
			reinterpret_cast<IPlatformScreen::CKeyInfo*>(event.getData());

		// save mask
		m_lastMask = kinfo->m_mask;

		// prepare new mask
		KeyModifierMask newMask = kinfo->m_mask;
		updateModifiers();
		newMask &= ~m_clearMask;
		newMask |= m_modifierMask;

		// set new mask
		kinfo->m_mask = newMask;
	}

	// add event to eventqueue
	EVENTQUEUE->addEvent(event);
}
BOOL LLKeyboardMacOSX::handleKeyUp(const U16 key, const U32 mask)
{
	KEY		translated_key = 0;
	U32		translated_mask = 0;
	BOOL	handled = FALSE;

	translated_mask = updateModifiers(mask);

	if(translateNumpadKey(key, &translated_key))
	{
		handled = handleTranslatedKeyUp(translated_key, translated_mask);
	}

	return handled;
}
// mask is ignored, except for extended flag -- we poll the modifier keys for the other flags
BOOL LLKeyboardWin32::handleKeyUp(const U16 key, MASK mask)
{
	KEY		translated_key;
	U32		translated_mask;
	BOOL	handled = FALSE;

	translated_mask = updateModifiers();

	if (translateExtendedKey(key, mask, &translated_key))
	{
		handled = handleTranslatedKeyUp(translated_key, translated_mask);
	}

	return handled;
}
Ejemplo n.º 5
0
static void kb_chvt(_self, int vt)
{
  if (ioctl(self->fd, VT_ACTIVATE, vt))
    perror("chvt: VT_ACTIVATE");
  else
    {
      while (ioctl(self->fd, VT_WAITACTIVE, vt))
	{
	  if (EINTR == errno)
	    continue;
	  perror("VT_WAITACTIVE");
	  break;
	}
      updateModifiers(self->state= 0);
    }
}
Ejemplo n.º 6
0
void
CInputFilter::handleEvent(const CEvent& event, void* arg)
{
	// get a modifiable copy of this event.
	// set target to us, set kDontFreeData and kDeliverImmediately because the
	// original event will be destroyed after this method exits.
	CEvent evt(event.getType(), this, event.getData(),
								event.getFlags() | CEvent::kDontFreeData |
								CEvent::kDeliverImmediately);

	// clear dirty flag
	m_dirtyFlag = kNotDirty;

	EActionMode	actionMode = kModePass;
	// match event against filter rules and perform actions
	for (CRuleList::iterator rule  = m_ruleList.begin();
							 rule != m_ruleList.end(); ++rule) {
		EFilterStatus conditionStatus;
		EFilterStatus actionStatus;
		conditionStatus = rule->first->match(evt, arg, actionMode);
		if (conditionStatus == kDiscard) {
			return;
		}
		else if (conditionStatus == kNoMatch) {
			continue;
		}

		actionStatus = rule->second->perform(evt, arg, actionMode);
		if (actionStatus == kDiscard) {
			// discard event
			return;
		}
		else if (actionStatus == kNotHandled) {
			continue;
		}
		else if (actionStatus == kUpdateModifiers) {
			updateModifiers();
			return;
		}

		// if we got here then the rule has matched and action returned
		// kHandled, so send the event.
		break;
	}

	sendEvent(evt);
}
Ejemplo n.º 7
0
BOOL LLKeyboardSDL::handleKeyUp(const U16 key, const U32 mask)
{
    U16     adjusted_nativekey;
    KEY	translated_key = 0;
    U32	translated_mask = MASK_NONE;
    BOOL	handled = FALSE;

    adjusted_nativekey = adjustNativekeyFromUnhandledMask(key, mask);

    translated_mask = updateModifiers(mask);

    if(translateNumpadKey(adjusted_nativekey, &translated_key))
    {
        handled = handleTranslatedKeyUp(translated_key, translated_mask);
    }

    return handled;
}
Ejemplo n.º 8
0
bool Global::eventFilter(QObject * /*watched*/, QEvent * event)
{
    // Every single event delivered by Qt go through this method first before
    // going to its target object, so keep it as lightweight as possible

    // It is used as a convenient way to fix a few event behaviours that were
    // not quite right out of the box.

    // --------------------- Detect modifier key presses --------------

    // Detect modifier key presses (Shift, Ctrl, Alt, etc.) and update application
    // state accordingly (e.g., indicate which modifiers are pressed in the status bar, or
    // redraw the scene, since highlighting color depends on which modifiers are pressed)

    // If a modifier is pressed or released, update the modifier state, and emit a signal
    // if this state has changed
    // If a modifier is pressed or released, update the modifier state, and emit a signal
    // if this state has changed
    if(event->type() == QEvent::KeyPress ||
       event->type() == QEvent::KeyRelease)
    {
        QKeyEvent * keyEvent = static_cast<QKeyEvent *>(event);
        if(keyEvent)
        {
            // Workaround for Mac delete key
            // This is needed because of a bug in QT 5 that has not been resolved as of 5.5.0
#ifdef Q_OS_MAC
            if(keyEvent->key() == Qt::Key_Backspace)
            {
                scene()->smartDelete();
            }
#endif
            if(keyEvent->key() == Qt::Key_Shift ||
               keyEvent->key() == Qt::Key_Alt ||
               keyEvent->key() == Qt::Key_Meta ||
               keyEvent->key() == Qt::Key_AltGr ||
               keyEvent->key() == Qt::Key_Control)
            {
                updateModifiers();
            }
        }

        // Continue normal processing of the event
        return false;
    }
    else if(event->type() == QEvent::FocusIn )
    {
        updateModifiers();

        // Continue normal processing of the event
        return false;
    }

    // --------------------- Resolve shortcut overloads --------------

    // Resolve shortcut overloads
    else if(event->type() == QEvent::Shortcut)
    {
        QShortcutEvent * shortcutEvent = static_cast<QShortcutEvent *>(event);

        if(shortcutEvent->isAmbiguous())
        {
            QKeySequence key = shortcutEvent->key();
            resolveAmbiguousShortcuts(key);

            // Stop processing of the event
            return true;

        }
        else
        {
            // Continue normal processing of the event
            return false;
        }
    }

    // --------------------- Keep standard behaviour --------------

    // Continue normal processing of the event
    return false;
}
Ejemplo n.º 9
0
static void kb_translate(_self, int code, int up)
{
  static int prev= 0;
  unsigned short *keyMap= self->keyMaps[self->state];
  int rep= (!up) && (prev == code);
  prev= up ? 0 : code;

  debugf("+++ code %d up %d prev %d rep %d map %p\n", code, up, prev, rep, keyMap);

  if (keyMap)
    {
      int sym=  keyMap[code];
      int type= KTYP(sym);
      debugf("+++ sym %x (%02x) type %d\n", sym, sym & 255, type);
      sym &= 255;
      if (type >= 0xf0)		// shiftable
	type -= 0xf0;
      if (KT_LETTER == type)	// lockable
	type= KT_LATIN;
      debugf("+++ type %d\n", type);
      switch (type)
	{
	case KT_LATIN:
	case KT_META:
	  kb_post(self, sym, up);
	  break;

	case KT_SHIFT:
	  if      (rep) break;
	  else if (up)  self->state &= ~(1 << sym);
	  else          self->state |=  (1 << sym);
	  updateModifiers(self->state);
	  break;

	case KT_FN:
	case KT_SPEC:
	case KT_CUR:
	  switch (K(type,sym))
	    {
	      // FN
	    case K_FIND:	kb_post(self,  1, up);	break;	// home
	    case K_INSERT:	kb_post(self,  5, up);	break;
	    case K_SELECT:	kb_post(self,  4, up);	break;	// end
	    case K_PGUP:	kb_post(self, 11, up);	break;
	    case K_PGDN:	kb_post(self, 12, up);	break;
	      // SPEC
	    case K_ENTER:	kb_post(self, 13, up);	break;
	      // CUR
	    case K_DOWN:	kb_post(self, 31, up);	break;
	    case K_LEFT:	kb_post(self, 28, up);	break;
	    case K_RIGHT:	kb_post(self, 29, up);	break;
	    case K_UP:		kb_post(self, 30, up);	break;
	    }
	  break;

	case KT_CONS:
	  if (self->vtSwitch && !self->vtLock)
	    kb_chvt(self, sym + 1);
	  break;

	default:
	  if (type > KT_SLOCK)
	    debugf("ignoring unknown scancode %d.%d\n", type, sym);
	  break;
	}
    }
}
Ejemplo n.º 10
0
void LLKeyboardMacOSX::handleModifier(MASK mask)
{
	updateModifiers(mask);
}
Ejemplo n.º 11
0
void Champion::updateCooldowns() {
    _ability->update();
    
    updateModifiers(_flatModifiers);
    updateModifiers(_addativeModifiers);
}