def send(self, *a):
        if self._recursing: return

        cbMode = self.builder.get_object("cbMode")
        cbYawRoll = self.builder.get_object("cbYawRoll")
        rvSoftLevel = self.builder.get_object("rvSoftLevel")
        sclSoftLevel = self.builder.get_object("sclSoftLevel")
        cbGyroButton = self.builder.get_object("cbGyroButton")
        cbInvertGyro = self.builder.get_object("cbInvertGyro")
        cbInvertGyro = self.builder.get_object("cbInvertGyro")
        action = cbMode.get_model().get_value(cbMode.get_active_iter(), 0)
        key = cbMode.get_model().get_value(cbMode.get_active_iter(), 2)
        yawroll = cbYawRoll.get_model().get_value(cbYawRoll.get_active_iter(),
                                                  0)
        item = cbGyroButton.get_model().get_value(
            cbGyroButton.get_active_iter(), 0)
        rvSoftLevel.set_reveal_child(item in TRIGGERS)

        match = re.match(r"([^\[]+)\[([^\|]+)\|([^\]]+)\](.*)", action)
        if match:
            grps = match.groups()
            if yawroll == YAW:
                action = "%s%s%s" % (grps[0], grps[1], grps[3])
            else:
                action = "%s%s%s" % (grps[0], grps[2], grps[3])
        action = self.parser.restart(action).parse()

        if item and action:
            if item in TRIGGERS:
                what = RangeOP(getattr(SCButtons, item), ">=",
                               sclSoftLevel.get_value())
            elif item == STICK:
                what = RangeOP(item, ">=", sclSoftLevel.get_value())
            else:
                what = getattr(SCButtons, item)
            if cbInvertGyro.get_active():
                action = ModeModifier(what, NoAction(), action)
            else:
                action = ModeModifier(what, action)
        if key == "mouse":
            self.editor.set_default_sensitivity(3.5, 3.5, 3.5)
        else:
            self.editor.set_default_sensitivity(1, 1, 1)

        self.update()
        self.editor.set_action(action)
	def on_btAddAction_clicked(self, *a):
		cbButtonChooser = self.builder.get_object("cbButtonChooser")
		item = cbButtonChooser.get_model().get_value(cbButtonChooser.get_active_iter(), 0)
		if item.startswith("Soft"):
			b = getattr(SCButtons, item.split(" ")[-1])
			rng = RangeOP(b, ">=", -1)
			self._add_action(self.current_page, rng, NoAction())
		else:
			b = getattr(SCButtons, item)
			self._add_action(self.current_page, b, NoAction())
Exemple #3
0
	def _parse_parameter(self):
		""" Parses single parameter """
		t = self._next_token()
		while t.type == TokenType.NEWLINE or t.value == "\n":
			if not self._tokens_left():
				raise ParseError("Expected parameter at end of string")
			t = self._next_token()
		
		if t.type == TokenType.NAME:
			# Constant or action used as parameter
			if self._tokens_left() and self._peek_token().type == TokenType.OP and self._peek_token().value == '(':
				# Action used as parameter
				self.index -= 1 # go step back and reparse as action
				parameter = self._parse_action()
			elif self._tokens_left() and t.value in Action.ALL and type(Action.ALL[t.value]) == dict and self._peek_token().value == '.':
				# SOMETHING.Action used as parameter
				self.index -= 1 # go step back and reparse as action
				parameter = self._parse_action()
			else:
				# Constant
				if not t.value in ActionParser.CONSTS:
					raise ParseError("Expected parameter, got '%s' which is not defined" % (t.value,))
				parameter = ActionParser.CONSTS[t.value]
			
			# Check for dots
			while self._tokens_left() and self._peek_token().type == TokenType.OP and self._peek_token().value == '.':
				self._next_token()
				if not self._tokens_left():
					raise ParseError("Expected NAME after '.'")
				
				t = self._next_token()
				if not hasattr(parameter, t.value):
					raise ParseError("%s has no attribute '%s'" % (parameter, t.value,))
				parameter = getattr(parameter, t.value)
			
			# Check for ranges (<, >, <=, >=)
			if self._tokens_left() and self._peek_token().type == TokenType.OP:
				if self._peek_token().value in RangeOP.OPS:
					op = self._next_token().value
					# TODO: Maybe other axes
					if not self._tokens_left():
						raise ParseError("Excepted number after '%s'" % (op, ))
					number = self._parse_number()
					try:
						parameter = RangeOP(parameter, op, number)
					except ValueError, e:
						raise ParseError(e.message)
			
			return parameter
