Exemple #1
0
 def colorValue(self, key, default = QColor()):
     if type(default) != QColor:
         default = QColor(default)
     name = self.mSettings.value(key, default.name())
     if (not QColor.isValidColor(name)):
         return QColor()
     return QColor(name)
Exemple #2
0
 def validate(self, value):
     self._basic_validation(value)
     if not value:
         return
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
Exemple #3
0
def _parse_qcolor_string(color_spec):
    if re.match(r'#?[0-9a-f]{2,}', color_spec):
        return _parse_qcolor_html(color_spec)
    elif QColor.isValidColor(color_spec):
        color = QColor()
        color.setNamedColor(color_spec)
        return color

    raise ValueError('Color name not recognized and not a HTML format')
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise configexc.ValidationError(value, "may not be empty!")
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
Exemple #5
0
 def __init__(self, parent=None, color_name="green"):
     super().__init__(parent)
     self.setAutoFillBackground(True)
     self.name = ""
     self.color = None
     if QColor.isValidColor(color_name):
         self.color = QColor(color_name)
         self.name = color_name
     self.clicked.connect(self.pick_color)
     self.setStyleSheet('background-color: {}'.format(self.color.name()))
Exemple #6
0
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise ValidationError(value, "may not be empty!")
     elif QColor.isValidColor(value):
         pass
     else:
         raise ValidationError(value, "must be a valid color")
Exemple #7
0
 def validate(self, value):
     self._basic_validation(value)
     if not value:
         return
     elif value.startswith('-'):
         # custom function name, won't validate.
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
Exemple #8
0
 def validate(self, value):
     self._basic_validation(value)
     if not value:
         return
     elif any(re.match(r, value) for r in self.color_func_regexes):
         # QColor doesn't handle these, so we do the best we can easily
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
Exemple #9
0
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise ValidationError(value, "may not be empty!")
     elif any(re.match(r, value) for r in self.color_func_regexes):
         # QColor doesn't handle these, so we do the best we can easily
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise ValidationError(value, "must be a valid color")
Exemple #10
0
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise ValidationError(value, "may not be empty!")
     elif any(re.match(r, value) for r in self.color_func_regexes):
         # QColor doesn't handle these, so we do the best we can easily
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise ValidationError(value, "must be a valid color")
Exemple #11
0
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise ValidationError(value, "may not be empty!")
     if value.startswith('-'):
         # custom function name, won't validate.
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise ValidationError(value, "must be a valid color")
Exemple #12
0
 def validate(self, value):
     if not value:
         if self._none_ok:
             return
         else:
             raise configexc.ValidationError(value, "may not be empty!")
     if value.startswith('-'):
         # custom function name, won't validate.
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
Exemple #13
0
 def validate(self, value):
     functions = ['rgb', 'rgba', 'hsv', 'hsva', 'qlineargradient',
                  'qradialgradient', 'qconicalgradient']
     self._basic_validation(value)
     if not value:
         return
     elif (any(value.startswith(func + '(') for func in functions) and
           value.endswith(')')):
         # QColor doesn't handle these
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
 def toMap(self, variant, mapDir):
     self.mGidMapper.clear()
     self.mMapDir = mapDir
     variantMap = variant
     orientationString = variantMap.get("orientation", '')
     orientation = orientationFromString(orientationString)
     if (orientation == Map.Orientation.Unknown):
         self.mError = self.tr("Unsupported map orientation: \"%s\""%orientationString)
         return None
     
     staggerAxisString = variantMap.get("staggeraxis", '')
     staggerAxis = staggerAxisFromString(staggerAxisString)
     staggerIndexString = variantMap.get("staggerindex", '')
     staggerIndex = staggerIndexFromString(staggerIndexString)
     renderOrderString = variantMap.get("renderorder", '')
     renderOrder = renderOrderFromString(renderOrderString)
     nextObjectId = variantMap.get("nextobjectid", 0)
     map = Map(orientation,
                        variantMap.get("width",0),
                        variantMap.get("height",0),
                        variantMap.get("tilewidth",0),
                        variantMap.get("tileheight",0))
     map.setHexSideLength(variantMap.get("hexsidelength", 0))
     map.setStaggerAxis(staggerAxis)
     map.setStaggerIndex(staggerIndex)
     map.setRenderOrder(renderOrder)
     if (nextObjectId):
         map.setNextObjectId(nextObjectId)
     self.mMap = map
     map.setProperties(self.toProperties(variantMap.get("properties", {})))
     bgColor = variantMap.get("backgroundcolor", '')
     if (bgColor!='' and QColor.isValidColor(bgColor)):
         map.setBackgroundColor(QColor(bgColor))
     for tilesetVariant in variantMap.get("tilesets", []):
         tileset = self.__toTileset(tilesetVariant)
         if not tileset:
             return None
         
         map.addTileset(tileset)
     
     for layerVariant in variantMap.get("layers", []):
         layer = self.toLayer(layerVariant)
         if not layer:
             return None
         
         map.addLayer(layer)
     
     return map
    def to_py(self, value):
        self._basic_py_validation(value, str)
        if not value:
            return None

        functions = ['rgb', 'rgba', 'hsv', 'hsva', 'qlineargradient',
                     'qradialgradient', 'qconicalgradient']
        if (any(value.startswith(func + '(') for func in functions) and
                value.endswith(')')):
            # QColor doesn't handle these
            return value

        if not QColor.isValidColor(value):
            raise configexc.ValidationError(value, "must be a valid color")

        return value
