|(34 intermediate revisions by 8 users not shown)|
See [[GUI Themes/TODO|GUI TODO]]. See [[GUI Themes/Custom Themes|here]] for theme downloads.
GUI GUI . .
GUI Themes config file format ==
=== Overview ===
We always have a built-in theme. It is used when there is no external . ini file. For simplicity it uses exactly same format as external . ini but is defined in Theme::_defaultConfigINI string in gui/ theme-config.cpp file.
Config file consists of at least one section. These sections can override one another. This is used to make a slight alteration of base theme possible without duplicating all element whose position is not changed.
is of .
'''NOTE: if you want to add new widgets, pay attention to correspondent section [[#What_to_do_if_I_need_to_add_new_widgets_to_GUI|below]]'''
=== Section names ===
definedthis can be or
They are defined with this regexp: (X|[0-9]+)x(Y|[0-9+]+). I.e. possible names are:
* [XxY] -- universal one which can be used for any resolution
* [640xY] -- could be used for 640x400 and 640x480
* [Xx400] -- could be used for 640x400 only (or any other resolution with height 400)
* [640x480] -- could be used for 640x480 only
=== Expressions ===
./and . .
To add most flexibility arbitrary arithmetic expressions can be used for specifying any element. Allowed operations are '(', ')', '+', '-', '*', '/ '. unary '+' and unary '-'. Atoms are either number or symbolic names.
Built-in Constants ===
Currently there are these built-in constants defined:
These correspond to constants defined in gui/widget.h file. There is no restriction on constants names.
* kThumbnailWidth -- defined in graphics/ scaler.h
* false = 0
* true = 1
=== Built-in Variables ===
ScummVM is :
Built-in variables are symbolic names for ScummVM variables whose value is determined at run-time. These are:
* w -- current GUI width
* h -- current GUI height
Defining widget positions ===
Widgets are specified by following construction:
widget_name=X Y [W H]
X, Y, W and H are whitespace-delimited expressions.
, and . .
W and H are optional.
construct effectively defines
If W and H are present, also these get defined:
widget_name. x2 = widget_name. x + widget_name.w
* widget_name.y2 = widget_name.y + widget_name.h
chooser_headline=10 6 (w - 2 * 16) (kLineHeight)
Widget properties ===
Above mentioned constructions with dots are called widget properties.
Also there are following additional widget properties:
* .visible -- if set to 0, then widget is not drawn
to , is not , .
* .align -- for text widgets defines text alignment (kTextAlignLeft, kTextAlignRight or kTextAlignCenter). Default is kTextAlignLeft
Widget class properties ===
Each widget class can be customized per-resolution. You need to specify their special properties.
==== ListWidget ====
is of . .
This is widget with list of selectable items
''leftPadding'', ''rightPadding'', ''topPadding'' and ''bottomPadding'' specify list contents (text) padding from widget edges. Default values are 0.
, , .
''hlLeftPadding'', ''hlRightPadding'' specify padding of selected text highlight, i.e. green bar in ''modern'' theme. Default values are 0.
==== PopUpWidget ====
This is drop-down list used to select one item out of several. In inactive state it displays only selected item.
leftPadding'' and '' rightPadding'' specify list contents (text) padding from widget endges. Default values are 0.
''labelSpacing'' is used to specify space between text label and widget itself.
==== EditTextWidget ====
This is editable text.
''leftPadding'' and ''rightPadding'' specify list contents (text) padding from widget endges. Default values are 0.
''font'' is used to specify font used by the widget.
==== Console ====
This is our debug console
''font'' is used to specify font for console. Note, that console uses fixed font.
''leftPadding'', ''rightPadding'', ''topPadding'' and ''bottomPadding'' specify console contents (text) padding from widget edges. Default values are 0.
=== Special variables ===
Special variables are:
It is reference to current and last defined widget special variables respectively, i. e. .x, .y, .w and .h
chooser_list=10 (6 + kLineHeight + 2) (w - 2 * 16) (h - self. y - buttonHeight - 12)
Denote self. y which equals to computed value of (6 + kLineHeight + 2).
. to .
You cannot use these references forward, i.e. refer to .w in .x. They get defined from left to right.
== Defining variables ===
def_kLineHeight=16 * 2
OneThirdWidth=(w / 3)
variable kLineHeight gets value 32. OneThirdWidth will be GUI width divided by 3. Note use of parens in last example. Definitions with ' def_' prefix have a special meaning and get skipped with USE keyword (see below).
=== Defining aliases ===
to , . , and .
You can define alias to any symbolic atom, i. e. constants, variables and widget properties.
Now you can use headerBottomX everywhere.
the resolution used in, will be '''the ''': of the 'to using , and that all and of it with the <><> .
=== Special alias ===
It sets 6 aliases for each widget property, i.e.
* parent.x = chooser_list.x
* parent.y = chooser_list.y
etc for .w, .h, .x2 and .y2
midi_checkbox=(parent.x + 10) (parent.y + 20)
roland_checkbox=midi_checkbox.x (parent.y + 50)
=== USE keyword ===
You can request loading of some particular section at any time within another section. But all variable definitions with def_ prefix get skipped. If you want to define a variable, use plain VAR=VAL construction.
listW=(w - 2 * 16)
chooser_headline=10 6 listW (kLineHeight)
chooser_list=10 (6 + kLineHeight + 2) listW (h - self.y - buttonHeight - 12)
In this example for 320xY resolution chooser_headline and chooser_list will be loaded from [640xY] section, though buttonHeight and kLineHeight will be different. listW will get the value.
=== USEASIS keyword ===
Same as USE keyword above but without def_ valuse skipped. Used for weird resolution aliases.
# MM NES resolution
=== USEWITHPREFIX keyword ===
This keyword is similiar to above described USE keyword. The difference is that all defined widgetset will get specified prefix. Example:
myw=(options_dialog.w - 20)
midipopup=(myx -5) yoffset (myw + 5)
Here you will get global_midipopup and game_midipopup widgets defined.
=== skipFor keyword ===
If this key is defined within section, then section loading will be skipped for specified resolutions. For example, it is used in our modern theme to make 320xY widgets be positioned like in our classic theme.
In above case section [XxY] will not be loaded for 320x200, 320x240 or 256x240 resolutions. No spaces are allowed in specified value, only [0-9XxYx,]
=== Modern Theme configuration ===
==== 'pixmaps' section ====
==== ' colors' section ====
In the "colors" section colors for the whole theme are specified.
A color gets defined in this way:
name=R G B
with values from 0 to 255 for R, G and B.
There is a special color entry to define the transparent color for the pixmaps, named "color_transparency". Our default theme uses pink (255 0 255) as the transparent color.
color_transparency=255 0 255
To set up text colors the following entries have to be set:
color_state_disabled=192 192 192
color_state_highlight=100 162 8
color_state_enabled=0 0 0
*"color_state_disabled" is used for disabled text.
*"color_state_highlight" is used for highlighted text.
*"color_state_enabled" is used for normal text.
The ListWidget uses two special text color entries:
text_inverted_background=100 162 8
text_inverted_color=0 0 0
There "text_inverted_background" is used for the rect which is drawn when an entry is selected, "text_inverted_color" is used for the text drawn when an entry is selected.
Another special color is used for all kinds of text input widgets:
caret_color=0 0 0
This value is used for the color the caret is drawn in.
Some colors are used for background fades, you can easily spot them since they have a ' _start' and ' _end' suffix.
main_dialog_start=210 114 10
main_dialog_end=239 196 24
This defines the color fade for the launcher background. "main_dialog_start" defines the color at the top of the drawn area, "main_dialog_end" at the bottom of the drawn area, the colors in between are calculated. (see 'gradients' section
for more information).
Sometimes there is more than one color fade definition for a widget, the button
widget uses for example one colorfade for normal drawing and a special fade for highlighted
button_bkgd_start=203 126 107
button_bkgd_end=169 42 12
button_bkgd_highlight_start=255 210 200
button_bkgd_highlight_end=200 70 50
*"button_bkgd_start" and "button_bkgd_end" are used for normal drawing.
*"button_bkgd_highlight_start" and "button_bkgd_highlight_end" are used for highlighted drawing.
There are three special entries for the button widget to define the text color:
button_text_enabled=255 255 255
button_text_disabled=192 192 192
button_text_highlight=255 214 84
*"button_text_enabled" is used for normal buttons.
*"button_text_disabled" is used for buttons which are currently disabled.
*"button_text_highlight" is used for highlighted buttons.
If you want to find out all defineable colors look at our default theme config file, named "modern.ini".
==== 'gradients' section ====
==== 'extra' section ====
===== Inactive dialog effects =====
For using an effect change the "inactive_dialog_shading" option in the "[extra]" section of default-theme.ini.
Possible values are: "no_effect", "luminance" and "dim". (Note that currently backends which don't copy
the game screen into the overlay buffer should use "no_effect").
* "luminance" will change all inactive screen areas to black and white.
** Example (enables it)
* "dim" will dim the screen with the given percentage value.
** "shading_dim_percent" in the "[extra]" section sets the dimming value. 0 means no dim, 100 is completeley black
** Example (30% screen dim):
== Evaluation precedence ==
Within one section everything is computed left to right, down to top. No forward references are allowed. The only exception are aliases which can refer to not yet defined variables and widget properties, but at time of useage those variables should be defined (otherwise you will get an error).
Currently any error in evaluation will lead to error() and ScummVM will be closed. So be careful, especially with the built-in theme.
On each resolution change all user-defined variables and aliases get cleared and all sections are recomputed. When sections get loaded for a single resolution, all of them are kept, so you can specify a generic [XxY] scheme and then overwrite only some widgets, thus simplifying the whole thing.
Sections loading order is always the same. For the 640x480 resolution this is:
# Built-in theme
# Custom theme
Only present sections are loaded. If a section is not defined no error message is generated.
== Widget name conventions ==
Widget names are given in the following form:
where dialog_ is the dialog name, and widget is a distinguishable name within that dialog. Be discreet and give meaningful names.
== What to do if I need to add new widgets to GUI ==
Most importantly, not all GUI behaviour is described in theme config. You can only alter the look, not the feel. So all real coding should go into the corresponding files in the gui/ directory.
When you add a new widget, follow this checklist before committing:
* Does it look right in 320xY (./scummvm --force-1x-overlay)
** To do this you should either have no absolute positions in your config file or create [320xY] section
* Does it look right with classic theme (./scummvm --gui-theme=classic)
** that is the [XxY] section in gui/theme-config.cpp
* Does it look right < u> both< /u> with classic theme and 320xY resolution (. /scummvm --force-1x-overlay --gui-theme=classic)
** that is the [320xY] section in gui/theme-config.cpp
Currently the classic theme has the following most notable differences from the modern theme:
* Line spacing is narrower everywhere
* Indentation is smaller in most cases apart from the Game Options dialog
Since the merge of the new GUI into the ScummVM trunk, all documentation regarding the legacy GUI is now obsolete. Hence, this page has been updated with the details of the new Theme format.
A theme file in the new version of the ScummVM GUI is a compressed ZIP file which contains all the required information
- One or more STX (ScummVM Theme XML) files.
- Any external Bitmap fonts.
- Any external Bitmap images.
- A THEMERC file.
The STX Files
STX (ScummVM Theme XML) is the new format for theme descriptions on the Graphical User Interface of ScummVM.
The chosen syntax of this format is a basic subset of XML, the one which the embedded XML parser supports. Please refer to the parser documentation for its technical specifications.
Throughout the STX files, every single property of the theme's appearance and layout is defined: Although all this information can easily be stored in a single file, the theme engine conveniently allows to split the different sections of the Theme Description in one or more files.
Any *.stx files contained inside the theme package will be automatically loaded and parsed. The content of such files must obviously adhere to the STX syntax which you can find in this document.
The external resources
Together with the STX files, external resources for the theme may be optionally bundled. The most usual resources are bitmaps to use in the Graphical User Interface and Bitmap fonts.
Packaged resources will then be accessible from the STX syntax (check the font and bitmap keys in the STX documentation).
The THEMERC file
ScummVM themes must also contain a simple THEMERC file stating the theme's version, name and author. The THEMERC file is a simple text file with the following syntax:
[SCUMMVM_STX0.2:Name of the ScummVM Theme:Name of the Author]
The SCUMMVM_STX0.2 is just a simple check to make sure that the theme was developed to be used on the proper version of the GUI; 0.2 is the latest version of the ScummVM STX format. Note that the THEMERC file is not optional, as it is used by the Theme engine to check that the Theme package is indeed valid and specifies the Name and Author fields that will be shown on the GUI.
Building theme packages
Building a ScummVM Theme Package is as easy as dragging your STX files, bitmaps, resources and THEMERC files into your favorite archiver application and creating a zip file. However, to make the development process easier, a Python script called scummtheme.py has been included in the gui/themes/ folder of the Git repository.
When ran with the makeall argument, the script will automatically parse all the theme folders in the Theme directory and build their ZIP files. It can be also used to build a single theme by passing it the make [themename] argument, where [themename] is the name of the folder containing the theme to be built.
This Python script is totally standalone and doesn't require external ZIP utilities, only a standard Python distribution.
Building the built-in theme
The Graphical User Interface must contain a built-in theme to use a fall-back when no other custom themes can be loaded. The built-in theme must be built manually with the scummtheme.py script, by passing it the default [themename] argument.
The Python script will then parse the supplied theme's STX files into a single *.inc file; this file is automatically built together with the ScummVM executable file when building the ScummVM source code, and will be used as the default built-in theme.
Note that because only STX files are embedded in the source code, the theme which is converted into a built-in theme cannot contain Bitmaps or any other external resources.
By default, the ScummVM Classic Theme is the built-in theme.
The process of rendering a widget on the screen is discretized into several phases called drawing steps. A set of such steps, which generate a basic widget shape on screen is called a Draw Data set. The GUI Engine loads all the different data sets for a given widget and takes care of rendering it into the screen based on its current state.
For example, the basic Button widget may be composed of several sets of data: Drawing data for the button's idle state, drawing data for when the button is hovered and drawing data for when the button is pressed.
The functionality of each set of Drawing Data is hard-coded into the Graphical User Interface; the most up to date version of all the drawing sets may be found extensively commented in the "gui/ThemeEngine.h" file, in the DrawData enumeration.
In order to successfully parse and load a custom theme definition, the whole list of Draw Data sets is not required to be defined in a theme description, but failing to declare all of them will make the parser complain and obviously several GUI elements will be missing.
Theme Layout specifications
The actual positioning and layout of widgets and dialogs on the graphical user interface is defined from the Layout section of the STX file. This new Graphical User Interface using a Flowing Layouts system which greatly differs from the old coordinate and arithmetic based implementation.
The best way to learn about the new Layout system is to read the documentation on the layout key and its children, and to read the example Layout Design section, which provides a detailed overview into the steps required to design the layout of a dialog.
A full STX theme description is composed of:
- A root <render_info> key, containing all the information regarding the looks of the theme.
- An optional <palette> key, containing color definitions.
- An optional <bitmaps> key, containing all the loaded bitmaps which will be used on the GUI.
- A <fonts> key, specifying the fonts used to draw text on the GUI.
- A <drawdata> key for each DrawData identifier of the Theme Engine, specifying how is each individual widget drawn.
- A root <layout_info> key, containing all the information regarding the layout of the theme.
- A <globals> key, containing the global variables to use on the layout design.
- A <dialog> key for each dialog in the GUI, specifying the layout and position of the dialog and all its children widgets.
Here's a schematic overview of the layout of keys in a STX file:
The best place to start writing a full theme description is taking a look at the already written themes in the gui/themes/ directory of the source code repository, while consulting the following documentation for each specific key:
Detailed STX documentation
The full documentation of the XML syntax used in the new Graphical User Interface can be found on its own wiki page.
Resolution-dependent keys and layouts
Several keys in the STX syntax support the resolution property, which allows to load or skip the key and all its children when loading the theme on a given resolution dimension limit.
The resolution property must contain one or more resolution dimension limits, comma separated, for which the given key is supposed to be loaded. Resolutions without any modifiers will force the theme to be loaded in all resolutions. Here are a few examples:
/* Key will be loaded in all resolutions */
/* Key will ONLY be loaded in resolutions with 400 width or more */
<render_info resolution = 'y>399'>
/* Key will ONLY be loaded in resolutions with less than 400 height */
<render_info resolution = 'y<400'>
Note that the Theme Parser does not assert on repeated keys or values, it just replaces them accordingly. For instance, the following variable definition:
<def var = 'TestVar' value = '100'/>
<def var = 'TestVar' value = '200' resolution = 'y>399'/>
won't fail to parse. What will happen when loading the theme using a resolution with 400 height or mire is that TestVal first will be assigned the 100 value, and then it will be overwritten with the 200 value. On the other hand, when loading the theme using a resolution with less than 400 height, the ThemeVal will be assigned the 100 value and the second key will be plain ignored.
The "proper" way to do that multi-resolution assignment would obviously be:
<def var = 'TestVar' value = '100' resolution = 'y<400'/>
<def var = 'TestVar' value = '200' resolution = 'y>399'/>
This way keys are only parsed on the resolution they are used in, but the result will be exactly the same: Most of the time it's just cleaner to avoid using y<400 resolution tags, and instead write a layout that works on all resolutions and overwrite parts of it with the y>399 tag.