Exemple #4
0
    def send(self, *a):
        if self._recursing: return

        rvSoftLevel = self.builder.get_object("rvSoftLevel")
        sclSoftLevel = self.builder.get_object("sclSoftLevel")
        cbGyroButton = self.builder.get_object("cbGyroButton")
        cbInvertGyro = self.builder.get_object("cbInvertGyro")
        item = cbGyroButton.get_model().get_value(
            cbGyroButton.get_active_iter(), 0)
        rvSoftLevel.set_reveal_child(item in TRIGGERS)

        normal, n_set = [None, None, None], False
        absolute, a_set = [None, None, None], False

        for i in xrange(0, 3):
            if self.axes[i] is not None:
                if self.cbs[i].get_active():
                    absolute[i] = self.axes[i]
                    a_set = True
                else:
                    normal[i] = self.axes[i]
                    n_set = True

        if n_set and a_set:
            action = MultiAction(GyroAction(*normal), GyroAbsAction(*absolute))
        elif n_set:
            action = GyroAction(*normal)
        elif a_set:
            action = GyroAbsAction(*absolute)
        else:
            action = NoAction()

        if item and action:
            what = getattr(SCButtons, item)
            if item in TRIGGERS:
                what = RangeOP(what, ">=", sclSoftLevel.get_value())
            if cbInvertGyro.get_active():
                action = ModeModifier(what, NoAction(), action)
            else:
                action = ModeModifier(what, action)

        self.editor.set_action(action)
    def _parse_parameter(self):
        """ Parses single parameter """
        t = self._next_token()
        while t.type == TokenType.NEWLINE or t.value == "\n":
            if not self._tokens_left():
                raise ParseError("Expected parameter at end of string")
            t = self._next_token()

        if t.type == TokenType.NAME:
            # Constant or action used as parameter
            if self._tokens_left() and self._peek_token(
            ).type == TokenType.OP and self._peek_token().value == '(':
                # Action used as parameter
                self.index -= 1  # go step back and reparse as action
                parameter = self._parse_action()
            elif self._tokens_left() and t.value in Action.ALL and type(
                    Action.ALL[
                        t.value]) == dict and self._peek_token().value == '.':
                # SOMETHING.Action used as parameter
                self.index -= 1  # go step back and reparse as action
                parameter = self._parse_action()
            else:
                # Constant
                if not t.value in ActionParser.CONSTS:
                    raise ParseError(
                        "Expected parameter, got '%s' which is not defined" %
                        (t.value, ))
                parameter = ActionParser.CONSTS[t.value]

            # Check for dots
            while self._tokens_left() and self._peek_token(
            ).type == TokenType.OP and self._peek_token().value == '.':
                self._next_token()
                if not self._tokens_left():
                    raise ParseError("Expected NAME after '.'")

                t = self._next_token()
                if not hasattr(parameter, t.value):
                    raise ParseError("%s has no attribute '%s'" % (
                        parameter,
                        t.value,
                    ))
                parameter = getattr(parameter, t.value)

            # Check for ranges (<, >, <=, >=)
            if self._tokens_left() and self._peek_token().type == TokenType.OP:
                if self._peek_token().value in RangeOP.OPS:
                    op = self._next_token().value
                    # TODO: Maybe other axes
                    if parameter not in (STICK, SCButtons.LT, SCButtons.RT,
                                         SCButtons.X, SCButtons.Y):
                        raise ParseError("'%s' is not trigger nor axis" %
                                         (nameof(parameter), ))
                    if not self._tokens_left():
                        raise ParseError("Excepted number after '%s'" % (op, ))
                    try:
                        number = float(self._next_token().value)
                    except ValueError:
                        raise ParseError("Excepted number after '%s'" % (op, ))
                    parameter = RangeOP(parameter, op, number)

            return parameter

        if t.type == TokenType.OP and t.value == "-":
            if not self._tokens_left(
            ) or self._peek_token().type != TokenType.NUMBER:
                raise ParseError("Expected number after '-'")
            return -self._parse_number()

        if t.type == TokenType.NUMBER:
            self.index -= 1
            return self._parse_number()

        if t.type == TokenType.STRING:
            return t.value[1:-1].decode('string_escape')

        raise ParseError("Expected parameter, got '%s'" % (t.value, ))