Exemple #16
0
    def to_py(self, value):
        self._basic_py_validation(value, str)
        if not value:
            return None

        functions = ['rgb', 'rgba', 'hsv', 'hsva', 'qlineargradient',
                     'qradialgradient', 'qconicalgradient']
        if (any(value.startswith(func + '(') for func in functions) and
                value.endswith(')')):
            # QColor doesn't handle these
            return value

        if not QColor.isValidColor(value):
            raise configexc.ValidationError(value, "must be a valid color")

        return value
Exemple #17
0
 def validate(self, value):
     functions = [
         'rgb', 'rgba', 'hsv', 'hsva', 'qlineargradient', 'qradialgradient',
         'qconicalgradient'
     ]
     self._basic_validation(value)
     if not value:
         return
     elif (any(value.startswith(func + '(') for func in functions)
           and value.endswith(')')):
         # QColor doesn't handle these
         pass
     elif QColor.isValidColor(value):
         pass
     else:
         raise configexc.ValidationError(value, "must be a valid color")
    def toMap(self, variant, mapDir):
        self.mGidMapper.clear()
        self.mMapDir = mapDir
        variantMap = variant
        orientationString = variantMap.get("orientation", '')
        orientation = orientationFromString(orientationString)
        if (orientation == Map.Orientation.Unknown):
            self.mError = self.tr("Unsupported map orientation: \"%s\"" %
                                  orientationString)
            return None

        staggerAxisString = variantMap.get("staggeraxis", '')
        staggerAxis = staggerAxisFromString(staggerAxisString)
        staggerIndexString = variantMap.get("staggerindex", '')
        staggerIndex = staggerIndexFromString(staggerIndexString)
        renderOrderString = variantMap.get("renderorder", '')
        renderOrder = renderOrderFromString(renderOrderString)
        nextObjectId = variantMap.get("nextobjectid", 0)
        map = Map(orientation, variantMap.get("width", 0),
                  variantMap.get("height", 0), variantMap.get("tilewidth", 0),
                  variantMap.get("tileheight", 0))
        map.setHexSideLength(variantMap.get("hexsidelength", 0))
        map.setStaggerAxis(staggerAxis)
        map.setStaggerIndex(staggerIndex)
        map.setRenderOrder(renderOrder)
        if (nextObjectId):
            map.setNextObjectId(nextObjectId)
        self.mMap = map
        map.setProperties(self.toProperties(variantMap.get("properties", {})))
        bgColor = variantMap.get("backgroundcolor", '')
        if (bgColor != '' and QColor.isValidColor(bgColor)):
            map.setBackgroundColor(QColor(bgColor))
        for tilesetVariant in variantMap.get("tilesets", []):
            tileset = self.__toTileset(tilesetVariant)
            if not tileset:
                return None

            map.addTileset(tileset)

        for layerVariant in variantMap.get("layers", []):
            layer = self.toLayer(layerVariant)
            if not layer:
                return None

            map.addLayer(layer)

        return map
    def toImageLayer(self, variantMap):
        imageLayer = ImageLayer(variantMap.get("name", ''),
                                variantMap.get("x", 0), variantMap.get("y", 0),
                                variantMap.get("width", 0),
                                variantMap.get("height", 0))
        opacity = variantMap.get("opacity", 0.0)
        visible = variantMap.get("visible", True)
        imageLayer.setOpacity(opacity)
        imageLayer.setVisible(visible)
        trans = variantMap.get("transparentcolor", '')
        if (not trans.isEmpty() and QColor.isValidColor(trans)):
            imageLayer.setTransparentColor(QColor(trans))
        imageVariant = variantMap.get("image", '')
        if imageVariant != '':
            imagePath = resolvePath(self.mMapDir, imageVariant)
            if (not imageLayer.loadFromImage(QImage(imagePath), imagePath)):
                self.mError = self.tr("Error loading image:\n'%s'" % imagePath)
                return None

        return imageLayer
    def toImageLayer(self, variantMap):
        imageLayer = ImageLayer(variantMap.get("name",''),
                                                variantMap.get("x",0),
                                                variantMap.get("y",0),
                                                variantMap.get("width",0),
                                                variantMap.get("height",0))
        opacity = variantMap.get("opacity", 0.0)
        visible = variantMap.get("visible", True)
        imageLayer.setOpacity(opacity)
        imageLayer.setVisible(visible)
        trans = variantMap.get("transparentcolor", '')
        if (not trans.isEmpty() and QColor.isValidColor(trans)):
            imageLayer.setTransparentColor(QColor(trans))
        imageVariant = variantMap.get("image",'')
        if imageVariant != '':
            imagePath = resolvePath(self.mMapDir, imageVariant)
            if (not imageLayer.loadFromImage(QImage(imagePath), imagePath)):
                self.mError = self.tr("Error loading image:\n'%s'"%imagePath)
                return None

        return imageLayer
    def __toTileset(self, variant):
        variantMap = variant
        firstGid = variantMap.get("firstgid",0)
        
        # Handle external tilesets
        sourceVariant = variantMap.get("source", '')
        if sourceVariant != '':
            source = resolvePath(self.mMapDir, sourceVariant)
            tileset, error = readTileset(source)
            if not tileset:
                self.mError = self.tr("Error while loading tileset '%s': %s"%(source, error))
            else:
                self.mGidMapper.insert(firstGid, tileset)
            return tileset

        name = variantMap.get("name",'')
        tileWidth = variantMap.get("tilewidth",0)
        tileHeight = variantMap.get("tileheight",0)
        spacing = variantMap.get("spacing",0)
        margin = variantMap.get("margin",0)
        tileOffset = variantMap.get("tileoffset", {})
        tileOffsetX = tileOffset.get("x",0)
        tileOffsetY = tileOffset.get("y",0)
        if (tileWidth <= 0 or tileHeight <= 0 or (firstGid == 0 and not self.mReadingExternalTileset)):
            self.mError = self.tr("Invalid tileset parameters for tileset '%s'"%name)
            return None
        
        tileset = Tileset.create(name, tileWidth, tileHeight, spacing, margin)
        tileset.setTileOffset(QPoint(tileOffsetX, tileOffsetY))
        trans = variantMap.get("transparentcolor", '')
        if (trans!='' and QColor.isValidColor(trans)):
            tileset.setTransparentColor(QColor(trans))
        imageVariant = variantMap.get("image",'')
        if imageVariant != '':
            imagePath = resolvePath(self.mMapDir, imageVariant)
            if (not tileset.loadFromImage(imagePath)):
                self.mError = self.tr("Error loading tileset image:\n'%s'"%imagePath)
                return None

        tileset.setProperties(self.toProperties(variantMap.get("properties", {})))
        
        # Read terrains
        terrainsVariantList = variantMap.get("terrains", [])
        for terrainMap in terrainsVariantList:
            tileset.addTerrain(terrainMap.get("name", ''), terrainMap.get("tile", 0))

        # Read tile terrain and external image information
        tilesVariantMap = variantMap.get("tiles", {})
        for it in tilesVariantMap.items():
            ok = False
            tileIndex = Int(it[0])
            if (tileIndex < 0):
                self.mError = self.tr("Tileset tile index negative:\n'%d'"%tileIndex)
            
            if (tileIndex >= tileset.tileCount()):
                # Extend the tileset to fit the tile
                if (tileIndex >= len(tilesVariantMap)):
                    # If tiles are  defined this way, there should be an entry
                    # for each tile.
                    # Limit the index to number of entries to prevent running out
                    # of memory on malicious input.f
                    self.mError = self.tr("Tileset tile index too high:\n'%d'"%tileIndex)
                    return None
                
                for i in range(tileset.tileCount(), tileIndex+1):
                    tileset.addTile(QPixmap())
            
            tile = tileset.tileAt(tileIndex)
            if (tile):
                tileVar = it[1]
                terrains = tileVar.get("terrain", [])
                if len(terrains) == 4:
                    for i in range(0, 4):
                        terrainId, ok = Int2(terrains[i])
                        if (ok and terrainId >= 0 and terrainId < tileset.terrainCount()):
                            tile.setCornerTerrainId(i, terrainId)

                probability, ok = Float2(tileVar.get("probability", 0.0))
                if (ok):
                    tile.setProbability(probability)
                imageVariant = tileVar.get("image",'')
                if imageVariant != '':
                    imagePath = resolvePath(self.mMapDir, imageVariant)
                    tileset.setTileImage(tileIndex, QPixmap(imagePath), imagePath)
                
                objectGroupVariant = tileVar.get("objectgroup", {})
                if len(objectGroupVariant) > 0:
                    tile.setObjectGroup(self.toObjectGroup(objectGroupVariant))
                frameList = tileVar.get("animation", [])
                lenFrames = len(frameList)
                if lenFrames > 0:
                    frames = QVector()
                    for i in range(lenFrames):
                        frames.append(Frame())
                    for i in range(lenFrames - 1, -1, -1):
                        frameVariantMap = frameList[i]
                        frame = frames[i]
                        frame.tileId = frameVariantMap.get("tileid", 0)
                        frame.duration = frameVariantMap.get("duration", 0)
                    
                    tile.setFrames(frames)

        
        # Read tile properties
        propertiesVariantMap = variantMap.get("tileproperties", {})
        
        for it in propertiesVariantMap.items():
            tileIndex = Int(it[0])
            propertiesVar = it[1]
            if (tileIndex >= 0 and tileIndex < tileset.tileCount()):
                properties = self.toProperties(propertiesVar)
                tileset.tileAt(tileIndex).setProperties(properties)

        if not self.mReadingExternalTileset:        
            self.mGidMapper.insert(firstGid, tileset)

        return tileset
    def __toTileset(self, variant):
        variantMap = variant
        firstGid = variantMap.get("firstgid", 0)

        # Handle external tilesets
        sourceVariant = variantMap.get("source", '')
        if sourceVariant != '':
            source = resolvePath(self.mMapDir, sourceVariant)
            tileset, error = readTileset(source)
            if not tileset:
                self.mError = self.tr("Error while loading tileset '%s': %s" %
                                      (source, error))
            else:
                self.mGidMapper.insert(firstGid, tileset)
            return tileset

        name = variantMap.get("name", '')
        tileWidth = variantMap.get("tilewidth", 0)
        tileHeight = variantMap.get("tileheight", 0)
        spacing = variantMap.get("spacing", 0)
        margin = variantMap.get("margin", 0)
        tileOffset = variantMap.get("tileoffset", {})
        tileOffsetX = tileOffset.get("x", 0)
        tileOffsetY = tileOffset.get("y", 0)
        if (tileWidth <= 0 or tileHeight <= 0
                or (firstGid == 0 and not self.mReadingExternalTileset)):
            self.mError = self.tr(
                "Invalid tileset parameters for tileset '%s'" % name)
            return None

        tileset = Tileset.create(name, tileWidth, tileHeight, spacing, margin)
        tileset.setTileOffset(QPoint(tileOffsetX, tileOffsetY))
        trans = variantMap.get("transparentcolor", '')
        if (trans != '' and QColor.isValidColor(trans)):
            tileset.setTransparentColor(QColor(trans))
        imageVariant = variantMap.get("image", '')
        if imageVariant != '':
            imagePath = resolvePath(self.mMapDir, imageVariant)
            if (not tileset.loadFromImage(imagePath)):
                self.mError = self.tr("Error loading tileset image:\n'%s'" %
                                      imagePath)
                return None

        tileset.setProperties(
            self.toProperties(variantMap.get("properties", {})))

        # Read terrains
        terrainsVariantList = variantMap.get("terrains", [])
        for terrainMap in terrainsVariantList:
            tileset.addTerrain(terrainMap.get("name", ''),
                               terrainMap.get("tile", 0))

        # Read tile terrain and external image information
        tilesVariantMap = variantMap.get("tiles", {})
        for it in tilesVariantMap.items():
            ok = False
            tileIndex = Int(it[0])
            if (tileIndex < 0):
                self.mError = self.tr("Tileset tile index negative:\n'%d'" %
                                      tileIndex)

            if (tileIndex >= tileset.tileCount()):
                # Extend the tileset to fit the tile
                if (tileIndex >= len(tilesVariantMap)):
                    # If tiles are  defined this way, there should be an entry
                    # for each tile.
                    # Limit the index to number of entries to prevent running out
                    # of memory on malicious input.f
                    self.mError = self.tr(
                        "Tileset tile index too high:\n'%d'" % tileIndex)
                    return None

                for i in range(tileset.tileCount(), tileIndex + 1):
                    tileset.addTile(QPixmap())

            tile = tileset.tileAt(tileIndex)
            if (tile):
                tileVar = it[1]
                terrains = tileVar.get("terrain", [])
                if len(terrains) == 4:
                    for i in range(0, 4):
                        terrainId, ok = Int2(terrains[i])
                        if (ok and terrainId >= 0
                                and terrainId < tileset.terrainCount()):
                            tile.setCornerTerrainId(i, terrainId)

                probability, ok = Float2(tileVar.get("probability", 0.0))
                if (ok):
                    tile.setProbability(probability)
                imageVariant = tileVar.get("image", '')
                if imageVariant != '':
                    imagePath = resolvePath(self.mMapDir, imageVariant)
                    tileset.setTileImage(tileIndex, QPixmap(imagePath),
                                         imagePath)

                objectGroupVariant = tileVar.get("objectgroup", {})
                if len(objectGroupVariant) > 0:
                    tile.setObjectGroup(self.toObjectGroup(objectGroupVariant))
                frameList = tileVar.get("animation", [])
                lenFrames = len(frameList)
                if lenFrames > 0:
                    frames = QVector()
                    for i in range(lenFrames):
                        frames.append(Frame())
                    for i in range(lenFrames - 1, -1, -1):
                        frameVariantMap = frameList[i]
                        frame = frames[i]
                        frame.tileId = frameVariantMap.get("tileid", 0)
                        frame.duration = frameVariantMap.get("duration", 0)

                    tile.setFrames(frames)

        # Read tile properties
        propertiesVariantMap = variantMap.get("tileproperties", {})

        for it in propertiesVariantMap.items():
            tileIndex = Int(it[0])
            propertiesVar = it[1]
            if (tileIndex >= 0 and tileIndex < tileset.tileCount()):
                properties = self.toProperties(propertiesVar)
                tileset.tileAt(tileIndex).setProperties(properties)

        if not self.mReadingExternalTileset:
            self.mGidMapper.insert(firstGid, tileset)

        return tileset