mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-20 08:48:13 +00:00
351 lines
9.7 KiB
Python
351 lines
9.7 KiB
Python
#!/usr/bin/env python
|
|
# encoding: utf-8
|
|
|
|
"""
|
|
" ScummVM - Graphic Adventure Engine
|
|
"
|
|
" ScummVM is the legal property of its developers, whose names
|
|
" are too numerous to list here. Please refer to the COPYRIGHT
|
|
" file distributed with this source distribution.
|
|
"
|
|
" This program is free software; you can redistribute it and/or
|
|
" modify it under the terms of the GNU General Public License
|
|
" as published by the Free Software Foundation; either version 2
|
|
" of the License, or (at your option) any later version.
|
|
"
|
|
" This program is distributed in the hope that it will be useful,
|
|
" but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
" GNU General Public License for more details.
|
|
"
|
|
" You should have received a copy of the GNU General Public License
|
|
" along with this program; if not, write to the Free Software
|
|
" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
"
|
|
" $URL$
|
|
" $Id$
|
|
"""
|
|
|
|
from __future__ import with_statement
|
|
import os
|
|
import xml.dom.minidom as DOM
|
|
import struct
|
|
|
|
class STXBinaryFile:
|
|
class InvalidRGBColor(Exception):
|
|
pass
|
|
|
|
class InvalidResolution(Exception):
|
|
pass
|
|
|
|
BLOCK_HEADERS = {
|
|
"palette" : 0x0100000A,
|
|
"bitmaps" : 0x0100000B,
|
|
"fonts" : 0x0100000C,
|
|
"defaults" : 0x0100000D,
|
|
"cursor" : 0x0100000E,
|
|
"drawdata" : 0x0100000F
|
|
}
|
|
|
|
DRAWSTEP_FORMAT_DEF = [
|
|
"stroke", "shadow",
|
|
"bevel", "factor",
|
|
"fg_color", "bg_color",
|
|
"fill", "gradient_start",
|
|
"gradient_end", "bevel_color",
|
|
"gradient_factor",
|
|
]
|
|
|
|
DRAWSTEP_FORMAT = [
|
|
"func", "radius", "width", "height",
|
|
"xpos", "ypos", "file", "orientation",
|
|
] + DRAWSTEP_FORMAT_DEF
|
|
|
|
def __init__(self, themeName, autoLoad = True, verbose = False):
|
|
self._themeName = themeName
|
|
self._stxFiles = []
|
|
self._verbose = verbose
|
|
|
|
if autoLoad:
|
|
if not os.path.isdir(themeName) or not os.path.isfile(os.path.join(themeName, "THEMERC")):
|
|
raise IOError
|
|
|
|
for filename in os.listdir(themeName):
|
|
filename = os.path.join(themeName, filename)
|
|
if os.path.isfile(filename) and filename.endswith('.stx'):
|
|
self._stxFiles.append(filename)
|
|
|
|
def debug(self, text):
|
|
if self._verbose: print text
|
|
|
|
def debugBinary(self, data):
|
|
if self._verbose:
|
|
print "BINARY OUTPUT (%d bytes):" % len(data), " ".join(["%0.2X" % ord(c) for c in data])
|
|
|
|
def addSTXFile(self, filename):
|
|
if not os.path.isfile(filename):
|
|
raise IOError
|
|
else:
|
|
self._stxFiles.append(filename)
|
|
|
|
def parse(self):
|
|
if not self._stxFiles:
|
|
self.debug("No files have been loaded for parsing on the theme.")
|
|
raise IOError
|
|
|
|
for f in self._stxFiles:
|
|
self.debug("Parsing %s." % f)
|
|
with open(f) as stxFile:
|
|
self.__parseFile(stxFile)
|
|
|
|
def __parseFile(self, xmlFile):
|
|
stxDom = DOM.parse(xmlFile)
|
|
|
|
for layout in stxDom.getElementsByTagName("layout_info"):
|
|
self.__parseLayout(layout)
|
|
|
|
for render in stxDom.getElementsByTagName("render_info"):
|
|
self.__parseRender(render)
|
|
|
|
stxDom.unlink()
|
|
|
|
def __parseDrawStep(self, drawstepDom, localDefaults = {}):
|
|
|
|
triangleOrientations = {"top" : 0x1, "bottom" : 0x2, "left" : 0x3, "right" : 0x4}
|
|
fillModes = {"none" : 0x0, "foreground" : 0x1, "background" : 0x2, "gradient" : 0x3}
|
|
vectorAlign = {"left" : 0x1, "right" : 0x2, "bottom" : 0x3, "top" : 0x4, "center" : 0x5}
|
|
|
|
functions = {
|
|
"void" : 0x0, "circle" : 0x1, "square" : 0x2, "roundedsq" : 0x3, "bevelsq" : 0x4,
|
|
"line" : 0x5, "triangle" : 0x6, "fill" : 0x7, "tab" : 0x8, "bitmap" : 0x9, "cross" : 0xA
|
|
}
|
|
|
|
parseAttribute = {
|
|
"stroke" : int,
|
|
"bevel" : int,
|
|
"shadow" : int,
|
|
"gradient_factor" : int,
|
|
|
|
"fg_color" : self.__parseColor,
|
|
"bg_color" : self.__parseColor,
|
|
"gradient_start" : self.__parseColor,
|
|
"gradient_end" : self.__parseColor,
|
|
"bevel_color" : self.__parseColor,
|
|
|
|
"radius" : lambda r: 0xFF if r == 'auto' else int(r),
|
|
"file" : str,
|
|
"orientation" : lambda o: triangleOrientations[o],
|
|
"fill" : lambda f: fillModes[f],
|
|
"func" : lambda f: functions[f],
|
|
|
|
"width" : lambda w: -1 if w == 'height' else 0 if w == 'auto' else int(w),
|
|
"height" : lambda h: -1 if h == 'width' else 0 if h == 'auto' else int(h),
|
|
|
|
"xpos" : lambda pos: vectorAlign[pos] if pos in vectorAlign else int(pos),
|
|
"ypos" : lambda pos: vectorAlign[pos] if pos in vectorAlign else int(pos),
|
|
}
|
|
|
|
dstable = {}
|
|
|
|
attributes = []
|
|
|
|
if drawstepDom.tagName == "defaults":
|
|
isGlobal = drawstepDom.parentNode.tagName == "render_info"
|
|
|
|
for attr in self.DRAWSTEP_FORMAT_DEF:
|
|
if drawstepDom.hasAttribute(attr):
|
|
self.debug("P: %s <= '%s'" % (attr, drawstepDom.getAttribute(attr)))
|
|
dstable[attr] = parseAttribute[attr](drawstepDom.getAttribute(attr))
|
|
|
|
elif isGlobal:
|
|
dstable[attr] = 0x0
|
|
|
|
else:
|
|
for attr in self.DRAWSTEP_FORMAT:
|
|
if drawstepDom.hasAttribute(attr):
|
|
self.debug("P: %s <= '%s'" % (attr, drawstepDom.getAttribute(attr)))
|
|
dstable[attr] = parseAttribute[attr](drawstepDom.getAttribute(attr))
|
|
elif attr in self.DRAWSTEP_FORMAT_DEF:
|
|
dstable[attr] = localDefaults[attr] if attr in localDefaults else self._globalDefaults[attr]
|
|
else:
|
|
dstable[attr] = 0x0
|
|
|
|
return dstable
|
|
|
|
|
|
def __parseDrawStepToBin(self, stepDict, isDefault):
|
|
DRAWSTEP_BININFO = {
|
|
"stroke" : "B", "shadow" : "B", "bevel" : "B",
|
|
"factor" : "B", "fg_color" : "BBB", "bg_color" : "BBB",
|
|
"fill" : "B", "func" : "B", "radius" : "i",
|
|
"width" : "i", "height" : "i", "xpos" : "i",
|
|
"ypos" : "i", "orientation" : "B", "file" : "B%ds",
|
|
|
|
"gradient_start" : "BBB", "gradient_end" : "BBB",
|
|
"bevel_color" : "BBB", "gradient_factor" : "B",
|
|
}
|
|
|
|
packLayout = ""
|
|
packData = []
|
|
attributes = self.DRAWSTEP_FORMAT_DEF if isDefault else self.DRAWSTEP_FORMAT
|
|
|
|
for attr in attributes:
|
|
layout = DRAWSTEP_BININFO[attr]
|
|
data = stepDict[attr]
|
|
|
|
if layout == "B%ds":
|
|
packLayout += layout % (len(data) + 1)
|
|
packData.append(len(data))
|
|
packData.append(data)
|
|
|
|
else:
|
|
packLayout += stepDict[attr]
|
|
|
|
if isinstance(data, tuple):
|
|
for d in data:
|
|
packData.append(d)
|
|
else:
|
|
packData.append(data)
|
|
|
|
stepBin = struct.pack(packLayout, *tuple(packData))
|
|
self.debugBinary(stepBin)
|
|
return stepBin
|
|
|
|
|
|
def __parseResolutionToBin(self, resString):
|
|
"""
|
|
/b bII bII bII/
|
|
b => number of resolution sections
|
|
bII => exclude byte, X resolution, Y resolution
|
|
"""
|
|
|
|
if resString == "":
|
|
return struct.pack("bbII", 1, 0, 0, 0)
|
|
|
|
resolutions = resString.split(", ")
|
|
packFormat = "b" + "bII" * len(resolutions)
|
|
packData = [len(resolutions)]
|
|
|
|
for res in resolutions:
|
|
exclude = 0
|
|
if res[0] == '-':
|
|
exclude = 1
|
|
res = res[1:]
|
|
|
|
try:
|
|
x, y = res.split('x')
|
|
x = 0 if x == 'X' else int(x)
|
|
y = 0 if y == 'Y' else int(y)
|
|
except ValueError:
|
|
raise InvalidResolution
|
|
|
|
packData.append(exclude)
|
|
packData.append(x)
|
|
packData.append(y)
|
|
|
|
buff = struct.pack(packFormat, *tuple(packData))
|
|
self.debug("Pack format: %s => %s" % (packFormat, str(packData)))
|
|
self.debugBinary(buff)
|
|
return buff
|
|
|
|
def __parseRGBToBin(self, color):
|
|
"""
|
|
/BBB/
|
|
B => red color byte
|
|
B => green color byte
|
|
B => blue color byte
|
|
"""
|
|
|
|
try:
|
|
rgb = tuple(map(int, color.split(", ")))
|
|
except ValueError:
|
|
raise self.InvalidRGBColor
|
|
|
|
if len(rgb) != 3:
|
|
raise self.InvalidRGBColor
|
|
|
|
for c in rgb:
|
|
if c < 0 or c > 255:
|
|
raise self.InvalidRGBColor
|
|
|
|
rgb = struct.pack("BBB", *tuple(rgb))
|
|
|
|
self.debugBinary(rgb)
|
|
return rgb
|
|
|
|
def __parseColor(self, color):
|
|
try:
|
|
color = self.__parseRGBToBin(color)
|
|
except self.InvalidRGBColor:
|
|
if color not in self._colors:
|
|
raise self.InvalidRGBColor
|
|
color = self._colors[color]
|
|
|
|
return color
|
|
|
|
|
|
def __parsePalette(self, paletteDom):
|
|
self._colors = {}
|
|
|
|
for color in paletteDom.getElementsByTagName("color"):
|
|
color_name = color.getAttribute('name')
|
|
color_rgb = self.__parseRGBToBin(color.getAttribute('rgb'))
|
|
|
|
self._colors[color_name] = color_rgb
|
|
self.debug("COLOR: %s" % (color_name))
|
|
|
|
|
|
def __parseBitmaps(self, bitmapsDom):
|
|
self._bitmaps = []
|
|
|
|
for bitmap in bitmapsDom.getElementsByTagName("bitmap"):
|
|
bmpName = bitmap.getAttribute("filename")
|
|
resolution = self.__parseResolutionToBin(bitmap.getAttribute("resolution"))
|
|
|
|
self._bitmaps.append((bmpName, resolution))
|
|
self.debug("BITMAP: %s" % bmpName)
|
|
|
|
def __parseFonts(self, fontsDom):
|
|
self._fonts = []
|
|
|
|
for font in fontsDom.getElementsByTagName("font"):
|
|
ident = font.getAttribute("id")
|
|
color = self.__parseColor(font.getAttribute("color"))
|
|
filename = font.getAttribute("file")
|
|
|
|
resolution = self.__parseResolutionToBin(font.getAttribute("resolution"))
|
|
self.debug("FONT: %s @ %s" % (ident, filename))
|
|
self._fonts.append((ident, filename, color, resolution))
|
|
|
|
def __parseDrawData(self, ddDom):
|
|
|
|
for ds in ddDom.getElementsByTagName("drawstep"):
|
|
dstable = self.__parseDrawStep(ds)
|
|
print dstable
|
|
|
|
|
|
def __parseLayout(self, layoutDom):
|
|
self.debug("GLOBAL SECTION: LAYOUT INFO.")
|
|
|
|
def __parseRender(self, renderDom):
|
|
self.debug("GLOBAL SECTION: RENDER INFO.")
|
|
|
|
paletteDom = renderDom.getElementsByTagName("palette")[0]
|
|
bitmapsDom = renderDom.getElementsByTagName("bitmaps")[0]
|
|
fontsDom = renderDom.getElementsByTagName("fonts")[0]
|
|
defaultsDom = renderDom.getElementsByTagName("defaults")[0]
|
|
|
|
self.__parsePalette(paletteDom)
|
|
self.__parseBitmaps(bitmapsDom)
|
|
self.__parseFonts(fontsDom)
|
|
|
|
self._globalDefaults = self.__parseDrawStep(defaultsDom)
|
|
|
|
for dd in renderDom.getElementsByTagName("drawdata"):
|
|
self.__parseDrawData(dd)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
bin = STXBinaryFile('scummmodern', True, True)
|
|
bin.parse()
|
|
|