Bump version.

This is a minor behavior change. Before this, renpy.play would stop
the playing sound if called with None - which is the default in a lot
of circumstances.

.gitignore

@@ -0,0 +1,54 @@
+*.rpyc
+*.rpyb
+*.rpymc
+*.pyc
+*.pyo
+
+*~
+*.bak 
+
+saves
+tmp
+cache
+
+log.txt
+
+/build
+/dist
+/dists
+/renpy.app
+/jedit
+/lint.txt
+/renpy.code
+/traceback.txt
+/testing*
+/screenshot*
+/errors.txt
+/styles.txt
+/Microsoft.VC90.CRT.manifest
+/console.exe
+/msvcr90.dll
+/python27.dll
+/renpy.exe
+/lib/windows-x86
+/lib/linux-x86_64
+/lib/linux-i686
+/lib/python2.7
+/doc
+/.pydevproject
+/.pydevproject.bak
+/.project
+/.settings
+/LICENSE.txt
+/template/README.html
+/the_question/README.html
+/tutorial/README.html
+/renpy/angle/*.pyx
+/renpy/angle/*.pxd
+/renpy-ppc.zip
+/module/build
+/module/gen
+/editra
+
+dl
+renpy/vc_version.py

LICENSE.txt

@@ -1,47 +0,0 @@
-Copyright 2004-2005 PyTom <pytom@bishoujo.us>
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation files
-(the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-
-Please note that the above license only applies to Ren'Py
-proper. A binary distribution of Ren'Py contains a number of other
-packages, each with their own licenses, which you may be bound to
-comply with when distributing a Ren'Py game. 
-
-These packages may include:
-
-Python (Python License)
-http://www.python.org
-
-Pygame (GNU LGPL)
-http://www.pygame.org
-
-SDL (GNU LGPL)
-http://www.libsdl.org
-
-SDL_mixer (GNU LGPL)
-http://www.libsdl.org/projects/SDL_mixer
-
-SDL_ttf (GNU LGPL)
-http://www.libsdl.org/projects/SDL_ttf
-
-ctypes (MIT)
-http://starship.python.net/crew/theller/ctypes/

README_RENPY.txt

@@ -1,42 +0,0 @@
-Greetings!
-
-You've downloaded a game that was written using Ren'Py, a python based
-engine for visual novel style games. If you're interested in making
-your own games, you may want to consider downloading Ren'Py from:
-
-     http://www.bishoujo.us/renpy/
-
-Ren'Py games can be played using the keyboard or the mouse.
-
-When dialogue or transitions are displayed, they can be dismissed
-by clicking the left mouse button, or pressing space or enter on the
-keyboard. When the control key is held down, dialogue and transitions
-are rapidly dismissed, provided that the user has seen them
-already. Tab toggles skipping mode.
-
-Choices on menus can be made by clicking on the appopriate choice with
-the mouse, or by picking the choice using the up and down arrow and
-hitting enter.
-
-Hitting escape or clicking the right mouse button brings up the game
-menu. This game menu lets you save and load games, quit the game, or
-return to the main menu. It also lets you set preferences that control
-the behavior of the game. These preferences are:
-
-Display            --- Controls if the game displays in a window or 
-                       fullscreen.
-Music              --- Controls if music is played or silenced.
-TAB and CTRL Skip  --- Chooses if CTRL skips all messages or only messages
-                       that have ever been seen on this computer.
-Transitions        --- Controls the amount of transitions that are shown.
-
-Finally, Ren'Py supports a rollback feature, which lets you, with some
-limits, play the game backwards. For example, you can rollback to a
-menu, and save or make a different choice. It also lets you see
-dialogue that you missed. You can rollback by pressing the 'page up'
-key, or by scrolling your mouse wheel up. Pressing 'page down' or
-scrolling your mouse wheel down lets you skip dialogue that's been
-seen in this session, which is almost the opposite of rollback.
-
-Thank you for choosing to play a Ren'Py powered game.
-

TODO.txt

@@ -1,4 +0,0 @@
-Have a new form of imagemap that uses a color image to distinguish
-hotspots.
-
-Keyd compiles.

add.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+cd ~/ab/website
+./upload.sh

add_from.py

@@ -1,104 +0,0 @@
-#!/usr/bin/env python
-
-# This program adds froms to every unqualified call found in the game
-# directory. It's not perfect, but it's better than nothing.
-
-import sys
-import os
-import re
-import glob
-
-def find_labels(fn, labels):
-
-    f = file(fn, "r")
-
-    for l in f:
-
-        m = re.match(r'^\s*call\s+\w+\s+from\s+(\w+)\s*$', l)
-        if m:
-            labels[m.group(1)] = True
-
-        m = re.match(r'^\s*call\s+expression.*from\s+(\w+)\s*$', l)
-        if m:
-            labels[m.group(1)] = True
-
-    f.close()
-
-def replace_labels(fn, labels):
-
-    f = file(fn, "r")
-    of = file(fn + ".new", "w")
-
-
-    def replaceit(m):
-        target = m.group(2)
-
-        num = 0
-
-        while True:
-            num += 1
-            label = "_call_%s_%d" % (target, num)
-
-            if label not in labels:
-                break
-
-        labels[label] = True
-
-        return m.group(1) + "call " + target + " from " + label + m.group(3)
-
-    for l in f:
-        l = re.sub(r'^(\s*)call\s+(\w+)(\s*$)', replaceit, l)
-
-        if re.search(r'call\s+expression', l) and not re.search('from', l):
-
-            num = 0
-
-            while True:
-                num += 1
-                label = "_call_expression_%d" % num
-
-                if label not in labels:
-                    break
-
-            labels[label] = label
-
-            l = l[:-1] + " from " + label + "\n"
-
-        of.write(l)
-
-    f.close()
-    of.close()
-
-
-    try:
-        os.unlink(fn + ".bak")
-    except:
-        pass
-    
-    os.rename(fn, fn + ".bak")
-    os.rename(fn + ".new", fn)
-
-def main():
-
-    pattern = "*/*.rpy"
-
-    if len(sys.argv) >= 2:
-        pattern = sys.argv[1]
-
-    files = glob.glob(pattern)
-    files = [ i for i in files if not i.startswith("common/") ]
-
-    labels = { }
-    
-    for fn in files:
-        print "Finding labels in", fn
-        find_labels(fn, labels)
-
-    for fn in files:
-        print "Replacing labels in", fn
-        replace_labels(fn, labels)
-    
-
-
-if __name__ == "__main__":
-    main()

after_checkout.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+ln -s ../help.html tutorial/README.html
+ln -s ../help.html the_question/README.html
+ln -s ../help.html template/README.html
+
+ln -s sphinx/source/license.rst LICENSE.txt
+ln -s sphinx/build/html doc

ansetup.py

@@ -0,0 +1,10 @@
+# This file sets up the normal python modules. It's used to help eclipse 
+# do type detection, by providing an importable version of the cython code.
+
+from distutils.core import setup
+
+setup(
+    packages=['renpy', 'renpy.gl', 'renpy.angle', 'renpy.display', 'renpy.audio', 'renpy.text', 'pysdlsound'],
+    package_dir={ 'pysdlsound' : 'module' },
+    )
+

archive_images.bat

@@ -1,3 +0,0 @@
-cd game
-..\archiver.exe images *.png *.jpg
-pause

archiver.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python
-
-# The Ren'Py archiver. This builds a Ren'Py archive file, and the
-# associated index file. These files are really easy to reverse-engineer,
-# but are probably better than nothing.
-
-import sys
-import os
-import encodings.zlib_codec
-import random
-import glob
-
-from cPickle import loads, dumps, HIGHEST_PROTOCOL
-
-# The most we will go without inserting some padding. 10k.
-padding_every = 10240
-
-# The amount of padding we will add.
-padding_max = 32
-
-def randpadding():
-
-    plen = random.randint(1, padding_max)
-
-    rv = ""
-
-    for i in range(0, plen):
-        rv += chr(random.randint(1, 255))
-
-    return rv
-
-def main():
-    if len(sys.argv) < 3:
-        print "Usage: %s <file-prefix> <files ...>" % sys.argv[0]
-        return
-
-    prefix = sys.argv[1]
-
-    # Archive file.
-    archivef = file(prefix + ".rpa", "wb")
-
-    # Index file.
-    indexf = file(prefix + ".rpi", "wb")
-
-    index = { }
-
-    random.seed()
-
-    offset = 0
-
-    # Needed because windows sucks. It doesn't do globbing on the
-    # command line.
-    files = [ ]
-    for i in sys.argv[2:]:
-        files.extend(glob.glob(i))
-
-    for fn in files:
-        index[fn] = [ ]
-
-        print "Adding %s..." % fn
-
-        datafile = file(fn, "rb")
-
-        while True:
-
-            # Pad with junk.
-            padding = randpadding()
-            archivef.write(padding)
-            offset += len(padding)
-
-            # Pick a random block size.
-            block = random.randint(1, padding_every)
-
-            data = datafile.read(block)
-
-            if not data:
-                break
-
-            dlen = len(data)
-
-            archivef.write(data)
-
-            index[fn].append((offset, dlen))
-            offset += dlen
-                      
-        datafile.close()
-
-    archivef.close()
-
-    indexf.write(dumps(index, HIGHEST_PROTOCOL).encode("zlib"))
-    indexf.close()
-    
-    
-
-if __name__ == "__main__":
-    main()

build_exe.bat

@@ -1 +0,0 @@
-build_exe.py run_game

build_exe.py

@@ -1,31 +1,111 @@
 #!/usr/bin/env python
 
+import modulefinder
+import shutil
 from distutils.core import setup
-import py2exe
+import py2exe #@UnresolvedImport @UnusedImport
 import sys
+import zipfile
+import traceback
+import os
 
-if len(sys.argv) != 2:
-    print "Usage: build_exe.py <prefix>"
-    print ""
-    print "Builds <prefix>.exe."
-    print "Expects icons in <prefix>.ico."
+# The pythonpath on my system.
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\bin')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\python')
 
-    sys.exit(-1)
+def move_from_dist(fn):
+    """
+    Moves the file `fn` from the dist directory to the main
+    directory. (This means we don't need symlinks on windows.)
+    """
 
-def program(name):
-    return dict(script="run_game.py",
-                icon_resources=[ (0, name + ".ico"),
-                                 ],
-                dest_base=name)
+    if os.path.isdir(fn):
+        shutil.rmtree(fn)
+    elif os.path.exists(fn):
+        os.unlink(fn)
 
-programs = [
-    program(sys.argv[1]),
-    ]
+    os.rename("dist/" + fn, fn)
 
-sys.argv[1:] = [ 'py2exe' ]
+import renpy
+renpy.setup_modulefinder(modulefinder) #@UndefinedVariable
 
-setup(name="RenPy",
-      windows=programs,
-      console=[ "archiver.py", "add_from.py", "console.py", "dump_text.py" ],
-      zipfile='lib/renpy.zip',
-      )
+def main():
+
+    sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
+
+    setup(name="Ren'Py",
+          windows=[ dict(script="renpy.py",
+                         dest_base="renpy",
+                         icon_resources=[ (1, "newicon.ico") ],
+                         ),
+                    ],
+
+          console=[ dict(script="renpy.py", dest_base="console") ],
+
+          zipfile='lib/windows-x86/renpy.code',
+
+          options={ 'py2exe' : { 'excludes' : [ 'doctest',
+                                                'pygame.macosx',
+                                                'pygame.surfarray',
+                                                'pygame.mixer',
+                                                'pygame.mixer_music',
+                                                '_ssl',
+                                                '_hashlib',
+                                                'win32con',
+                                                'win32api',
+                                                'Numeric',
+                                                'os2emxpath',
+                                                'macpath',
+                                                'multiprocessing',
+                                                '_multiprocessing',
+                                                ],
+                                 'optimize' : 2,
+                                 } },
+          )
+
+
+    zfold = zipfile.ZipFile("dist/lib/windows-x86/renpy.code")
+    zfnew = zipfile.ZipFile("dist/lib/windows-x86/renpy.code.new", "w", zipfile.ZIP_STORED)
+
+    seen = { }
+
+    for fn in zfold.namelist():
+        if fn.startswith("renpy/"):
+
+            # Keep around .pyo files that load pyd files.
+            pydfn = fn.replace("/", ".").replace(".pyo", ".pyd")
+            if not os.path.exists("dist/lib/windows-x86/" + pydfn):
+                continue
+
+        if fn in seen:
+            continue
+
+        if fn == "SDL_mixer.dll":
+            continue
+        
+        seen[fn] = True
+
+        zfnew.writestr(fn, zfold.read(fn))
+
+    zfold.close()
+    zfnew.close()
+
+    os.unlink("dist/lib/windows-x86/renpy.code")
+    os.rename("dist/lib/windows-x86/renpy.code.new", "dist/lib/windows-x86/renpy.code")
+
+    # Take these files from the old python.
+    shutil.copy("c:/Python26/Microsoft.VC90.CRT.manifest", "Microsoft.VC90.CRT.manifest")
+    shutil.copy("c:/Python26/msvcr90.dll", "msvcr90.dll")
+
+    move_from_dist("lib/windows-x86")
+    move_from_dist("console.exe")
+    move_from_dist("python27.dll")
+    move_from_dist("renpy.exe")
+
+
+try:
+    main()
+except:
+    traceback.print_exc()
+
+    

build_strings.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+
+import collections
+import glob
+import re
+import os
+
+# A map from string to filename, line number where the string is found.
+strings = collections.defaultdict(list)
+
+def process(fn):
+
+    lineno = 0
+    
+    for data in file(fn, "r"):
+
+        lineno += 1
+
+        matches = [ ]
+        
+        matches += re.finditer(r'\bu\"(\\"|[^"])+\"', data)
+        matches += re.finditer(r"\bu\'(\\'|[^'])+\'", data)
+
+        for m in matches:
+            s = m.group(0)[2:-1]
+
+            if "\\u" in s:
+                continue
+
+            if len(s) == 1:
+                continue
+            
+            strings[s].append("%s:%d" % (fn, lineno))
+
+if __name__ == "__main__":
+
+    files = [ ]
+
+    files += glob.glob("launcher/*.rpy")
+    files += glob.glob("common/*.rpy")
+    files += glob.glob("common/*.rpym")
+    files += glob.glob("common/_layout/*.rpym")
+    files += glob.glob("common/_compat/*.rpym")
+
+    if "launcher/strings.rpy" in files:
+        files.remove("launcher/strings.rpy")
+    
+    for fn in files:
+        process(fn)
+
+    converse = [ ]
+        
+    for k, v in strings.iteritems():
+        v = " ".join(sorted(v))
+        converse.append((v, k))
+
+    converse.sort()
+
+    f = file("launcher/strings.rpy", "w")
+
+    files = set(i for i in os.listdir("launcher") if i.endswith(".rpy"))
+    
+    print >>f, """\
+init python:
+    LAUNCHER_RPYS = %r
+
+    TRANSLATION_STRINGS = [
+""" % files
+    
+    for v, k in converse:
+        # print
+        # print "#:", v
+        # print "#, python-format"
+
+        print >>f, "        u\"%s\"," % unicode(k)
+
+    print >>f, """\
+    ]
+"""

common/00atl.rpy

@@ -0,0 +1,35 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains warpers that are used by ATL. They need to be defined
+# early, so Ren'Py knows about them when parsing other files.
+
+python early hide:
+
+    # pause is defined internally, but would look like:
+    #
+    # @renpy.atl_warper
+    # def pause(t):
+    #     if t >= 1.0:
+    #         return 1.0
+    #     else:
+    #         return 0.0
+    
+    @renpy.atl_warper
+    def linear(t):
+        return t
+
+    @renpy.atl_warper
+    def easeout(x):
+        import math
+        return 1.0 - math.cos(x * math.pi / 2.0)
+
+    @renpy.atl_warper
+    def easein(x):
+        import math
+        return math.cos((1.0 - x) * math.pi / 2.0)
+
+    @renpy.atl_warper
+    def ease(x):
+        import math
+        return .5 - math.cos(math.pi * x) / 2.0

common/00build.rpy

@@ -0,0 +1,301 @@
+
+# Contains functions and variables that control the building of 
+# distributions.
+
+init -1000 python in build:
+    
+    def make_file_lists(s):
+        """
+        Turns `s` into a (perhaps empty) list of file_lists.
+        
+        If `s` is a list or None, then returns it. If it's a string, splits
+        it on whitespace. Otherwise, errors out.
+        """
+        
+        if s is None:
+            return s
+        elif isinstance(s, list):
+            return s
+        elif isinstance(s, basestring):
+            return s.split()
+            
+        raise Exception("Expected a string, list, or None.")
+    
+
+
+    def pattern_list(l):
+        """
+        Apply file_lists to the second argument of each tuple in a list.
+        """
+        
+        rv = [ ]
+        
+        for pattern, groups in l:
+            rv.append((pattern, make_file_lists(groups)))
+            
+        return rv
+
+    # Patterns that are used to classify Ren'Py.
+    renpy_patterns = pattern_list([
+        ( "**~", None),
+        ( "**/#*", None),
+        ( "**/.*", None),
+        ( "**.old", None),
+        ( "**.new", None),
+        ( "**.rpa", None),
+
+        ( "**/*.pyc", None),
+
+        ( "renpy.py", "all"),
+        ( "renpy/**", "all"),
+        ( "common/**", "all"),
+
+        # Windows-specific patterns.
+        ( "python*.dll", "windows" ),
+        ( "msvcr*.dll", "windows"),
+        ( "Microsoft.VC*.CRT.manifest", "windows"),
+        ( "lib/dxwebsetup.exe", "windows"),
+        ( "lib/windows-x86/**", "windows"),
+        
+        # Linux patterns. 
+        ( "renpy.sh", "linux"),
+        ( "lib/linux-x86_64/**", "linux"),
+        ( "lib/linux-i686/**", "linux"),
+        ( "lib/python2.7/**", "linux"),
+        
+        # Mac patterns.
+        ( "renpy.app/Contents/Ren'Py Launcher", None),
+        ( "renpy.app/Contents/Info.plist", None),
+        ( "renpy.app/Contents/Resources/launcher.py", None),
+        ( "renpy.app/Contents/Resources/launcher.icns", None),
+        ( "renpy.app/**", "mac"),
+        
+        # Shared patterns.
+        ( "/lib/", "windows linux"),
+    ])
+
+ 
+    def classify_renpy(pattern, groups):
+        """
+        Classifies files in the Ren'Py base directory according to pattern.
+        """
+        
+        renpy_patterns.append((pattern, make_file_lists(groups)))
+
+    # Patterns that are relative to the base directory.
+    
+    early_base_patterns = pattern_list([ 
+        ("*.py", None),
+        ("*.sh", None),
+        ("*.app/", None),
+        ("*.dll", None),
+        ("*.manifest", None),
+        
+        ("lib/", None),
+        ("renpy/", None),
+        ("update/", None),
+        ("common/", None),
+        ("update/", None),
+        
+        ("icon.ico", None),
+        ("icon.icns", None),
+        ("project.json", None),
+
+        ("tmp/", None),
+        ("game/saves/", None),
+
+        ("archived/", None),
+        ("launcherinfo.py", None),
+        ("android.txt", None),
+        ])
+    
+    base_patterns = [ ]
+    
+    late_base_patterns = pattern_list([
+        ("**", "all")
+        ])
+    
+    def classify(pattern, file_list):
+        """
+        :doc: build
+        
+        Classifies files that match `pattern` into `file_list`.
+        """
+        
+        base_patterns.append((pattern, make_file_lists(file_list)))
+        
+    def clear():
+        """
+        :doc: build
+        
+        Clears the list of patterns used to classify files.
+        """
+        
+        base_patterns[:] = [ ]
+      
+    def remove(l, pattern):
+        """
+        Removes the pattern from the list.
+        """
+        
+        l[:] = [ (p, fl) for i in l if p != pattern ]
+      
+    # Archiving.
+      
+    archives = [ ]
+    
+    def archive(name, file_list="all"):
+        """
+        :doc: build
+        
+        Declares the existence of an archive. If one or more files are 
+        classified with `name`, `name`.rpa is build as an archive. The 
+        archive is included in the named file lists.
+        """
+        
+        archives.append((name, make_file_lists(file_list)))
+        
+    archive("archive", "all") 
+        
+    # Documentation patterns.
+    
+    documentation_patterns = [ ]
+    
+    def documentation(pattern):
+        """
+        :doc: build
+        
+        Declares a pattern that matches documentation. In a mac app build, 
+        files matching the documentation pattern are stored twice - once
+        inside the app package, and again outside of it.
+        """
+        
+        documentation_patterns.append(pattern)
+
+    xbit_patterns = [
+        "**.sh",
+        "**/*.so.*",
+        "**/*.so",
+        "**/*.dylib",
+        "**.app/Contents/MacOS/*",
+        "lib/**/python",
+        "lib/**/zsync",
+        "lib/**/zsyncmake",
+        ]
+    
+    def executable(pattern):
+        """
+        :doc: build
+        
+        Adds a pattern marking files as executable on platforms that support it. 
+        (Linux and Macintosh)
+        """
+
+        xbit_patterns.append(pattern)
+
+    # Packaging.
+        
+    packages = [ ]
+    
+    def package(name, format, file_lists, description=None, update=True, dlc=False):
+        """
+        :doc: build
+        
+        Declares a package that can be built by the packaging
+        tool. 
+        
+        `name`
+            The name of the package.
+        
+        `format`
+            The format of the package. A string containing a space separated
+            list of:
+        
+            zip
+                A zip file. 
+            app-zip
+                A zip file containing a macintosh application.
+            tar.bz2
+                A tar.bz2 file.
+
+            The empty string will not build any package formats (this 
+            makes dlc possible).
+        
+        `file_lists`
+            A list containing the file lists that will be contained
+            within the package.
+        
+        `description`
+            An optional description of the package to be built.
+        
+        `update`
+            If true and updates are being built, an update will be 
+            built for this package.
+        
+        `dlc`
+            If true, any zip or tar.bz2 file will be built in 
+            standalone DLC mode, without an update directory.
+        """
+
+        formats = format.split()
+        
+        for i in formats:
+            if i not in [ "zip", "app-zip", "tar.bz2" ]:
+                raise Exception("Format {} not known.".format(i))
+            
+        if description is None:
+            description = name
+            
+        d = {
+            "name" : name,
+            "formats" : formats,
+            "file_lists" : make_file_lists(file_lists),
+            "description" : description,
+            "update" : update,
+            "dlc" : dlc,
+            }
+            
+        packages.append(d)
+
+    package("all", "zip", "windows mac linux all", "All Desktop Platforms")
+    package("linux", "tar.bz2", "linux all", "Linux x86/x86_64")
+    package("mac", "app-zip", "mac all", "Macintosh x86")
+    package("win", "zip", "windows all", "Windows x86")
+        
+    # Data that we expect the user to set.
+    
+    # The name of directories in the archives.
+    directory_name = ""
+
+    # The name of executables.
+    executable_name = ""
+    
+    # Should we include update information into the archives?
+    include_update = False
+    
+    # A verbose version to include in the update.
+    version = None
+    
+    # Are we building Ren'Py?
+    renpy = False
+    
+    # This function is called by the json_dump command to dump the build data 
+    # into the json file.
+    def dump():
+        rv = { }
+        
+        rv["directory_name"] = directory_name
+        rv["executable_name"] = executable_name
+        rv["include_update"] = include_update
+        
+        rv["packages"] = packages
+        rv["archives"] = archives
+        rv["documentation_patterns"] = documentation_patterns
+        rv["base_patterns"] = early_base_patterns + base_patterns + late_base_patterns
+        rv["renpy_patterns"] = renpy_patterns
+        rv["xbit_patterns"] = xbit_patterns
+        rv["version"] = version or directory_name
+    
+        rv["renpy"] = renpy
+        
+        return rv

common/00compat.rpy

@@ -0,0 +1,128 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1210 python:
+
+    # This is called when script_version is set, to immediately
+    # run code in response to a script_version change.        
+    def _set_script_version(version):
+
+        if version is None:
+            return
+
+        if version <= (5, 6, 0):
+            config.check_properties = False
+
+        if version <= (6, 5, 0):
+            layout.compat()
+
+        if version <= (6, 9, 1):
+            store.library = store.config
+
+        if version <= (6, 9, 3):
+
+            # Before 6.10, these were positions, rather than transforms.
+            store.left = Position(xalign=0.0)
+            store.center = Position(xalign=0.5)
+            store.truecenter = Position(xalign=0.5, yalign=0.5)
+            store.right = Position(xalign=1.0)
+            store.offscreenleft = Position(xpos=0.0, xanchor=1.0)
+            store.offscreenright = Position(xpos=1.0, xanchor=0.0)
+
+        if version <= (6, 10, 2):
+            # Before 6.11, we used the image placement to handle
+            # the location of things on the screen.            
+            style.image_placement.xpos = 0.5
+            style.image_placement.ypos = 1.0
+            style.image_placement.xanchor = 0.5
+            style.image_placement.yanchor = 1.0
+
+            config.transform_uses_child_position = False
+            config.default_transform = None
+            config.start_scene_black = True
+            
+        if version <= (6, 11, 0):
+            config.movetransition_respects_offsets = False
+
+        if version <= (6, 11, 2):
+            config.imagereference_respects_position = True
+            config.predict_screens = False
+            config.choice_screen_chosen = False
+
+        if version <= (6, 12, 0):
+            config.keep_running_transform = False
+            config.image_attributes = False
+            config.new_character_image_argument = False
+            config.save_physical_size = False
+            
+        if version <= (6, 12, 2):
+            style.default.language = "western"
+            style.default.layout = "greedy"
+            config.new_substitutions = False
+            config.broken_line_spacing = True
+    
+        if (6, 12, 2) < version <= (6, 13, 8):
+            config.old_substitutions = False
+    
+        if version <= (6, 13, 12):
+            global MoveTransition
+            MoveTransition = OldMoveTransition
+
+
+init 1210 python hide::
+
+    # This returns true if the script_version is <= the
+    # script_version supplied. Give it the last script version
+    # where an old version was used.
+    def compat(x, y, z):
+        return config.script_version and config.script_version <= (x, y, z)
+
+    # Compat for changes to with-callback.
+    if compat(5, 4, 5):
+        if config.with_callback:
+            def compat_with_function(trans, paired, old=config.with_callback):
+                old(trans)
+                return trans
+
+            config.with_callback = compat_with_function
+
+    if not config.sound:
+        config.has_sound = False
+        config.has_music = False
+        config.has_voice = False
+        
+    # Compat for SFont recoloring.
+    if compat(5, 1, 1):
+        config.recolor_sfonts = False
+
+    if compat(5, 5, 4):
+        config.implicit_with_none = False
+
+    # Compat for changes to button look.
+    if compat(5, 5, 4):            
+        style.button.setdefault(xpos=0.5, xanchor=0.5)
+        style.menu_button.clear()
+        style.menu_button_text.clear()
+
+    if compat(5, 6, 6):
+        config.reject_midi = False
+
+    if compat(6, 2, 0):
+        config.reject_backslash = False
+
+    if compat(6, 9, 0):
+        style.motion.clear()
+        
+    if "Fullscreen" in config.translations:
+        fs = _("Fullscreen")
+        config.translations.setdefault("Fullscreen 4:3", fs + " 4:3")
+        config.translations.setdefault("Fullscreen 16:9", fs + " 16:9")
+        config.translations.setdefault("Fullscreen 16:10", fs + " 16:10")
+            
+    for i in layout.compat_funcs:
+        i()
+
+    if config.hyperlink_styler or config.hyperlink_callback or config.hyperlink_focus:
+        style.default.hyperlink_functions = (config.hyperlink_styler, config.hyperlink_callback, config.hyperlink_focus)
+        
+        

common/00definitions.rpy

@@ -0,0 +1,283 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains a number of definitions of standard
+# locations and transitions. We've moved them into the common
+# directory so that it's easy for an updated version of all of these
+# definitions.
+
+init -1110:
+
+    transform reset:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+   
+    # These are positions that can be used inside at clauses. We set
+    # them up here so that they can be used throughout the program.
+    transform left:
+        xpos 0.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform right:
+        xpos 1.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform center:
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    transform truecenter:
+        xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+
+    transform topleft:
+        xpos 0.0 xanchor 0.0 ypos 0.0 yanchor 0.0
+        
+    transform topright:
+        xpos 1.0 xanchor 1.0 ypos 0.0 yanchor 0.0
+        
+    transform top:
+        xpos 0.5 xanchor 0.5 ypos 0.0 yanchor 0.0
+        
+    # Offscreen positions for use with the move transition. Images at
+    # these positions are still shown (and consume
+    # resources)... remember to hide the image after the transition.    
+    transform offscreenleft:
+        xpos 0.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform offscreenright:
+        xpos 1.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform default:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    # These are used by the transitions to move things offscreen. We don't
+    # expect them to be used by user code.
+    transform _moveleft:
+        xpos 0.0 xanchor 1.0
+        
+    transform _moveright:
+        xpos 1.0 xanchor 0.0
+        
+    transform _movetop:
+        ypos 0.0 yanchor 1.0
+        
+    transform _movebottom:
+        ypos 1.0 yanchor 0.0
+
+    python:
+        config.default_transform = default
+        
+
+init -1110 python:
+
+    _define = define = object()
+        
+    # Transitions ############################################################
+
+    # Simple transitions.
+    fade = Fade(.5, 0, .5) # Fade to black and back.
+    dissolve = Dissolve(0.5)
+    pixellate = Pixellate(1.0, 5)
+
+    # Various uses of CropMove.    
+    wiperight = CropMove(1.0, "wiperight")
+    wipeleft = CropMove(1.0, "wipeleft")
+    wipeup = CropMove(1.0, "wipeup")
+    wipedown = CropMove(1.0, "wipedown")
+
+    slideright = CropMove(1.0, "slideright")
+    slideleft = CropMove(1.0, "slideleft")
+    slideup = CropMove(1.0, "slideup")
+    slidedown = CropMove(1.0, "slidedown")
+
+    slideawayright = CropMove(1.0, "slideawayright")
+    slideawayleft = CropMove(1.0, "slideawayleft")
+    slideawayup = CropMove(1.0, "slideawayup")
+    slideawaydown = CropMove(1.0, "slideawaydown")
+
+    irisout = CropMove(1.0, "irisout")
+    irisin = CropMove(1.0, "irisin")
+
+    # Ease images around. These are basically cosine-warped moves.
+    def _ease_out_time_warp(x):
+        print "ZZZ"
+        import math
+        return 1.0 - math.cos(x * math.pi / 2.0)
+
+    def _ease_in_time_warp(x):
+        import math
+        return math.cos((1.0 - x) * math.pi / 2.0)
+
+    def _ease_time_warp(x):
+        import math
+        return .5 - math.cos(math.pi * x) / 2.0
+
+
+    # Back up the move transition, so that if MoveTransition gets replaced by
+    # renpy.compat, this still works.
+    __MoveTransition = MoveTransition
+
+    # This defines a family of move transitions, using the old-style methods.
+    def move_transitions(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[ 'master' ], **kwargs):
+        """
+        :doc: transition_family
+
+        This defines a family of move transitions, similar to the move and ease
+        transitions. For a given `prefix`, this defines the transitions:
+
+        * *prefix*- A transition that takes `delay` seconds to move images that
+          changed positions to their new locations.
+
+        * *prefix*\ inleft, *prefix*\ inright, *prefix*\ intop, *prefix*\ inbottom - Transitions
+          that take `delay` seconds to move images that changed positions to their
+          new locations, with newly shown images coming in from the appropriate
+          side.
+
+        * *prefix*\ outleft, *prefix*\ outright, *prefix*\ outtop, *prefix*\ outbottom -
+          Transitions that take `delay` seconds to move images that changed
+          positions to their new locations, with newly hidden images leaving via
+          the appropriate side.
+
+        `time_warp`, `in_time_warp`, `out_time_warp`        
+            Time warp functions that are given a time from 0.0 to 1.0 representing
+            the fraction of the move complete, and return a value in the same 
+            range giving the fraction of a linear move that is complete.
+            
+            This can be used to define functions that ease the images around,
+            rather than moving them at a constant speed.
+            
+            The three argument are used for images remaining on the screen,
+            newly shown images, and newly hidden images, respectively.
+
+        `old`
+            If true, the transitions to move the old displayables, rather than the new ones.
+
+        `layers`        
+            The layers the transition will apply to.
+
+        ::
+
+            # This defines all of the pre-defined transitions beginning
+            # with "move".
+            init python:
+                define.move_transitions("move", 0.5)
+        
+        """
+        
+        moves = {
+            "" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                time_warp=time_warp),
+
+            "inright" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                enter=_moveright,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+
+            "inleft" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                enter=_moveleft,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+                
+            "intop" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                enter=_movetop,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+                
+            "inbottom" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                enter=_movebottom,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+
+            "outright" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                leave=_moveright,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),
+
+            "outleft" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                leave=_moveleft,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),
+
+            "outtop" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                leave=_movetop,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),
+
+            "outbottom" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                leave=_movebottom,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),
+            }
+
+        for k, v in moves.iteritems():
+            setattr(store, prefix + k, v)
+
+    define.move_transitions = move_transitions
+    del move_transitions
+
+    define.move_transitions("move", 0.5)
+    define.move_transitions("ease", 0.5, _ease_time_warp, _ease_in_time_warp, _ease_out_time_warp) 
+
+    # Zoom-based transitions. Legacy - nowadays, these are probably best done with ATL.
+    zoomin = OldMoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0))
+    zoomout = OldMoveTransition(0.5, leave_factory=ZoomInOut(1.0, 0.01))
+    zoominout = OldMoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0), leave_factory=ZoomInOut(1.0, 0.01))
+    
+    # These shake the screen up and down for a quarter second.
+    # The delay needs to be an integer multiple of the period.
+    vpunch = Move((0, 10), (0, -10), .10, bounce=True, repeat=True, delay=.275)
+    hpunch = Move((15, 0), (-15, 0), .10, bounce=True, repeat=True, delay=.275)
+
+    # These use the ImageDissolve to do some nifty effects.
+    blinds = ImageDissolve(im.Tile("blindstile.png"), 1.0, 8)
+    squares = ImageDissolve(im.Tile("squarestile.png"), 1.0, 256)
+
+
+init -1110:
+    image black = Solid("#000")
+
+init 1110 python:
+    if not hasattr(store, 'narrator'):
+        narrator = Character(None, kind=adv, what_style='say_thought')
+
+    if not hasattr(store, 'name_only'):
+        name_only = adv
+
+    if not hasattr(store, 'centered'):
+        centered = Character(None, what_style="centered_text", window_style="centered_window")
+
+    # This is necessary to ensure that config.default_transform works.
+    if config.default_transform:
+        config.default_transform._show()

common/00gallery.rpy

@@ -0,0 +1,329 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1135 python:
+
+    class __GalleryAllPriorCondition(object):
+
+        def check(self, all_prior):
+            return all_prior
+
+    
+    class __GalleryArbitraryCondition(object):
+        def __init__(self, condition):
+            self.condition = condition
+
+        def check(self, all_prior):
+            return eval(self.condition)
+
+                    
+    class __GalleryUnlockCondition(object):
+        def __init__(self, images):
+            self.images = images
+            
+        def check(self, all_prior):
+            for i in self.images:
+                if not renpy.seen_image(i):
+                    return False
+
+            return True
+            
+            
+    class __GalleryImage(object):
+        def __init__(self, gallery, displayables):
+            
+            # The gallery object we belong to.
+            self.gallery = gallery
+            
+            # A list of conditions for this image to be displayed.
+            self.conditions = [ ]
+            
+            # A list of displayables to show.
+            self.displayables = displayables
+            
+            # A list of transforms to apply to those displayables, or None
+            # to not apply a transform.
+            self.transforms = [ None ] * len(displayables)
+
+
+        def check_unlock(self, all_prior):
+            """
+            Returns True if the image is unlocked.
+            """
+        
+            for i in self.conditions:
+                if not i.check(all_prior):
+                    return False
+
+            return True
+        
+        def show(self, locked, index, count):
+            """
+            Shows this image when it's unlocked.
+            """
+
+            renpy.transition(self.gallery.transition)
+            ui.saybehavior()
+
+            displayables = [ ]
+
+            for d, transform in zip(self.displayables, self.transforms):
+
+                if transform is not None:
+                    d = transform(d)
+                else:
+                    d = config.default_transform(d)
+
+                displayables.append(d)
+                
+            renpy.show_screen("_gallery", locked=locked, index=index + 1, count=count, displayables=displayables, gallery=self.gallery)
+            ui.interact()
+
+    class __GalleryButton(object):
+        def __init__(self, gallery):
+            self.gallery = gallery
+            self.images = [ ]
+            self.conditions = [ ]            
+            
+        def check_unlock(self):
+            for i in self.conditions:
+                if not i.check(True):
+                    return False
+            
+            for i in self.images:
+                if i.check_unlock(False):
+                    return True
+
+            return False
+
+        def show(self):
+
+            all_prior = True
+
+            for i, img in enumerate(self.images):
+                locked = not img.check_unlock(all_prior)
+                img.show(locked, i, len(self.images))
+
+            renpy.transition(self.gallery.transition)
+            
+    class Gallery(object):
+        """
+        :doc: gallery class
+        
+        This class supports the creation of an image gallery by handling the 
+        locking of images, providing an action that can show one or more images, 
+        and a providing method that creates buttons that use that action. 
+
+        .. attribute:: transition
+
+            The transition that is used when changing images.
+
+        .. attribute:: locked_button
+        
+            The default displayable used by make_button for a locked button.
+            
+        .. attribute:: hover_border
+
+            The default hover border used by make_button.
+            
+        .. attribute:: idle_border
+        
+            The default idle border used by make_button.
+        """
+
+        transition = None
+        
+        hover_border = None
+        idle_border = None
+
+        locked_button = None
+
+        def __init__(self):
+    
+            # A map from button name (or image) to __GalleryButton object.
+            self.buttons = { }
+
+            self.button_ = None
+            self.image_ = None
+            self.unlockable = None
+            
+        def button(self, name):
+            """
+            :doc: gallery method
+            
+            Creates a new button, named `name`. 
+            
+            `name`
+                The name of the button being created.
+            """
+                
+            self.button_ = __GalleryButton(self)
+            self.unlockable = self.button_
+            self.buttons[name] = self.button_
+            
+        def image(self, *displayables):
+            """
+            :doc: gallery method
+            
+            Adds a new image to the current button, where an image consists 
+            of one or more displayables.
+            """
+        
+            self.image_ = __GalleryImage(self, displayables)
+            self.button_.images.append(self.image_)
+            self.unlockable = self.image_
+
+        display = image
+
+        def transform(self, *transforms):
+            """
+            :doc: gallery method
+            
+            Applies transforms to the last image registered. This should be
+            called with the same number of transforms as the image has 
+            displayables. The transforms are applied to the corresponding 
+            displayables. 
+            
+            If a transform is None, the default transform is used.
+            """
+
+            self.image_.transforms = transforms
+
+        def unlock(self, *images):
+            """
+            :doc: gallery method
+            
+            A condition that takes one or more image names as argument, and 
+            is satisfied when all the named images have been seen by the 
+            player. The image names should be given as strings.            
+            """            
+
+            self.unlockable.conditions.append(__GalleryUnlockCondition(images))
+
+        def condition(self, expression):
+            """
+            :doc: gallery method
+            
+            A condition that is satisfied when an expression evaluates to true.
+            
+            `expression`
+                A string giving a python expression.
+            """
+
+            if not isinstance(expression, basestring):
+                raise Exception("Gallery condition must be a string containing an expression.")
+
+            self.unlockable.conditions.append(__GalleryArbitraryCondition(expression))
+
+        def allprior(self):
+            """
+            :doc: gallery method
+            
+            A condition that is true if all prior images associated with the 
+            current button have been unlocked.
+            """
+
+            self.unlockable.conditions.append(__GalleryAllPriorCondition())
+    
+        def unlock_image(self, *images):
+            """
+            :doc: gallery method
+                
+            A convenience method that is equivalent to calling image and unlock
+            with the same parameters. This will cause an image to be displayed 
+            if it has been seen before.
+            
+            The images should be specified as strings giving image names.            
+            """
+
+            self.image(*images)
+            self.unlock(*images)
+
+        def Action(self, name):
+            """
+            :doc: gallery method
+            
+            An action that displays the images associated with the given button
+            name.
+            """
+        
+            if name not in self.buttons:
+                raise Exception("{0!r} is not a button defined in this gallery.".format(name))
+                
+            b = self.buttons[name]
+                
+            if b.check_unlock():
+                return ui.invokesinnewcontext(b.show)
+            else:
+                return None
+                
+        def make_button(self, name, unlocked, locked=None, hover_border=None, idle_border=None, **properties):
+            """
+            :doc: gallery method
+            
+            This creates a button that displays the images associated with the given 
+            button name. 
+            
+            `name`
+                The name of the button that will be created.
+                
+            `unlocked`
+                A displayable that is displayed for this button when it is 
+                unlocked.
+                
+            `locked`
+                A displayable that is displayed for this button when it is 
+                locked. If None, the locked_button field of the gallery 
+                object is used instead.
+                
+            `hover_border`
+                A displayable that is used to overlay this button when when 
+                it is unlocked and has focus. If None, the hover_border
+                field of the gallery object is used. 
+ 
+            `idle_border`
+                A displayable that is used to overlay this button when when 
+                it is unlocked but unfocused. If None, the idle_border
+                field of the gallery object is used. 
+            
+            Additional keyword arguments become style properties of the 
+            created button object.
+            """
+            
+            action = self.Action(name)
+            
+            if locked is None:
+                locked = self.locked_button
+                
+            if hover_border is None:
+                hover_border = self.hover_border
+                
+            if idle_border is None:
+                idle_border = self.idle_border
+                
+            return Button(action=action, child=unlocked, insensitive_child=locked, hover_foreground=hover_border, idle_foreground=idle_border, **properties)
+
+
+init -1135:
+
+    # Displays a set of images in the gallery, or indicates that the images 
+    # are locked. This is given the following arguments:
+    #
+    # locked
+    #     True if the image is locked.
+    # displayables
+    #     A list of transformed displayables that should be shown to the user.
+    # index
+    #     A 1-based index of the image being shown.
+    # count
+    #     The number of images attached to the current button.
+    # gallery
+    #     The image gallery object.
+    screen _gallery:
+        if locked:
+            add "#000"            
+            text "Image [index] of [count] locked." align (0.5, 0.5)          
+        else:
+            for d in displayables:
+                add d
+                        

common/00gltest.rpy

@@ -0,0 +1,377 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This contains code to choose between OpenGL and Software rendering, when
+# a system supports both.
+
+init -1024:
+
+    python hide:
+        import os
+        store.__dxwebsetup = os.path.join(config.renpy_base, "lib", "dxwebsetup.exe")
+
+    python:
+        class _SetRenderer(Action):
+            """
+            Sets the preferred renderer to one of "auto", "angle", "gl", or 
+            "sw". 
+            """
+            
+            def __init__(self, renderer):
+                self.renderer = renderer
+                
+            def __call__(self):
+                _preferences.renderer = self.renderer
+                renpy.restart_interaction()
+                
+            def get_selected(self):
+                return _preferences.renderer == self.renderer
+
+    # This is displayed to ask the user to choose the renderer he or she
+    # wants to use. It takes no parameters, doesn't return anything, and 
+    # is expected to call _SetRenderer actions and quit when done.
+    #
+    # This screen can be customized by the creator, provided the actions 
+    # remain available.    
+    screen _choose_renderer:
+
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+            xpadding 20
+            ypadding 20
+    
+            xmaximum 400
+
+            has vbox
+
+            label _("Graphics Acceleration")
+
+            null height 10
+            
+            textbutton _("Automatically Choose"):
+                action _SetRenderer("auto")
+                xfill True
+                
+            if renpy.renpy.windows:
+                textbutton _("Force Angle/DirectX Renderer"):
+                    action _SetRenderer("angle")
+                    xfill True
+                
+            textbutton _("Force OpenGL Renderer"):
+                action _SetRenderer("gl")
+                xfill True
+
+            textbutton _("Force Software Renderer"):
+                action _SetRenderer("sw")
+                xfill True
+
+            null height 10
+
+            text _("Changes will take effect the next time this program is run.") substitute True
+ 
+            null height 10
+
+            textbutton _(u"Quit"):
+                action Quit(confirm=False)
+                xfill True
+
+            if not renpy.display.interface.safe_mode:
+                textbutton _("Return"): 
+                    action Return(0)
+                    xfill True
+
+
+    # This is displayed when a display performance problem occurs. 
+    # 
+    # `problem` is the kind of problem that is occuring. It can be:
+    # - "sw" if the software renderer was selected.
+    # - "slow" if the performance test failed.
+    # - "fixed" if we're operating w/o shaders.
+    # - other things, added in the future.
+    #
+    # `url` is the url of a web page on renpy.org that will include
+    # info on troubleshooting display problems.
+    screen _performance_warning:
+    
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            xmaximum 400
+
+            has vbox
+
+            label _("Performance Warning")
+            
+            null height 10
+            
+            if problem == "sw":
+                text _("This computer is using software rendering.")
+            elif problem == "fixed":
+                text _("This computer is not using shaders.")
+            elif problem == "slow":
+                text _("This computer is displaying graphics slowly.")
+            else:
+                text _("This computer has a problem displaying graphics: [problem].") substitute True     
+                
+            null height 10
+
+            if directx_update:
+                text _("Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem.")
+            else:            
+                text _("Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display.")
+
+            if directx_update:
+                null height 10
+                
+                textbutton _("Update DirectX"):
+                    action directx_update
+                    xfill True
+            
+            null height 10
+            
+            textbutton _("Continue, Show this warning again"): 
+                action Return(True)
+                xfill True
+                
+            textbutton _("Continue, Don't show warning again"):
+                action Return(False)
+                xfill True
+            
+            null height 10
+        
+            textbutton _("Quit"): 
+                action Quit(confirm=False)
+                xfill True
+
+    # Used while a directx update is ongoing.
+    screen _directx_update:
+        
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            xmaximum 400
+
+            has vbox
+                    
+            label _("Updating DirectX.")
+
+            null height 10
+
+            text _("DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX.")
+            
+            null height 10
+        
+            text _("{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box.")
+
+            null height 10      
+                    
+            text _("When setup finishes, please click below to restart this program.")
+
+            textbutton _("Restart") action Return(True)
+
+
+
+init -1024 python:
+    # The image that we fill the screen with in GL-test mode.
+    config.gl_test_image = "black"
+
+    class __GLTest(renpy.Displayable):
+        """
+         This counts the number of times it's been rendered, and
+         the number of seconds it's been displayed, and uses them
+         to make the decisions as to if OpenGL is working or not.
+         """
+        
+        def __init__(self, frames, fps, timeout):
+            super(__GLTest, self).__init__()
+
+            self.target = 1.0 * frames / fps
+            self.frames = frames
+            self.timeout = timeout
+
+            self.times = [ ]
+            self.success = False
+            
+            renpy.renpy.display.log.write("- Target is {0} frames in {1} seconds.".format(frames, self.target))
+            
+        def render(self, width, height, st, at):
+            rv = renpy.Render(width, height)
+
+            if self.success:
+                return rv
+
+            self.times.append(st)
+
+            renpy.redraw(self, 0)
+
+            renpy.renpy.display.log.write("- Frame drawn at %f seconds." % st)
+            
+            if len(self.times) >= self.frames:
+                frames_timing = self.times[-1] - self.times[-self.frames]
+
+                renpy.renpy.display.log.write("- %f seconds to render %d frames.", frames_timing, self.frames)
+
+                if frames_timing <= self.target:
+                    self.success = True
+                    renpy.timeout(0)
+
+            return rv                    
+                            
+        def event(self, ev, x, y, st):
+
+            if self.success:
+                return True
+
+            if st > self.timeout:
+                return False
+
+            renpy.timeout(self.timeout - st)
+   
+    config.performance_test = True
+        
+    def __gl_test():
+
+        import os
+
+        # If we've entered safe mode, display the renderer choice screen.
+        # This screen will cause us to quit.
+
+        if _restart:
+            return
+
+        if not config.gl_enable:
+            return
+    
+        if renpy.display.interface.safe_mode:
+            renpy.call_in_new_context("_choose_renderer")
+
+        if not config.performance_test:
+            return
+
+        _gl_performance_test()
+
+    def _gl_performance_test():
+    
+        import os
+
+        if not _preferences.performance_test and "RENPY_PERFORMANCE_TEST" not in os.environ:
+            return
+
+        # Don't bother on androuid - there's nothing the user can do.
+        if renpy.renpy.android:
+            return
+
+        renpy.renpy.display.log.write("Performance test:")
+            
+        # This will cause the screen to start displaying.
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+        # The problem we have.
+        problem = None
+
+        renderer_info = renpy.get_renderer_info()
+
+        # Software renderer check.
+        if config.renderer != "sw" and renderer_info["renderer"] == "sw":
+            problem = "sw"
+        
+        # Speed check.
+        if problem is None:
+            
+            # The parameters of the performance test. If we do not hit FPS fps
+            # over FRAMES frames before DELAY seconds are up, we fail. 
+            FRAMES = 5
+            FPS = 15
+            DELAY = 1.5
+            
+            renpy.transition(Dissolve(DELAY), always=True, force=True)
+            ui.add(__GLTest(FRAMES, FPS, DELAY))
+            result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+    
+            if not result:
+                problem = "slow"
+
+        # Lack of shaders check.
+        if problem is None:
+            if not "RENPY_GL_ENVIRON" in os.environ:    
+                if renderer_info["renderer"] == "gl" and renderer_info["environ"] == "fixed":
+                    problem = "fixed"
+         
+        if problem is None:
+            return
+
+        if renpy.renpy.windows and os.path.exists(__dxwebsetup):
+            directx_update = Jump("_directx_update")
+        else:
+            directx_update = None
+    
+        # Give the warning message to the user.            
+        renpy.show_screen("_performance_warning", problem=problem, directx_update=directx_update, _transient=True)
+        result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+        
+
+        # Store the user's choice, and continue.        
+        _preferences.performance_test = result
+        return
+        
+            
+label _gl_test:
+
+    # Show the test image.
+    scene
+    show expression config.gl_test_image
+    
+    $ __gl_test()
+                
+    # Hide the test image.
+    scene
+
+    return
+
+# We can assume we're on windows here. We're also always restart once we 
+# make it here.
+label _directx_update:
+
+    if renpy.has_label("directx_update"):
+        jump expression "directx_update"
+
+label _directx_update_main:
+
+    python hide:
+        import subprocess
+        import sys
+        
+        # Start dxsetup. We have to go through startfile to ensure that UAC
+        # doesn't cause problems.
+        os.startfile(__dxwebsetup)
+
+        renpy.show_screen("_directx_update")
+        ui.interact(suppress_overlay=True, suppress_underlay=True)
+        
+        # Restart the current program.
+        subprocess.Popen(sys.argv)
+        renpy.quit()
+    
+label _choose_renderer:    
+    scene expression "#000"
+
+    $ renpy.call_screen("_choose_renderer")    
+    return
+    
+

common/00layout.rpy

@@ -0,0 +1,434 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1105 python:
+
+    class Layout():
+        def __call__(self, func):
+            setattr(self, func.func_name, func)
+            return func
+
+    layout = _layout =  Layout()
+    del Layout
+
+    layout.compat_funcs = [ ]
+    layout.provided = set()
+    
+init -1105 python hide:
+
+    # Called to indicate that the given kind of layout has been
+    # provided.
+    @layout
+    def provides(kind):
+
+        if kind in layout.provided:
+            raise Exception("%s has already been provided by another layout function." % kind)
+        
+        layout.provided.add(kind)
+
+    # Called by registered themes to have the default versions of
+    # various kinds of layouts provided, if a more specific version
+    # has not been requested by the user.
+    @layout
+    def defaults():
+
+        # Do nothing, in compatibility mode.
+        if 'compat' in layout.provided:
+            return
+        
+        defaults = dict(
+            main_menu=layout.classic_main_menu,
+            load_save=layout.classic_load_save,
+            navigation=layout.classic_navigation,
+            yesno_prompt=layout.classic_yesno_prompt,
+            preferences=layout.classic_preferences,
+            joystick_preferences=layout.classic_joystick_preferences,
+            )
+
+        if renpy.has_screen("main_menu"):
+            defaults["main_menu"] = layout.screen_main_menu
+
+        if renpy.has_screen("load") and renpy.has_screen("save"):
+            defaults["load_save"] = layout.screen_load_save
+
+        if renpy.has_screen("yesno_prompt"):
+            defaults["yesno_prompt"] = layout.screen_yesno_prompt
+
+        if renpy.has_screen("preferences"):
+            defaults["preferences"] = layout.screen_preferences
+
+        if renpy.has_screen("joystick_preferences"):
+            defaults["joystick_preferences"] = layout.screen_joystick_preferences
+        
+        for k, v in defaults.iteritems():
+            if k not in layout.provided:
+                v()
+
+        if store._game_menu_screen is None:
+            if renpy.has_label("save_screen"):
+                store._game_menu_screen = "save_screen"
+            elif renpy.has_label("preferences_screen"):
+                store._game_menu_screen = "preferences_screen"
+            
+                
+    ##########################################################################
+    # These live on the layout object, and ease the construction of buttons,
+    # labels, and prompts. A sufficently aggressive layout might change
+    # these.
+
+    @layout
+    def button(label,
+               type=None,
+               selected=False,
+               enabled=True,
+               clicked=None,
+               hovered=None,
+               unhovered=None,
+               index=None,
+               **properties):
+        
+        """
+         label - The label of this button. Will be translated if necessary.
+         type - The type of this button. Used to generate the appropriate styles.
+         selected - Determines if this button should be selected.
+         enabled - Determines if this button should be enabled.
+         clicked - A function that is run when the button is clicked.
+         hovered - A function that is run when the button is hovered.
+         unhovered - A function that is run when the button is unhovered.
+         index - A style index. If None, label is used.
+         size_group - The size_group used by this button.
+         """
+
+        if not enabled:
+            clicked = None
+
+        if selected and enabled:
+            role = "selected_"
+        else:
+            role = ""
+
+        if type:
+            button_style = type + "_button"
+            text_style = type + "_button_text"
+        else:
+            button_style = 'button'
+            text_style = 'button_text'
+            
+        if index is None:
+            index = label
+        
+        button_style = getattr(style, button_style)[index]
+        text_style = getattr(style, text_style)[index]
+
+        rv = ui.button(style=button_style, role=role, clicked=clicked, hovered=hovered, unhovered=unhovered, **properties)
+        ui.text(_(label), style=text_style)
+
+        return rv
+
+    @layout
+    def label(label, type, suffix="label", index=None, **properties):
+
+        if index is None:
+            index = label
+
+        if type:
+            label_style = getattr(style, type + "_" + suffix)[index]
+            text_style = getattr(style, type + "_" + suffix + "_text")[index]
+        else:
+            label_style = style.label[index]
+            text_style = style.label_text[index]
+            
+        ui.window(style=label_style, **properties)
+        ui.text(_(label), style=text_style)
+
+    @layout
+    def prompt(label, type, index=None, **properties):
+        return layout.label(label, type, "prompt", index, **properties)
+
+    @layout
+    def list(entries, clicked=None, hovered=None, unhovered=None, selected=None, **properties):
+
+        ui.window(style=style.list, **properties)
+        ui.vbox(style=style.list_box)
+
+        size_group = str(id(entries))
+        
+        for i, (spacers, content) in enumerate(entries):
+            if clicked is not None:
+                new_clicked = renpy.curry(clicked)(i)
+            else:
+                new_clicked = None
+
+            if hovered is not None:
+                new_hovered = renpy.curry(hovered)(i)
+            else:
+                new_hovered = None
+                
+            if unhovered is not None:
+                new_unhovered = renpy.curry(unhovered)(i)
+            else:
+                new_unhovered = None
+
+            if selected == i:
+                role = "selected_"
+            else:
+                role = ""
+
+            ui.button(style=style.list_row[i%2],
+                      clicked=new_clicked,
+                      hovered=new_hovered, 
+                      unhovered=new_unhovered,
+                      role=role,
+                      size_group=size_group,
+                      )
+
+            ui.hbox(style=style.list_row_box)
+            
+            for j in range(0, spacers):
+                ui.window(style=style.list_spacer)
+                ui.null()
+
+            ui.text(content, style=style.list_text)
+
+            ui.close() # row
+            
+        ui.close() # vbox
+    
+    ##########################################################################
+    # Misc.
+                
+    @layout
+    def button_menu():
+
+        config.narrator_menu = True
+
+        style.menu.box_spacing = 2
+        style.menu_window.set_parent(style.default)
+        style.menu_window.xalign = 0.5
+        style.menu_window.yalign = 0.5
+        style.menu_choice.set_parent(style.button_text)
+        style.menu_choice.clear()
+        style.menu_choice_button.set_parent(style.button)
+        style.menu_choice_button.xminimum = int(config.screen_width * 0.75)
+        style.menu_choice_button.xmaximum = int(config.screen_width * 0.75)
+        
+    store._button_menu = button_menu
+
+    ###########################################################################
+    # Compat layout.
+                
+    @layout
+    def compat():
+        layout.provides('compat')
+        renpy.load_module("_compat/styles")
+        renpy.load_module("_compat/library")
+        renpy.load_module("_compat/mainmenu")
+        renpy.load_module("_compat/gamemenu")
+        renpy.load_module("_compat/preferences")
+        renpy.load_module("_compat/themes")
+
+    ###########################################################################
+    # Classic layout.
+
+    @layout
+    def classic_main_menu():
+        renpy.load_module("_layout/classic_main_menu")
+
+    @layout
+    def classic_navigation():
+        renpy.load_module('_layout/classic_navigation')
+
+    @layout
+    def classic_load_save():
+        renpy.load_module('_layout/classic_load_save')
+
+    @layout
+    def classic_yesno_prompt():
+        renpy.load_module('_layout/classic_yesno_prompt')
+
+    @layout
+    def classic_preferences(center=False):
+        renpy.load_module('_layout/classic_preferences')
+
+        if center:
+            style.prefs_button.xalign = 0.5
+            style.prefs_slider.xalign = 0.5
+            style.prefs_jump_button.xalign = 0.5
+
+    @layout
+    def classic_joystick_preferences():
+        renpy.load_module('_layout/classic_joystick_preferences')
+
+    @layout
+    def two_column_preferences():
+        renpy.load_module("_layout/two_column_preferences")
+        
+    @layout
+    def one_column_preferences():
+        renpy.load_module("_layout/one_column_preferences")
+
+    @layout
+    def grouped_main_menu(per_group=2, equal_size=True):
+        renpy.load_module("_layout/grouped_main_menu")
+        config.main_menu_per_group = per_group
+
+        if equal_size:
+            style.mm_button.size_group = "main_menu"
+
+            
+    @layout
+    def grouped_navigation(per_group=2, equal_size=True):
+        renpy.load_module("_layout/grouped_navigation")
+        config.navigation_per_group = per_group
+
+        if equal_size:
+            style.gm_nav_button.size_group = "navigation"
+
+    @layout
+    def scrolling_load_save():
+        renpy.load_module("_layout/scrolling_load_save")
+
+
+    @layout
+    def imagemap_main_menu(ground, selected, hotspots, idle=None, variant=None):
+        renpy.load_module("_layout/imagemap_main_menu")
+
+        config.main_menu_ground[variant] = ground
+        config.main_menu_selected[variant] = selected
+        config.main_menu_hotspots[variant] = hotspots
+        config.main_menu_idle[variant] = idle
+        
+    @layout
+    def imagemap_navigation(ground, idle, hover, selected_idle, selected_hover,
+                            hotspots):
+
+        renpy.load_module("_layout/imagemap_navigation")
+        
+        config.navigation_ground = ground
+        config.navigation_idle = idle
+        config.navigation_hover = hover
+        config.navigation_selected_idle = selected_idle
+        config.navigation_selected_hover = selected_hover
+        config.navigation_hotspots = hotspots
+
+    @layout
+    def imagemap_preferences(ground, idle, hover, selected_idle, selected_hover,
+                            hotspots):
+
+        renpy.load_module("_layout/imagemap_preferences")
+        
+        config.preferences_ground = ground
+        config.preferences_idle = idle
+        config.preferences_hover = hover
+        config.preferences_selected_idle = selected_idle
+        config.preferences_selected_hover = selected_hover
+        config.preferences_hotspots = hotspots
+
+    @layout
+    def imagemap_yesno_prompt(ground, idle, hover, hotspots, prompt_images={ }):
+
+        renpy.load_module("_layout/imagemap_yesno_prompt")
+        
+        config.yesno_prompt_ground = ground
+        config.yesno_prompt_idle = idle
+        config.yesno_prompt_hover = hover
+        config.yesno_prompt_hotspots = hotspots
+        config.yesno_prompt_message_images = prompt_images
+        
+    @layout
+    def imagemap_load_save(ground, idle, hover, selected_idle, selected_hover,
+                           hotspots, variant=None):
+
+        renpy.load_module("_layout/imagemap_load_save")
+        
+        config.load_save_ground[variant] = ground
+        config.load_save_idle[variant] = idle
+        config.load_save_hover[variant] = hover
+        config.load_save_selected_idle[variant] = selected_idle
+        config.load_save_selected_hover[variant] = selected_hover
+        config.load_save_hotspots[variant] = hotspots
+
+    @layout
+    def screen_main_menu():
+        renpy.load_module("_layout/screen_main_menu")
+        
+    @layout
+    def screen_load_save():
+        renpy.load_module("_layout/screen_load_save")
+        
+    @layout
+    def screen_preferences():
+        renpy.load_module("_layout/screen_preferences")
+        
+    @layout
+    def screen_joystick_preferences():
+        renpy.load_module("_layout/screen_joystick_preferences")
+        
+    @layout
+    def screen_yesno_prompt():
+        renpy.load_module("_layout/screen_yesno_prompt")
+    
+    layout.ARE_YOU_SURE = u"Are you sure?"
+    layout.DELETE_SAVE = u"Are you sure you want to delete this save?"
+    layout.OVERWRITE_SAVE = u"Are you sure you want to overwrite your save?"
+    layout.LOADING = u"Loading will lose unsaved progress.\nAre you sure you want to do this?"
+    layout.QUIT = u"Are you sure you want to quit?"
+    layout.MAIN_MENU = u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
+
+    @layout
+    def invoke_yesno_prompt(*args):
+        _enter_menu()
+        return layout.yesno_prompt(*args)
+
+    @layout
+    def yesno_screen(message, yes=None, no=None):
+        """
+         :doc: other
+
+         This causes the a yes/no prompt screen with the given message
+         to be displayed. The screen will be hidden when the user hits
+         yes or no.
+
+         `message`
+             The message that will be displayed.
+
+         `yes`
+             An action that is run when the user chooses yes.
+
+         `no`
+             An action that is run when the user chooses no.
+         """
+
+        if renpy.has_screen("yesno_prompt"):
+
+            yes_action = [ Hide("yesno_prompt") ]
+            no_action = [ Hide("yesno_prompt") ]
+
+            if yes is not None:
+                yes_action.append(yes)
+            if no is not None:
+                no_action.append(no)
+            
+            renpy.show_screen(
+                "yesno_prompt", 
+                message=message,
+                yes_action=yes_action,
+                no_action=no_action)
+
+            renpy.restart_interaction()
+            
+            return
+            
+        if renpy.invoke_in_new_context(layout.invoke_yesno_prompt, None, message):
+            if yes is not None:
+                yes()
+        else:
+            if no is not None:
+                no()
+    
+    
+    def __auto_save_extra_info():
+        return save_name
+    
+    config.auto_save_extra_info = __auto_save_extra_info
+                

common/00library.rpy

@@ -0,0 +1,914 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file consists of renpy functions that aren't expected to be
+# touched by the user too much. We reserve the _ prefix for names
+# defined in the library.
+
+init -1180 python:
+
+    # These are settings that the user can tweak to control the
+    # look of the main menu and the load/save/escape screens.
+
+    # basics: The version of Ren'Py this script is intended for, or
+    # None if it's intended for the current version.
+    config.script_version = None
+    
+    # The minimum version of the module we work with. Don't change
+    # this unless you know what you're doing.
+    config.module_version = 6007001
+
+    # Should we warn the user if the module is missing or has a bad
+    # version?
+    config.module_warning = False
+
+    # basics: A map from a string that's displayed by the interface to
+    # a translated value of that string.
+    config.translations = { }
+
+    # Used internally to maintain compatiblity with old
+    # translations of strings.
+    config.old_names = { }
+
+    # basics: True if the skip indicator should be shown.
+    config.skip_indicator = True
+
+    # basics: The width of a thumbnail.
+    config.thumbnail_width = 66
+
+    # basics: The height of a thumbnail.
+    config.thumbnail_height = 50
+
+    # basics: If not None, the default value of the fullscreen
+    # preference when the game is first run.
+    config.default_fullscreen = None
+
+    # basics: If not None, the default value of the text_cps
+    # preference when the game is first run.
+    config.default_text_cps = None        
+
+    # If not None, the default value of afm_time
+    config.default_afm_time = None
+
+    # If not None, the default value of afm_enable
+    config.default_afm_enable = None
+    
+    # Should we automatically define images?
+    config.automatic_images = None
+
+    # Prefixes to strip from automatic images.
+    config.automatic_images_strip = [ ]
+    
+    # A save to automatically load, if it exists.
+    config.auto_load = None
+
+    # Layers to clear when entering the menus.
+    config.menu_clear_layers = [ ]
+
+    # Should we start the game with scene black or just scene?
+    config.start_scene_black = False
+
+    # Voice and Sound samples.
+    config.sample_sound = None
+    config.sample_voice = None
+    
+    # This is updated to give the user an idea of where a save is
+    # taking place.
+    save_name = ''
+
+    # Should the window be shown during transitions?
+    _window_during_transitions = False
+
+    def _default_with_callback(trans, paired=None):
+        if (_window_during_transitions and not
+            renpy.context_nesting_level() and
+            not renpy.count_displayables_in_layer('transient')):
+
+            # narrator("", interact=False)
+            ui.window(style=style.say_window["empty"])
+            ui.null()
+            
+        return trans
+
+    config.with_callback = _default_with_callback
+
+
+    def _default_empty_window():
+        
+        who = _last_say_who
+
+        if who is not None:
+            who = eval(who)
+
+        if who is None:
+            who = narrator
+
+        if isinstance(who, NVLCharacter):
+            nvl_show_core()
+        else:
+            store.narrator("", interact=False)
+                
+    config.empty_window = _default_empty_window
+        
+    style.skip_indicator = Style(style.default, heavy=True, help='The skip indicator.')
+    style.skip_indicator.xpos = 10
+    style.skip_indicator.ypos = 10
+
+    # This is used to jump to a label with a transition.
+    def _intra_jumps_core(label, transition):
+        renpy.transition(getattr(config, transition))
+        renpy.jump(label)
+
+    _intra_jumps = renpy.curry(_intra_jumps_core)
+
+    # The function that's used to translate strings in the game menu.
+    def _(s):
+        """
+        Translates s into another language or something.
+        """
+
+        if s in config.translations:
+            return config.translations[s]
+
+        if s in config.old_names and config.old_names[s] in config.translations:
+            return config.translations[config.old_names[s]]
+
+        return s
+
+    config.extend_interjection = "{fast}"
+
+    def extend(what, interact=True):
+        who = _last_say_who
+
+        if who is not None:
+            who = eval(who)
+
+        if who is None:
+            who = narrator 
+            
+        if isinstance(who, basestring):
+            who = unknown.copy(who)
+
+        # This ensures extend works even with NVL mode.
+        who.do_extend()
+            
+        what = _last_say_what + config.extend_interjection + what
+            
+        renpy.exports.say(who, what, interact=interact)
+        store._last_say_what = what
+        
+    extend.record_say = False
+
+    # Are the windows currently hidden?
+    _windows_hidden = False
+
+    def toggle_skipping():
+
+        if not config.skipping:
+            config.skipping = "slow"
+        else:
+            config.skipping = None
+
+        if renpy.context()._menu:
+            renpy.jump("_noisy_return")
+        else:            
+            renpy.restart_interaction()
+
+    config.help = None
+            
+    def _help(help=None):
+
+        if help is None:
+            help = config.help
+
+        if help is None:
+            return
+
+        if renpy.has_label(help):
+            renpy.call_in_new_context(help)
+            return
+
+        _preferences.fullscreen = False
+
+        try:
+            import webbrowser
+            webbrowser.open_new("file:///" + config.basedir + "/" + help)
+        except:
+            pass
+
+    # Called to make a screenshot happen.
+    def _screenshot():
+        import os.path
+        import os
+        import __main__
+        
+        # Pick the directory to save into.
+        dest = config.renpy_base.rstrip("/")
+        
+        # Guess if we're an OSX App.
+        if dest.endswith("/Contents/Resources/autorun"):
+            # Go up 4 directories.
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            
+        # Try to pick a filename.
+        i = 1
+        while True:
+            fn = os.path.join(dest, config.screenshot_pattern % i)
+            if not os.path.exists(fn):
+                break
+            i += 1
+
+        try:
+            renpy.screenshot(fn)
+        except:
+            import traceback
+            traceback.print_exc()
+
+        if config.screenshot_callback is not None:
+            config.screenshot_callback(fn)
+
+    def _screenshot_callback(fn):
+        renpy.notify(_("Saved screenshot as %s.") % fn)
+
+    config.screenshot_callback = _screenshot_callback
+        
+    _predict_screens = [ ]
+        
+init -1180 python hide:
+    
+    import os
+    config.screenshot_pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
+
+    def dump_styles():
+        if config.developer:
+            renpy.style.write_text("styles.txt")
+
+    # This is run when entering the game menu.
+    config.game_menu_action = None
+            
+    def invoke_game_menu():
+        if renpy.context()._menu:
+            if renpy.context()._main_menu:
+                return
+            else:
+                renpy.jump("_noisy_return")
+        else:
+            if config.game_menu_action:
+                renpy.display.behavior.run(config.game_menu_action)
+            else:            
+                renpy.call_in_new_context('_game_menu')
+
+    def keymap_toggle_skipping():
+        if renpy.context()._menu:
+            return
+
+        toggle_skipping()
+            
+    def fast_skip():
+        if config.fast_skipping or config.developer:
+            config.skipping = "fast"
+
+        if renpy.context()._menu:
+            renpy.jump("_noisy_return")
+
+    def reload_game():
+        if not config.developer:
+            return
+
+        renpy.call_in_new_context("_save_reload_game")
+
+    def launch_editor():
+        if not config.developer:
+            return
+
+        filename, line = renpy.get_filename_line()
+        renpy.launch_editor([ filename ], line)
+        
+    # The default keymap. We might also want to put some of this into
+    # the launcher.
+    km = renpy.Keymap(
+        rollback = renpy.rollback,
+        screenshot = _screenshot,
+        toggle_fullscreen = renpy.toggle_fullscreen,
+        toggle_music = renpy.toggle_music,
+        toggle_skip = keymap_toggle_skipping,
+        fast_skip = fast_skip,
+        game_menu = invoke_game_menu,
+        hide_windows = renpy.curried_call_in_new_context("_hide_windows"),
+        launch_editor = launch_editor,
+        dump_styles = dump_styles,
+        reload_game = reload_game,
+        developer = renpy.curried_call_in_new_context("_developer"),
+        quit = renpy.quit_event,
+        iconify = renpy.iconify,
+        help = _help,
+        choose_renderer = renpy.curried_call_in_new_context("_choose_renderer"),
+        )
+
+    config.underlay = [ km ]
+
+    def skip_indicator():
+
+        ### skip_indicator default
+        # (text) The style and placement of the skip indicator.            
+
+        if config.skip_indicator is True:
+
+            if config.skipping == "slow" and config.skip_indicator:
+                ui.text(_(u"Skip Mode"), style='skip_indicator')
+
+            if config.skipping == "fast" and config.skip_indicator:
+                ui.text(_(u"Fast Skip Mode"), style='skip_indicator')
+
+            return
+
+        if not config.skip_indicator:
+            return
+
+        if not config.skipping:
+            return
+
+        ui.add(renpy.easy.displayable(config.skip_indicator))
+
+    config.overlay_functions.append(skip_indicator)
+
+    # Hyperlink functions. Duplicated in _errorhandling.rpym.
+    def hyperlink_styler(target):
+        return style.hyperlink_text
+
+    def hyperlink_function(target):
+        if target.startswith("http:"):
+            try:
+                import webbrowser
+                webbrowser.open(target)
+            except:
+                pass
+        else:
+            renpy.call_in_new_context(target)
+
+    style.default.hyperlink_functions = (hyperlink_styler, hyperlink_function, None)
+
+    # Prediction of screens.    
+    def predict():
+
+        for s in _predict_screens:
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+
+        s = _game_menu_screen
+
+        if s is None:
+            return
+
+        if renpy.has_screen(s):
+            renpy.predict_screen(s)
+            return
+
+        if s.endswith("_screen"):
+            s = s[:-7]
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+                return
+
+            
+    config.predict_callbacks.append(predict)
+            
+    def imagemap_auto_function(auto_param, variant):
+        rv = auto_param % variant
+
+        if renpy.loadable(rv):
+            return rv
+        else:
+            return None
+        
+        
+    config.imagemap_auto_function = imagemap_auto_function
+
+
+label _hide_windows:
+
+    if renpy.context()._menu:
+        return
+    
+    if _windows_hidden:
+        return
+
+    python:
+        _windows_hidden = True
+        ui.saybehavior(dismiss=['dismiss', 'hide_windows'])
+        ui.interact(suppress_overlay=True, suppress_window=True)
+        _windows_hidden = False
+
+    return
+
+    
+# This code here handles check for the correct version of the Ren'Py module.
+                         
+label _save_reload_game:
+    python hide:
+        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
+        renpy.music.stop()
+        
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Saving game...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        renpy.pause(0)
+
+        renpy.save("_reload-1", "reload save game")
+        
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Reloading script...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        renpy.pause(0)
+        
+        renpy.utter_restart()
+
+label _load_reload_game:
+    
+    if not renpy.can_load("_reload-1"):
+        return 
+
+    python hide:
+        renpy.rename_save("_reload-1", "_reload-2")
+
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Reloading game...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+        
+        renpy.load("_reload-2")
+
+    return
+
+init -1001:
+    image text = renpy.ParameterizedText(style="centered_text")
+
+    # Lock the library object.
+    $ config.locked = True
+
+
+# Implement config.default_fullscreen and config.default_text_cps.
+init 1180 python:
+
+    if not persistent._set_preferences:
+        persistent._set_preferences = True
+        
+        if config.default_fullscreen is not None:
+            _preferences.fullscreen = config.default_fullscreen
+
+        if config.default_text_cps is not None:
+            _preferences.text_cps = config.default_text_cps
+
+        if config.default_afm_time is not None:
+            _preferences.afm_time = config.default_afm_time
+            
+    if config.default_afm_enable is not None:
+        _preferences.afm_enable = config.default_afm_enable
+        _preferences.using_afm_enable = True
+    else:
+        _preferences.afm_enable = True
+        _preferences.using_afm_enable = False
+    
+
+        
+##############################################################################
+# Code that originated in 00gamemenu.rpy
+init -1180 python:
+
+    ######################################################################
+    # First up, we define a bunch of configuration variable, which the
+    # user can change.
+
+    # menus: Music to play when entering the game menu.
+    config.game_menu_music = None
+
+    # menus: Sound played when entering the library without clicking a
+    # button.
+    config.enter_sound = None
+
+    # menus: Sound played when leaving the library without clicking a
+    # button.
+    config.exit_sound = None
+
+    # menus: Transition that occurs when entering the game menu.
+    config.enter_transition = None
+
+    # menus: Transition that occurs when leaving the game menu.
+    config.exit_transition = None
+
+    # menus: Transition that's used when going from one screen to another.
+    config.intra_transition = None
+
+    # menus: Transition that's used when going from the main to the game
+    # menu.
+    config.main_game_transition = None
+
+    # menus: Transition that's used when going from the game to the main
+    # menu.
+    config.game_main_transition = None
+
+    # menus: Transition that's used at the end of the game, when returning
+    # to the main menu.
+    config.end_game_transition = None
+
+    # menus: Transition that's used at the end of the splash screen, when
+    # it is shown.
+    config.end_splash_transition = None
+
+    # Transition that's used after the game is loaded.
+    config.after_load_transition = None
+    
+    # basics: True if autosave should be used.
+    config.has_autosave = True
+
+    # basics: True if quicksave has been enabled.
+    config.has_quicksave = False
+
+    # A list of layers to clear when entering the main and game menus.
+    config.clear_layers = [ ]
+
+    # The _window_subtitle used inside menus.
+    config.menu_window_subtitle = ''
+    
+    # The screen that we go to when entering the game menu.
+    _game_menu_screen = None
+    
+    style.error_root = Style(style.default)
+    style.error_title = Style(style.default)
+    style.error_body = Style(style.default)
+
+    def _show_exception(title, message):
+
+        ui.window(style='error_root')
+        ui.vbox()
+
+        ui.text(title, style='error_title')
+        ui.text("")
+        ui.text(message, style='error_body')
+        ui.text("")
+        ui.text(_(u"Please click to continue."), style='error_body')
+
+        ui.close()
+
+        ui.saybehavior()
+
+        ui.interact()
+
+    def _enter_menu():
+        config.skipping = None
+        
+        renpy.movie_stop(only_fullscreen=True)
+        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
+
+        for i in config.menu_clear_layers:
+            renpy.scene(layer=i)
+        
+        renpy.context()._menu = True        
+        renpy.context()._main_menu = False
+        renpy.context_dynamic("main_menu")
+        renpy.context_dynamic("_window_subtitle")
+        renpy.context_dynamic("_window")
+        
+        store.main_menu = False
+        store._window_subtitle = config.menu_window_subtitle
+        store._window = False
+        
+        store.mouse_visible = True
+        store.suppress_overlay = True
+        ui.clear()
+
+        for i in config.clear_layers:
+            renpy.scene(layer=i)
+        
+# Run at the end of init, to set up autosaving based on the user's
+# choices.
+init 1180 python:
+
+    if config.has_autosave:
+        config.autosave_slots = 10
+    else:
+        config.autosave_frequency = None
+    
+# Factored this all into one place, to make our lives a bit easier.
+label _enter_game_menu:
+    $ _enter_menu()
+
+    $ renpy.transition(config.enter_transition)
+
+    if renpy.has_label("enter_game_menu"):
+        call expression "enter_game_menu" from _call_enter_game_menu_1
+
+    if config.game_menu_music:
+        $ renpy.music.play(config.game_menu_music, if_changed=True)
+
+    return
+
+# Entry points from the game into menu-space.
+label _game_menu(_game_menu_screen=_game_menu_screen):
+    if not _game_menu_screen:
+        return
+
+    $ renpy.play(config.enter_sound)
+    
+    call _enter_game_menu from _call__enter_game_menu_0
+    
+    if renpy.has_label("game_menu"):
+        jump expression "game_menu"
+
+    if renpy.has_screen(_game_menu_screen):
+        $ renpy.show_screen(_game_menu_screen)
+        $ ui.interact()
+        jump _noisy_return
+        
+    jump expression _game_menu_screen
+
+label _game_menu_save:
+    call _enter_game_menu from _call__enter_game_menu_1
+
+    if renpy.has_label("_save_screen"):
+        jump expression "_save_screen"
+    else:
+        jump expression "save_screen"
+
+label _game_menu_load:
+    call _enter_game_menu from _call__enter_game_menu_2
+
+    if renpy.has_label("_load_screen"):
+        jump expression "_load_screen"
+    else:
+        jump expression "load_screen"
+
+label _game_menu_preferences:
+    call _enter_game_menu from _call__enter_game_menu_3
+
+    if renpy.has_label("_prefs_screen"):
+        jump expression "_prefs_screen"
+    else:
+        jump expression "preferences_screen"
+
+label _quit:
+    $ renpy.quit()
+
+label _return_skipping:
+    $ config.skipping = "slow"
+    jump _return
+    
+# Make some noise, then return.
+label _noisy_return:
+    $ renpy.play(config.exit_sound)
+
+# Return to the game.
+label _return:
+
+    if renpy.context()._main_menu:
+        $ renpy.transition(config.game_main_transition)
+        jump _main_menu_screen
+
+    $ renpy.transition(config.exit_transition)
+
+    return
+
+label _confirm_quit:
+
+    if renpy.has_label("confirm_quit"):
+        jump expression "confirm_quit"
+    elif renpy.has_label("_compat_confirm_quit"):
+        jump expression "_compat_confirm_quit"
+    else:
+        jump expression "_quit_prompt"
+
+
+##############################################################################
+# Code that originated in 00mainmenu.rpy
+
+init -1180 python hide:
+
+    # menus: Music to play at the main menu.
+    config.main_menu_music = None
+
+    # advanced: Callbacks to run at start.
+    config.start_callbacks = [ ]
+
+
+# This fixes up the context, if necessary, then calls the real
+# after_load.
+label _after_load:
+    $ renpy.context()._menu = False
+    $ renpy.context()._main_menu = False
+
+    if config.after_load_transition:
+        $ renpy.transition(config.after_load_transition, force=True)
+    
+    if renpy.has_label("after_load"):
+        jump expression "after_load"
+    else:
+        return
+
+    
+# This is the true starting point of the program. Sssh... Don't
+# tell anyone.
+label _start:
+
+    python hide:
+        renpy.context()._menu = False
+        renpy.context()._main_menu = False
+        
+        for i in config.start_callbacks:
+            i()
+
+    $ renpy.block_rollback()
+
+    call _gl_test
+            
+    call _load_reload_game from _call__load_reload_game_1
+
+    if not _restart and config.auto_load and renpy.can_load(config.auto_load):
+        $ renpy.load(config.auto_load)
+
+    if config.start_scene_black:        
+        scene black
+    else:
+        scene
+        
+    if not _restart:
+        $ ui.pausebehavior(0)
+        $ ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+    $ renpy.block_rollback()
+
+    $ _old_game_menu_screen = _game_menu_screen
+    $ _old_predict_screens = _predict_screens
+    $ _game_menu_screen = None
+    $ _predict_screens = [ 'main_menu' ]
+    
+    if renpy.has_label("splashscreen") and not _restart:
+        call expression "splashscreen" from _call_splashscreen_1
+
+    $ _game_menu_screen = _old_game_menu_screen
+    $ del _old_game_menu_screen
+        
+    $ renpy.block_rollback()
+
+    if config.main_menu_music:
+        $ renpy.music.play(config.main_menu_music, if_changed=True)
+    else:
+        $ renpy.music.stop()
+        
+    # Clean out any residual scene from the splashscreen.
+    if config.start_scene_black:
+        scene black
+    else:
+        scene
+
+
+    # This has to be python, to deal with a case where _restart may
+    # change across a shift-reload.
+    python:
+        if _restart is None:
+            renpy.transition(config.end_splash_transition)
+        else:
+            renpy.transition(_restart[0])
+            renpy.jump(_restart[1])
+        
+label _invoke_main_menu:
+
+    # Again, this has to be python.
+    python:
+        if _restart:
+            renpy.call_in_new_context(_restart[2])
+        else:
+            renpy.call_in_new_context("_main_menu")
+        
+        
+    # If the main menu returns, then start the game.
+    jump start
+
+# At this point, we've been switched into a new context. So we
+# initialize it.
+label _main_menu(_main_menu_screen="_main_menu_screen"):
+
+    $ _enter_menu()
+
+    python:
+        renpy.dynamic("_load_prompt")
+        _load_prompt = False
+
+        renpy.context()._main_menu = True
+        store.main_menu = True
+
+    jump expression _main_menu_screen
+        
+# This is called to show the main menu to the user.
+label _main_menu_screen:    
+
+    # Let the user completely override the main menu. (But please note
+    # it still lives in the menu context, rather than the game context.)
+    if renpy.has_label("main_menu"):
+        jump expression "main_menu"
+
+    # New name.
+    elif renpy.has_label("main_menu_screen"):
+        jump expression "main_menu_screen"
+
+    # Compatibility name.
+    elif renpy.has_label("_library_main_menu"):
+        jump expression "_library_main_menu"
+        
+    return
+
+init 1180 python hide:
+    
+    def create_automatic_images():
+    
+        seps = config.automatic_images
+
+        if seps is True:
+            seps = [ ' ', '/', '_' ]
+            
+        for dir, fn in renpy.loader.listdirfiles():
+
+            if fn.startswith("_"):
+                continue
+
+            # Only .png and .jpg
+            if not fn.lower().endswith(".png") and not fn.lower().endswith(".jpg"):
+                continue
+
+            # Strip the extension, replace slashes.
+            shortfn = fn[:-4].replace("\\", "/")
+            
+            # Determine the name.
+            name = ( shortfn, )
+            for sep in seps:
+                name = tuple(j for i in name for j in i.split(sep))
+
+            # Strip name components.
+            while name:
+                for i in config.automatic_images_strip:
+                    if name[0] == i:
+                        name = name[1:]
+                        break
+                else:
+                    break
+                
+            # Only names of 2 components or more.
+            if len(name) < 2:
+                continue
+            
+            # Reject if it already exists.
+            if name in renpy.display.image.images:
+                continue
+
+            renpy.image(name, fn)
+
+    if config.automatic_images:
+        create_automatic_images()
+
+
+# After init, make some changes based on if config.developer is True.
+init 1180 python hide:
+
+    if config.developer:
+        if config.debug_sound is None:
+            config.debug_sound = True
+        
+        renpy.load_module("_developer")
+
+
+
+# Entry point for the developer screen. The rest of it is loaded from
+# _developer.rpym
+label _developer:
+
+    if not config.developer:
+        return
+
+    $ _enter_menu()
+
+    jump expression "_developer_screen"
+
+
+# Translations.
+init -1180 python:
+
+    def _language_activate():
+
+        if persistent._language:
+            language = persistent._language 
+        else:
+            language = "translations"
+    
+        if renpy.loadable(language + ".rpt"):
+            config.translator = renpy.Translator(language)
+        else:
+            config.translator = None
+            
+    _language_activate()
+            

common/00menus.rpy

@@ -0,0 +1,46 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Common stuff that's used by the various Ren'Py menus. This includes
+# the default definitions of config.main_menu and config.game_menu, as
+# well as the default definitions of the various preferences (and the objects
+# holding those preferences)
+
+init -1150 python:
+
+    config.main_menu = [
+        (u"Start Game", "start", "True"),
+        (u"Load Game", _intra_jumps("load_screen", "main_game_transition"), "True"),
+        (u"Preferences", _intra_jumps("preferences_screen", "main_game_transition"), "True"),
+        (u"Help", _help, "True", "config.help"),
+        (u"Quit", ui.jumps("_quit"), "True"),
+        ]
+
+    config.game_menu = [
+        ( None, u"Return", ui.jumps("_return"), 'True'),
+        ( "preferences", u"Preferences", _intra_jumps("preferences_screen", "intra_transition"), 'True' ),
+        ( "save", u"Save Game", _intra_jumps("save_screen", "intra_transition"), 'not main_menu' ),
+        ( "load", u"Load Game", _intra_jumps("load_screen", "intra_transition"), 'True'),
+        ( None, u"Main Menu", ui.callsinnewcontext("_main_menu_prompt"), 'not main_menu' ),
+        ( "help", u"Help", _help, "True", "config.help"),
+        ( None, u"Quit", ui.callsinnewcontext("_quit_prompt"), 'True' ),
+        ]
+
+label _quit_prompt:
+    $ renpy.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.QUIT):
+        jump _quit
+    else:
+        return
+
+label _main_menu_prompt:
+    $ renpy.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.MAIN_MENU):
+        $ renpy.full_restart(transition=config.game_main_transition)
+    else:
+        return
+
+    
+ 

common/00mixers.rpy

@@ -0,0 +1,63 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains code that sets up the various mixers, based on how
+# the user sets config.has_music, .has_sound, and .has_voice.
+
+init -1130 python hide:
+    
+    # Set to true in the very unlikely event you want to manually init
+    # the sound system.
+    config.force_sound = False
+
+    # basics: True if the game will have music.
+    config.has_music = True
+
+    # basics: True if the game will have sound effects.
+    config.has_sound = True
+
+    # Register 8 channels by default, for compatiblity with older version
+    # of Ren'Py.
+    for i in xrange(0, 8):
+        renpy.music.register_channel(i)
+
+    renpy.music.register_channel("movie", "music", False, stop_on_mute=False, buffer_queue=False)
+        
+    # Set up default names for some of the channels.
+    renpy.music.alias_channel(0, "sound")
+    renpy.music.alias_channel(7, "music")
+    renpy.music.alias_channel(2, "voice")
+    
+init 1130:
+
+    python hide:
+
+        if not config.has_music and not config.has_sound:
+            mixers = None
+            
+        elif not config.has_music and config.has_sound:
+            mixers = [ 'sfx' ] * 8
+
+        elif config.has_music and not config.has_sound:
+            mixers = [ 'music' ] * 8
+
+        else:
+            mixers = [ 'sfx' ] * 3 + [ 'music' ] * 5
+
+        if config.has_voice:
+            if not mixers:
+                mixers = [ 'voice' ] * 8
+            else:
+                mixers[2] = 'voice'
+
+        if not mixers:
+            config.sound = config.force_sound
+
+        else:
+            for i, m in enumerate(mixers):
+                renpy.sound.set_mixer(i, m, default=True)
+                if m == 'music':
+                    renpy.music.set_music(i, True, default=True)
+                else:
+                    renpy.music.set_music(i, False, default=True)
+        

common/00musicroom.rpy

@@ -0,0 +1,221 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains the code to implement Ren'Py's music room function,
+# which consists of the ability to set up a playlist (the aforementioned
+# "music room"), and then a series of actions that let the player 
+# navigate through the music room.
+
+init -1135 python:
+
+    class __MusicRoomPlay(Action):
+        """
+        The action returned by MusicRoom.Play when called with a file.
+        """
+                
+        def __init__(self, mr, filename):
+            self.mr = mr
+            self.filename = filename
+            self.selected = self.get_selected()
+
+        def __call__(self):
+            self.mr.play(self.filename, 0)
+        
+        def get_sensitive(self):
+            return self.mr.is_unlocked(self.filename)
+            
+        def get_selected(self):
+            return renpy.music.get_playing(self.mr.channel) == self.filename
+        
+        def periodic(self, st):
+            if self.selected != self.get_selected():
+                renpy.restart_interaction()
+
+            return .1
+    
+    class MusicRoom(object):
+        """
+        :doc: music_room class
+        
+        A music room that contains a series of songs that can be unlocked
+        by the user, and actions that can play entries from the list in
+        order.
+        """
+        
+        def __init__(self, channel="music", fadeout=0.0, fadein=0.0):
+            """
+            `channel`
+                The channel that this music room will operate on.
+
+            `fadeout`
+                The number of seconds it takes to fade out the old
+                music when changing tracks.
+                
+            `fadein`
+                The number of seconds it takes to fade in the new
+                music when changing tracks.
+            """
+    
+            self.channel = channel
+            self.fadeout = fadeout
+            self.fadein = fadein
+            
+            # The list of strings giving the titles of songs that make up the
+            # playlist.
+            self.playlist = [ ]
+            
+            # A set of filenames, so we can quickly check if a valid filename
+            # has been provided.
+            self.filenames = set()
+            
+            # The set of songs that are always unlocked.
+            self.always_unlocked = set()
+            
+            
+        def add(self, filename, always_unlocked=False):
+            """
+            :doc: music_room method
+            
+            Adds the music file `filename` to this music room. The music room
+            will play unlocked files in the order that they are added to the
+            room.
+            
+            `always_unlocked`
+                If true, the music file will be always unlocked. This allows
+                the file to show up in the music room before it has been 
+                played in the game.
+            """
+            
+            self.playlist.append(filename)
+            self.filenames.add(filename)
+            
+            if always_unlocked:
+                self.always_unlocked.add(filename)
+                
+        def is_unlocked(self, filename):
+            """
+            :doc: music_room method
+            
+            Returns true if the filename has been unlocked (or is always
+            unlocked), and false if it is still locked.
+            """
+            
+            if filename in self.always_unlocked:
+                return True
+            
+            return renpy.seen_audio(filename)
+        
+        def unlocked_playlist(self):
+            """
+            Returns a list of filenames in the playlist that have been 
+            unlocked.
+            """
+            
+            return [ i for i in self.playlist if self.is_unlocked(i) ]
+        
+        def play(self, filename=None, offset=0):
+            """
+            Starts the music room playing. The file we start playing with is 
+            selected in two steps. 
+
+            If `filename` is an unlocked file, we start by playing it.
+            Otherwise, we start by playing the currently playing file, and if
+            that doesn't exist or isn't unlocked, we start with the first file.
+
+            We then apply `offset`. If `offset` is positive, we advance that many
+            files, otherwise we go back that many files.
+            
+            The selected file is then played.                
+        
+            """
+            
+            playlist = self.unlocked_playlist()
+            
+            if not playlist:
+                return
+            
+            if filename is None:
+                filename = renpy.music.get_playing(channel=self.channel)
+            
+            try:
+                idx = playlist.index(filename)
+            except ValueError:
+                idx = 0
+                
+            idx = (idx + offset) % len(playlist)
+            
+            playlist = playlist[idx:] + playlist[:idx]
+            
+            renpy.music.play(playlist, channel=self.channel, fadeout=self.fadeout, fadein=self.fadein)
+            
+        def stop(self):
+            """
+            Stops the music from playing.
+            """
+            
+            renpy.music.stop(channel=self.channel, fadeout=self.fadeout)
+            
+        def next(self):
+            """
+            Plays the next file in the playlist.
+            """
+
+            return self.play(None, 1)
+            
+        def previous(self):
+            """
+            Plays the previous file in the playlist.
+            """
+            
+            return self.play(None, -1)
+            
+        def Play(self, filename=None):
+            """
+            :doc: music_room method
+                        
+            Causes the music room to start playing. If `filename` is given, that
+            file begins playing. Otherwise, the currently playing file starts 
+            over (if it's unlocked), or the first file starts playing.
+
+            If `filename` is given, buttons with this action will be insensitive
+            while `filename` is locked, and will be selected when `filename`
+            is playing.
+            """
+                
+            if filename is None:
+                return self.play
+                
+            if filename not in self.filenames:
+                raise Exception("{0!r} is not a filename registered with this music room.".format(filename))
+            
+            return __MusicRoomPlay(self, filename)
+        
+        def Stop(self):
+            """
+            :doc: music_room method
+            
+            Stops the music.
+            """
+            
+            return self.stop
+            
+        
+        def Next(self):
+            """
+            :doc: music_room method
+            
+            An action that causes the music room to play the next unlocked file
+            in the playlist.
+            """
+            
+            return self.next
+        
+        def Previous(self):
+            """
+            :doc: music_room method
+            
+            An action that causes the music room to play the previous unlocked 
+            file in the playlist.
+            """
+            
+            return self.previous

common/00nvl_mode.rpy

@@ -0,0 +1,416 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This is an implementation of NVL-mode, which can be used to show
+# dialogue in a fullscreen way, like NVL-style games. Multiple lines
+# of dialogue are shown on the screen at once, whenever a line of
+# dialogue is said by a NVLCharacter. Calling the nvl_clear function
+# clears the screen, ensuring that the the next line will appear at
+# the top of the screen.
+#
+# You can also have menus appear on the screen, by running:
+#
+# init:
+#     $ menu = nvl_menu
+#
+# It's also possible to make the narrator a NVLCharacter, using code like:
+#
+# init:
+#     $ narrator = NVLCharacter(None)
+        
+##############################################################################
+# The implementation of NVL mode lives below this line.
+
+init -1100 python:
+
+    # Styles that are used by nvl mode.
+    style.create('nvl_window', 'default', 'the window containing nvl-mode dialogue')
+    style.create('nvl_vbox', 'vbox', 'the vbox containing each box of nvl-mode dialogue')
+    style.create('nvl_label', 'say_label', 'an nvl-mode character\'s name')
+    style.create('nvl_dialogue', 'say_dialogue', 'nvl-mode character dialogue')
+    style.create('nvl_entry', 'default', 'a window containing each line of nvl-mode dialogue')
+
+    style.create('nvl_menu_window', 'default', 'a window containing an nvl-mode menu')
+    style.create('nvl_menu_choice', 'default', 'an nvl-mode menu choice')
+    style.create('nvl_menu_choice_chosen', 'nvl_menu_choice', 'an nvl-mode menu choice that has been chosen')
+    style.create('nvl_menu_choice_button', 'default', 'an nvl-mode choice button')
+    style.create('nvl_menu_choice_chosen_button', 'nvl_menu_choice_button', 'an nvl-mode choice button that\'s been chosen.')
+
+    # Set up nvl mode styles.
+    style.nvl_label.minwidth = 150
+    style.nvl_label.text_align = 1.0
+
+    style.nvl_window.background = "#0008"
+    style.nvl_window.yfill = True
+    style.nvl_window.xfill = True
+    style.nvl_window.xpadding = 20
+    style.nvl_window.ypadding = 30
+
+    style.nvl_vbox.box_spacing = 10
+
+    style.nvl_menu_choice.idle_color = "#0ff"
+    style.nvl_menu_choice.hover_color = "#ff0"
+    style.nvl_menu_choice_button.left_margin = 160
+    style.nvl_menu_choice_button.right_margin = 20
+    style.nvl_menu_choice_button.xfill = True
+    style.nvl_menu_choice_button.hover_background = "#F0F2"
+
+    # nvlmode: The CTC indicator to use when at the end of an NVL page.
+    config.nvl_page_ctc = None
+
+    # nvlmode: The position of the CTC indicator used at the end of an NVL page.
+    config.nvl_page_ctc_position = "nestled"
+
+    # Should we used paged rollback?
+    config.nvl_paged_rollback = False
+
+    # A hook that delta wanted, that is called instead of renpy.show_display_say
+    config.nvl_show_display_say = renpy.show_display_say
+    
+    # A list of arguments that have been passed to nvl_record_show.
+    nvl_list = None
+
+    # If set, then all of the nvl-specific style get indexed with this.
+    nvl_variant = None
+
+    # Returns the appropriate variant style.
+    def __s(s):
+        if nvl_variant:
+            return s[nvl_variant]
+        else:
+            return s
+
+    def __nvl_screen_dialogue():
+        """
+         Returns widget_properties and dialogue for the current NVL
+         mode screen.
+         """
+
+        widget_properties = { }
+        dialogue = [ ]
+        
+        for i, entry in enumerate(nvl_list):
+            if not entry:
+                continue
+
+            who, what, kwargs = entry
+
+            if i == len(nvl_list) - 1:
+                who_id = "who"
+                what_id = "what"
+                window_id = "window"
+
+            else:
+                who_id = "who%d" % i
+                what_id = "what%d" % i
+                window_id = "window%d" % i
+                
+            widget_properties[who_id] = kwargs["who_args"]
+            widget_properties[what_id] = kwargs["what_args"]
+            widget_properties[window_id] = kwargs["window_args"]
+
+            dialogue.append((who, what, who_id, what_id, window_id))
+        
+        return widget_properties, dialogue
+        
+    def __nvl_show_screen(screen_name, **scope):
+        """
+         Shows an nvl-mode screen. Returns the "what" widget.
+         """
+
+        widget_properties, dialogue = __nvl_screen_dialogue()        
+
+        renpy.show_screen(screen_name, _transient=True, _widget_properties=widget_properties, dialogue=dialogue, **scope) 
+        renpy.shown_window()
+
+        return renpy.get_widget(screen_name, "what")
+        
+    def nvl_show_core(who=None, what=None):
+
+         # Screen version.
+        if renpy.has_screen("nvl"):
+            return __nvl_show_screen("nvl", items=[ ])
+        
+        if renpy.in_rollback():
+            nvl_window = __s(style.nvl_window)['rollback']
+            nvl_vbox = __s(style.nvl_vbox)['rollback']
+        else:
+            nvl_window = __s(style.nvl_window)
+            nvl_vbox = __s(style.nvl_vbox)
+        
+        ui.window(style=nvl_window)
+        ui.vbox(style=nvl_vbox)
+
+        rv = None
+
+        for i in nvl_list:
+            if not i:
+                continue
+
+            who, what, kw = i                
+            rv = config.nvl_show_display_say(who, what, variant=nvl_variant, **kw)
+
+        ui.close()
+
+        renpy.shown_window()
+        
+        return rv
+
+    def nvl_window():
+        nvl_show_core()
+    
+    def nvl_show(with_):
+        nvl_show_core()
+        renpy.with_statement(with_)
+
+    def nvl_hide(with_):
+        nvl_show_core()
+        renpy.with_statement(None)
+        renpy.with_statement(with_)
+
+    def nvl_erase():
+        if nvl_list:
+            nvl_list.pop()
+
+    # Check to see if one of the next statements is nvl clear.
+    def nvl_clear_next():
+
+        # The number of statements forward to look.
+        count = 10
+
+        scry = renpy.scry()
+        scry = scry.next()
+
+        while count and scry:
+
+            count -= 1
+            if scry.nvl_clear:
+                return True
+
+            if scry.interacts:
+                return False
+
+            scry = scry.next()
+        
+            
+    class NVLCharacter(ADVCharacter):
+
+        def __init__(self, 
+                     who=renpy.character.NotSet,
+                     kind=None,
+                     **properties):
+            
+            if kind is None:
+                kind = store.nvl
+            
+            if "clear" in properties:
+                self.clear = properties.pop("clear")
+            else:
+                self.clear = kind.clear
+
+            ADVCharacter.__init__(
+                self, 
+                who,
+                kind=kind,
+                **properties)
+
+        def do_add(self, who, what):
+        
+            if store.nvl_list is None:
+                store.nvl_list = [ ]
+                
+            kwargs = self.show_args.copy()
+            kwargs["what_args"] = self.what_args
+            kwargs["who_args"] = self.who_args
+            kwargs["window_args"] = self.window_args
+            
+            store.nvl_list.append((who, what, kwargs))
+
+        def do_display(self, who, what, **display_args):
+
+            page = self.clear or nvl_clear_next()
+
+            if config.nvl_page_ctc and page:
+                display_args["ctc"] = config.nvl_page_ctc
+                display_args["ctc_position"] = config.nvl_page_ctc_position
+
+            if config.nvl_paged_rollback:
+                if page:
+                    checkpoint = True
+                else:
+                    if renpy.in_rollback():
+                        return
+                    checkpoint = False
+            else:
+                checkpoint = True
+                
+            renpy.display_say(
+                who,
+                what,
+                nvl_show_core,
+                checkpoint=checkpoint,
+                **display_args)
+            
+        def do_done(self, who, what):
+            if self.clear:
+                nvl_clear()
+
+        def do_extend(self):
+            renpy.mode(self.mode)
+            store.nvl_list = store.nvl_list[:-1]
+                
+    # The default NVLCharacter.
+    nvl = NVLCharacter(
+        show_say_vbox_properties={ 'box_layout' : 'horizontal' },
+        who_style='nvl_label',
+        what_style='nvl_dialogue',
+        window_style='nvl_entry',
+        type='nvl',
+        mode='nvl',
+        clear=False,
+        kind=adv)
+                
+    def nvl_clear():
+        store.nvl_list = [ ]
+
+    # Run clear at the start of the game.
+    config.start_callbacks.append(nvl_clear)
+    
+    
+    def nvl_menu(items):
+
+        renpy.mode('nvl_menu')
+        
+        if nvl_list is None:
+            store.nvl_list = [ ]
+
+        screen = None
+        
+        if renpy.has_screen("nvl_choice"):
+            screen = "nvl_choice"
+        elif renpy.has_screen("nvl"):
+            screen = "nvl"
+            
+        if screen is not None:
+
+            widget_properties, dialogue = __nvl_screen_dialogue()        
+
+            return renpy.display_menu(
+                items,
+                widget_properties=widget_properties,
+                screen=screen,
+                scope={ "dialogue" : dialogue },
+                window_style=__s(style.nvl_menu_window),
+                choice_style=__s(style.nvl_menu_choice),
+                choice_chosen_style=__s(style.nvl_menu_choice_chosen),
+                choice_button_style=__s(style.nvl_menu_choice_button),
+                choice_chosen_button_style=__s(style.nvl_menu_choice_chosen_button),
+                type="nvl",                      
+                )
+
+
+        # Traditional version.
+        ui.layer("transient")
+        ui.clear()
+        ui.close()
+
+        ui.window(style=__s(style.nvl_window))
+        ui.vbox(style=__s(style.nvl_vbox))
+
+        for i in nvl_list:
+            if not i:
+                continue
+
+            who, what, kw = i            
+            rv = renpy.show_display_say(who, what, **kw)
+
+        renpy.display_menu(items, interact=False,
+                           window_style=__s(style.nvl_menu_window),
+                           choice_style=__s(style.nvl_menu_choice),
+                           choice_chosen_style=__s(style.nvl_menu_choice_chosen),
+                           choice_button_style=__s(style.nvl_menu_choice_button),
+                           choice_chosen_button_style=__s(style.nvl_menu_choice_chosen_button),
+                           )
+
+        ui.close()
+
+        roll_forward = renpy.roll_forward_info()
+
+        rv = ui.interact(roll_forward=roll_forward)
+        renpy.checkpoint(rv)
+
+        return rv
+
+    NVLSpeaker = NVLCharacter
+    
+    config.nvl_adv_transition = None
+    config.adv_nvl_transition = None
+
+
+    # This is used to execute the nvl and adv mode transitions.
+    def _nvl_adv_callback(mode, old_modes):
+
+        old = old_modes[0]
+
+        if config.adv_nvl_transition:
+            if mode == "nvl" or mode == "nvl_menu":
+                if old == "say" or old == "menu":
+                    nvl_show(config.adv_nvl_transition)
+                    
+        if config.nvl_adv_transition:
+            if mode == "say" or mode == "menu":
+                if old == "nvl" or old == "nvl_menu":
+                    nvl_hide(config.nvl_adv_transition)
+                    
+    config.mode_callbacks.append(_nvl_adv_callback)
+    
+python early hide:
+
+    def parse_nvl_show_hide(l):
+        rv = l.simple_expression()
+        if rv is None:
+            renpy.error('expected simple expression')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return rv
+            
+    def lint_nvl_show_hide(trans):
+        _try_eval(trans, 'transition')
+
+    def execute_nvl_show(trans):
+        nvl_show(eval(trans))
+
+    def execute_nvl_hide(trans):
+        nvl_hide(eval(trans))
+
+    renpy.statements.register("nvl show",
+                              parse=parse_nvl_show_hide,
+                              execute=execute_nvl_show,
+                              lint=lint_nvl_show_hide)
+
+    renpy.statements.register("nvl hide",
+                              parse=parse_nvl_show_hide,
+                              execute=execute_nvl_hide,
+                              lint=lint_nvl_show_hide)
+
+    def parse_nvl_clear(l):
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return None
+
+    def execute_nvl_clear(parse):
+        nvl_clear()
+
+    def scry_nvl_clear(parse, scry):
+        scry.nvl_clear = True
+        
+    renpy.statements.register('nvl clear',
+                              parse=parse_nvl_clear,
+                              execute=execute_nvl_clear,
+                              scry=scry_nvl_clear)
+
+
+    

common/00splines.rpy

@@ -0,0 +1,135 @@
+# This file contains the spline motion code contributed by Aenakume, at
+# http://lemmasoft.renai.us/forums/viewtopic.php?f=8&t=3977
+
+init -1080 python:
+    class _SplineInterpolator(object):
+   
+        ANCHORS = {
+            'top'    : 0.0,
+            'center' : 0.5,
+            'bottom' : 1.0,
+            'left'   : 0.0,
+            'right'  : 1.0,
+            }
+   
+        def __init__(self, points, anchors=(0.5, 0.5)):
+     
+            assert len(points) >= 2, "Need at least a start and end point."
+     
+            def setup_coordinate_(c):
+                if len(c) == 2:
+                    c += anchors
+                return [ self.ANCHORS.get(i, i) for i in c ]
+     
+            self.points = []
+            
+            for p in points:
+                length = len(p)
+                
+                if isinstance(p[-1], float):
+                    length = len(p) - 1
+                    point = [ p[-1] ]
+                else:
+                    length = len(p)
+                    point = [ -1 ]
+       
+                self.points.append(point + [ setup_coordinate_(p[i]) for i in range(length) ])
+     
+            # Make sure start and end times are set, if not already set
+            if self.points[0][0] == -1:
+                self.points[0][0] = 0.0
+            if self.points[-1][0] == -1:
+                self.points[-1][0] = 1.0
+     
+            # Now we gotta calculate the step times that need calculating
+            for start in range(1, len(self.points) - 1):
+                if self.points[start][0] != -1:
+                    continue
+       
+                end = start + 1
+       
+                while end < (len(self.points) - 1) and self.points[end][0] == -1:
+                    end += 1
+       
+                step = (self.points[end][0] - self.points[start - 1][0]) / float(end - start + 1)
+       
+                for i in range(start, end):
+                    self.points[i][0] = self.points[i - 1][0] + step
+     
+            # And finally, sort the list of points by increasing time
+            self.points.sort(key=lambda a : a[0])
+     
+            self.initialized = None
+   
+        def init_values(self, sizes):
+            def to_abs_(value, size):
+                if type(value) ==  float:
+                    return value * size
+                else:
+                    return value
+     
+            def coord_(c):
+
+                if len(c) == 2:
+                    c = c + (0, 0)
+
+                return ( to_abs_(c[0], sizes[0]) - to_abs_(c[2], sizes[2]),
+                         to_abs_(c[1], sizes[1]) - to_abs_(c[3], sizes[3]) )
+
+            for p in self.points:
+                for i in range(1, len(p)):
+                    p[i] = coord_(p[i])
+     
+            self.initialized = sizes
+  
+        def __call__(self, t, sizes):
+            # Initialize if necessary
+            if not self.initialized == sizes:
+                self.init_values(sizes)
+     
+            # Now we must determine which segment we are in
+            for segment in range(len(self.points)):
+                if self.points[segment][0] > t:
+                    break
+     
+            # If this is the zeroth segment, just start at the start point
+            if segment == 0:
+                result = self.points[0][1]
+            # If this is past the last segment, just leave it at the end point
+            elif segment == len(self.points) - 1 and t > self.points[-1][0]:
+                result = self.points[-1][1]
+            else:
+                # Scale t
+                t = (t - self.points[segment - 1][0]) / (self.points[segment][0] - self.points[segment - 1][0])
+       
+            # Get start and end points
+            start = self.points[segment - 1][1]
+            end   = self.points[segment][1]
+       
+            # Now what kind of interpolation is it?
+            if len(self.points[segment]) == 2:   # Straight line
+                t_p = 1.0 - t
+
+                result = [ t_p * start[i] + t * end[i] for i in 0,1 ]
+
+            elif len(self.points[segment]) == 3: # Quadratic Bezier
+                t_pp = (1.0 - t)**2
+                t_p = 2 * t * (1.0 - t)
+                t2 = t**2
+         
+                result = [ t_pp * start[i] + t_p * self.points[segment][2][i] + t2 * end[i] for i in 0,1 ]
+
+            elif len(self.points[segment]) == 4: # Cubic Bezier
+                t_ppp = (1.0 - t)**3
+                t_pp = 3 * t * (1.0 - t)**2
+                t_p = 3 * t**2 * (1.0 - t)
+                t3 = t**3
+         
+                result = [ t_ppp * start[i] + t_pp * self.points[segment][2][i] + t_p * self.points[segment][3][i] + t3 * end[i] for i in 0,1 ]
+
+            return ( absolute(result[0]), absolute(result[1]), 0, 0 )
+
+    def SplineMotion(points, time, child=None, anchors=(0.5, 0.5), repeat=False, bounce=False, anim_timebase=False, style='default', time_warp=None, **properties):
+        return Motion(_SplineInterpolator(points, anchors), time, child, repeat=repeat, bounce=bounce, anim_timebase=anim_timebase, style=style, time_warp=time_warp, add_sizes=True, **properties)
+
+  

common/00statements.rpy

@@ -0,0 +1,569 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains code that creates a few new statements. We'll
+# also describe here the API for defining your own statements.
+#
+# Statements can be defined by calling renpy.statements.register. This
+# function takes a string giving the keywords at the start of the
+# statement, and then up to 4 functions defining the behavior of the
+# statement: parse, execute, predict, and lint. If given the keyword
+# argument block=True, the statement will take a block.
+#
+# The parse function takes a lexer object as an argument, and is
+# expected to return some parser data. The lexer has the following
+# methods.
+#
+# l.eol() - True if we are at the end of the line.
+# l.match(re) - Matches an arbitrary regexp string.
+# l.keyword(s) - Matches s.
+# l.name() - Matches any non-keyword name. Note that this only
+# counts built-in keywords.
+# l.word() - Matches any word, period.
+# l.string() - Matches a renpy string.
+# l.integer() - Matches an integer, returns a string containing the
+# integer.
+# l.float() - Matches a floating point number.
+# l.simple_expression() - Matches a simple python expression, returns
+# it as a string.
+# l.rest() - Skips whitespace, then returns the rest of the line.
+# l.checkpoint() - Returns an opaque object representing the current
+# point in the parse.
+# l.revert(o) - Given the object returned by l.checkpoint(), returns
+# there.
+#
+# l.subblock_lexer() - Return a lexer that gives a sub-block for the 
+# block associated with the current statement.
+# l.advance() - In a subblock lexer, advance to the next line. This needs
+# to be called before the above functions can be called on the first line. 
+# 
+#
+#
+# The parse function is expected to return an object, which is passed
+# to the other functions. Parse should call renpy.error with the error
+# message to report an error.
+#
+# The execute function is passed the object returned from parse, and
+# is expected to execute the statement.
+#
+# The predict function is passed the object returned from parse, and
+# is expected to return a list of images that are used by the
+# statement.
+#
+# The lint function is called at lint time, after the init code is
+# run. It should check the statement for errors, and report them by
+# calling renpy.error with the appropriate error message.
+#
+# The scry function is called with a scry object. It may mutate that
+# object, but it is then expected to return it. See 00nvlmode.rpy for
+# details.
+# 
+# The next function is expected to return a string giving the label of
+# the next statement to execute, or None to indicate that next
+# statement in the block should be executed. The next function is
+# called during predict, scry, and execute, and should always return
+# the same value. (Or scrying may be incorrect.)
+
+
+python early hide:
+
+    # Music play - The example of a full statement.
+    
+    def parse_play_music(l):
+
+        file = l.simple_expression()
+        if not file:
+            renpy.error("play requires a file")
+
+        fadeout = "None"
+        fadein = "0"
+        channel = None
+        loop = None
+        if_changed = False
+        
+        while True:
+
+            if l.eol():
+                break
+
+            if l.keyword('fadeout'):
+                fadeout = l.simple_expression()
+                if fadeout is None: 
+                    renpy.error('expected simple expression')
+
+                continue
+            
+            if l.keyword('fadein'):
+                fadein = l.simple_expression()
+                if fadein is None: 
+                    renpy.error('expected simple expression')
+
+                continue
+            
+            if l.keyword('channel'):
+                channel = l.simple_expression()
+                if channel is None:
+                    renpy.error('expected simple expression')
+
+                continue
+
+            if l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
+
+            if l.keyword('if_changed'):
+                if_changed = True
+                continue
+            
+            renpy.error('could not parse statement.')
+
+        return dict(file=file,
+                    fadeout=fadeout,
+                    fadein=fadein,
+                    channel=channel,
+                    loop=loop,
+                    if_changed=if_changed)
+
+    def execute_play_music(p):
+
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "music"
+        
+        renpy.music.play(eval(p["file"]),
+                         fadeout=eval(p["fadeout"]),
+                         fadein=eval(p["fadein"]),
+                         channel=channel,
+                         loop=p.get("loop", None),
+                         if_changed=p.get("if_changed", False))
+
+    def predict_play_music(p):
+        return [ ]
+
+    def lint_play_music(p, channel="music"):
+
+        file = _try_eval(p["file"], 'filename')
+
+        if p["channel"] is not None:
+            channel = _try_eval(p["channel"], 'channel')
+            
+        if not isinstance(file, list):
+            file = [ file ]
+
+        for fn in file:
+            if isinstance(fn, basestring):
+                try:
+                    if not renpy.music.playable(fn, channel):
+                        renpy.error("%r is not loadable" % fn)
+                except:
+                    pass
+                        
+    renpy.statements.register('play music',
+                              parse=parse_play_music,
+                              execute=execute_play_music,
+                              predict=predict_play_music,
+                              lint=lint_play_music)
+
+    # From here on, we'll steal bits of other statements when defining other
+    # statements.
+
+    def parse_queue_music(l):
+
+        file = l.simple_expression()
+        if not file:
+            renpy.error("queue requires a file")
+
+        channel = None
+        loop = None
+        
+        while not l.eol():
+        
+            if l.keyword('channel'):
+                channel = l.simple_expression()
+                if channel is None:
+                    renpy.error('expected simple expression')
+
+            if l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
+
+            renpy.error('expected end of line')
+
+        return dict(file=file, channel=channel, loop=loop)
+
+    def execute_queue_music(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "music"
+        
+        renpy.music.queue(
+            eval(p["file"]),
+            channel=channel,
+            loop=p.get("loop", None))
+
+
+    renpy.statements.register('queue music',
+                              parse=parse_queue_music,
+                              execute=execute_queue_music,
+                              lint=lint_play_music)
+
+    def parse_stop_music(l):
+        fadeout = "None"
+
+        if l.keyword("fadeout"):
+            fadeout = l.simple_expression()
+
+        channel = None
+            
+        if l.keyword('channel'):
+            channel = l.simple_expression()
+            if channel is None:
+                renpy.error('expected simple expression')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        if fadeout is None: 
+            renpy.error('expected simple expression')
+
+        return dict(fadeout=fadeout, channel=channel)
+
+    def execute_stop_music(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "music"
+        
+        renpy.music.stop(fadeout=eval(p["fadeout"]), channel=channel)
+
+    renpy.statements.register('stop music',
+                              parse=parse_stop_music,
+                              execute=execute_stop_music)
+
+
+    # Sound statements. They share alot with the equivalent music
+    # statements.
+
+    def execute_play_sound(p):
+        
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "sound"
+
+        fadeout = eval(p["fadeout"]) or 0
+            
+        renpy.sound.play(eval(p["file"]),
+                         fadeout=fadeout,
+                         fadein=eval(p["fadein"]),
+                         channel=channel)
+
+    def lint_play_sound(p, lint_play_music=lint_play_music):
+        return lint_play_music(p, channel="sound")
+        
+    renpy.statements.register('play sound',
+                              parse=parse_play_music,
+                              execute=execute_play_sound,
+                              lint=lint_play_sound)
+
+    def execute_queue_sound(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "sound"
+
+        renpy.sound.queue(eval(p["file"]), channel=channel)
+
+
+    renpy.statements.register('queue sound',
+                              parse=parse_queue_music,
+                              execute=execute_queue_sound,
+                              lint=lint_play_music)
+
+    def execute_stop_sound(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = "sound"
+
+        fadeout = eval(p["fadeout"]) or 0
+
+        renpy.sound.stop(fadeout=fadeout, channel=channel)
+
+    renpy.statements.register('stop sound',
+                              parse=parse_stop_music,
+                              execute=execute_stop_sound)
+
+
+    # Generic play/queue/stop statements. These take a channel name as
+    # the second thing.
+
+    def parse_play_generic(l, parse_play_music=parse_play_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('play requires a channel')
+
+        rv = parse_play_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_queue_generic(l, parse_queue_music=parse_queue_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('queue requires a channel')
+
+        rv = parse_queue_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_stop_generic(l, parse_stop_music=parse_stop_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('stop requires a channel')
+
+        rv = parse_stop_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def lint_play_generic(p, lint_play_music=lint_play_music):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+        lint_play_music(p, channel)
+
+    def lint_stop_generic(p):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+    renpy.statements.register('play',
+                              parse=parse_play_generic,
+                              execute=execute_play_music,
+                              predict=predict_play_music,
+                              lint=lint_play_generic)
+    
+    renpy.statements.register('queue',
+                              parse=parse_queue_generic,
+                              execute=execute_queue_music,
+                              lint=lint_play_generic)
+            
+    renpy.statements.register('stop',
+                              parse=parse_stop_generic,
+                              execute=execute_stop_music,
+                              lint=lint_stop_generic)
+
+
+    ##########################################################################
+    # "window show" and "window hide" statements.
+
+    def parse_window(l):
+        p = l.simple_expression()
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return p
+            
+    def lint_window(p):
+        if p is not None:
+            _try_eval(p, 'window transition')
+
+    def execute_window_show(p):
+        if store._window:
+            return
+
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_show_transition
+            
+        renpy.with_statement(None)
+        store._window = True
+        renpy.with_statement(trans)
+        
+    def execute_window_hide(p):
+        if not _window:
+            return
+        
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_hide_transition
+
+        renpy.with_statement(None)
+        store._window = False
+        renpy.with_statement(trans)
+
+    renpy.statements.register('window show',
+                              parse=parse_window,
+                              execute=execute_window_show,
+                              lint=lint_window)
+
+    renpy.statements.register('window hide',
+                              parse=parse_window,
+                              execute=execute_window_hide,
+                              lint=lint_window)
+
+    ##########################################################################
+    # Pause statement.
+    
+    def parse_pause(l):
+
+        delay = l.simple_expression()
+
+        if not l.eol():
+            renpy.error("expected end of line.")
+
+        return { "delay" : delay }
+
+    def lint_pause(p):
+
+        if p["delay"]:
+            _try_eval(p["delay"], 'pause statement')
+            
+    def execute_pause(p):
+
+        if p["delay"]:
+            delay = eval(p["delay"])
+            renpy.with_statement(Pause(delay))
+        else:
+            renpy.pause()
+
+
+    renpy.statements.register('pause',
+                              parse=parse_pause,
+                              lint=lint_pause,
+                              execute=execute_pause)
+    
+                              
+init -1200 python:
+
+    config.window_show_transition = None
+    config.window_hide_transition = None
+    
+    def _try_eval(e, what):
+        try:
+            return eval(e)
+        except:
+            renpy.error('unable to evaluate %s %r' % (what, e))
+    
+##############################################################################
+# Screen-related statements.
+
+python early hide:
+
+    def parse_show_call_screen(l):
+
+        # Parse a name.
+        name = l.require(l.name)
+
+        # Parse a parameter list. (name -> expression string)
+        parameters = { }
+        
+        if l.match(r"\("):
+
+            while True:
+                pname = l.name()
+                if not pname:
+                    break
+
+                l.require(r"=")
+
+                expr = l.delimited_python(",)")
+
+                if not expr:
+                    l.error("expected expression.")
+
+                parameters[pname] = expr
+
+                if not l.match(r','):
+                    break
+
+            l.require(r'\)')
+            l.expect_eol()
+            
+        return dict(name=name, parameters=parameters)
+
+    def parse_hide_screen(l):
+        name = l.require(l.name)
+
+        l.expect_eol()
+
+        return dict(name=name)
+
+    def predict_screen(p):
+        if not p["parameters"]:
+            renpy.predict_screen(p["name"])
+    
+    def execute_show_screen(p):
+
+        name = p["name"]
+        parameters = p["parameters"]
+
+        kwargs = { }
+
+        for k, v in parameters.iteritems():
+            kwargs[k] = eval(v)
+
+        renpy.show_screen(name, **kwargs)
+
+    def execute_call_screen(p):
+        name = p["name"]
+        parameters = p["parameters"]
+
+        kwargs = { }
+
+        for k, v in parameters.iteritems():
+            kwargs[str(k)] = eval(v)
+
+        store._return = renpy.call_screen(name, **kwargs)
+
+    def execute_hide_screen(p):
+        name = p["name"]
+        renpy.hide_screen(name)
+        
+    def lint_screen(p):
+        name = p["name"]
+        if not renpy.has_screen(name):
+            renpy.error("Screen %s does not exist." % name)
+
+        
+    renpy.statements.register("show screen",
+                              parse=parse_show_call_screen,
+                              execute=execute_show_screen,
+                              predict=predict_screen,
+                              lint=lint_screen)
+
+    renpy.statements.register("call screen",
+                              parse=parse_show_call_screen,
+                              execute=execute_call_screen,
+                              predict=predict_screen,
+                              lint=lint_screen)
+
+    renpy.statements.register("hide screen",
+                              parse=parse_hide_screen,
+                              execute=execute_hide_screen)
+
+            
+    

common/00style.rpy

@@ -0,0 +1,328 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file is responsible for creating and defining the default styles
+# used by the system.
+
+# This file should be considered part of the Ren'Py library, and not
+# something that needs to be modified by the user. Instead, just update
+# the appropriate style property in an init: block in your script.
+#
+# For example, to change the default window backgrounds to a
+# transparent dark red, add:
+#
+# init:
+#     $ style.window.background = "#8008"
+#
+# to your script. No need to mess around here, it will just make your
+# life harder when a new version of Ren'Py is released.
+
+init -1200 python hide:
+
+    # Style Declarations #################################################
+
+    style.default = Style(None, help='root of style hierarchy')
+    style.text = Style(style.default, help='style of text')
+
+    style.fixed = Style(style.default, help='fixed layouts')
+    style.hbox = Style(style.default, help='horizontal boxes')
+    style.vbox = Style(style.default, help='vertical boxes')
+    style.grid = Style(style.default, help='grid layouts')
+    style.side = Style(style.default, help='side layouts')
+    
+    style.window = Style(style.default, help='windows created with ui.window')
+
+    style.image_placement = Style(style.default, help='default placement of images on the screen')
+    style.image = Style(style.default, help="default style of images")
+
+    style.motion = Style(style.default, help="default style of motions and zooms.")
+    style.animation = Style(style.default, help="default style of animations.")
+
+    style.say_label = Style(style.default, help='the name of the character speaking dialogue.')
+    style.say_dialogue = Style(style.default, help='used for dialogue text')
+    style.say_thought = Style(style.default, help='used by the default narrator')
+    style.say_window = Style(style.window, help='windows containing dialogue and thoughts')
+    style.say_who_window = Style(style.window, help='window containing the label in two-window-say mode')
+    style.say_two_window_vbox = Style(style.vbox, help='vbox containing the two windows in two-window-say mode')
+    style.say_vbox = Style(style.vbox, help='contains the label (if present) and the body of dialogue')
+
+    style.menu = Style(style.default, help='the vbox containing an in-game menu')
+    style.menu_caption = Style(style.default, help='in-game menu caption text')
+    style.menu_choice = Style(style.default, help='text of an in-game menu choice')
+    style.menu_choice_button = Style(style.default, help='buttons containing in-game menu choices')
+    style.menu_choice_chosen = Style(style.menu_choice, help='text of an in-game menu choice that has been chosen')
+    style.menu_choice_chosen_button = Style(style.menu_choice_button, help='buttons containing chosen in-game menu choices')
+    style.menu_window = Style(style.window, help='a window containing a menu')
+
+    style.input = Style(style.default, help='style of an input control')
+    style.input_text = Style(style.input, help='text of an input box')
+    style.input_prompt = Style(style.default, help='prompt of an input box')
+    style.input_window = Style(style.window, help='window of an input box')
+
+    style.centered_window = Style(style.default, help='window containing centered text')
+    style.centered_text = Style(style.default, help='centered text')
+
+    style.imagemap = Style(style.image_placement, help='default style of imagemaps')
+    style.hotspot = Style(style.default, help='default style of hotspots inside imagemaps')
+    style.hotbar = Style(style.default, help='default style of hotbars inside imagemaps')
+    style.imagemap_button = style.hotspot
+    
+    style.image_button = Style(style.default, help='default style of image buttons')
+    style.image_button_image = Style(style.default, help='default style of images inside image buttons')
+
+    style.hyperlink = Style(style.default, help=None) # ignored
+    style.hyperlink_text = Style(style.default, help='hyperlinked text')
+    style.ruby_text = Style(style.default, help='ruby text')
+
+    style.viewport = Style(style.default, help='default style of viewports')
+    style.transform = Style(style.motion, help='default style of transforms')
+    
+    style.list = Style(style.default)
+    style.list_box = Style(style.vbox)
+    style.list_row = Style(style.default)
+    style.list_row_box = Style(style.hbox)
+    style.list_spacer = Style(style.default)    
+    style.list_text = Style(style.default)
+
+    style.tile = Style(style.default, help='default style of tile')
+    
+# The base styles that can be customized by themes.
+
+    style.frame = Style(style.default, help='base style for frames.')
+    style.menu_frame = Style(style.frame, help='base style for frames used in the game and main menus.')
+    
+    style.button = Style(style.default, help='base style for buttons.')
+    style.button_text = Style(style.default, help='base style for button text')
+
+    style.small_button = Style(style.button, help="base style for small buttons")
+    style.small_button_text = Style(style.button_text, help="base style for small button text")
+    style.radio_button = Style(style.button, help="base style for radio buttons")
+    style.radio_button_text = Style(style.button_text, help="base style for radio button text")
+    style.check_button = Style(style.button, help="base style for check buttons")
+    style.check_button_text = Style(style.button_text, help="base style for check button text")
+
+    style.large_button = Style(style.default, help="base style for large buttons")
+    style.large_button_text = Style(style.default, help="base style for large button text")
+
+    style.label = Style(style.default, help="base style for windows surrounding labels")
+    style.label_text = Style(style.default, help="base style for label text")
+
+    style.prompt = Style(style.default, help="base style for windows surrounding prompts")
+    style.prompt_text = Style(style.default, help="base style for prompt text")
+    
+    style.bar = Style(style.default, help='base style for horizontal bars')
+    style.vbar = Style(style.default, help='base style for vertical bars')
+
+    style.slider = Style(style.default, help='base style for horizontal sliders')
+    style.vslider = Style(style.default, help='base style for vertical sliders')
+
+    style.scrollbar = Style(style.default, help='base style for horizontal scrollbars')
+    style.vscrollbar = Style(style.default, help='base style for vertical scollbars')
+
+    style.mm_root = Style(style.default, help="main menu root window")
+    style.gm_root = Style(style.default, help="game menu root window")
+
+    
+init -1090 python:
+    
+    # Colors #############################################################
+
+    # The Default Style ###################################################
+
+    # Text properties.
+    style.default.font = "DejaVuSans.ttf"
+    style.default.language = "unicode"
+    style.default.antialias = True
+    style.default.size = 22
+    style.default.color = (255, 255, 255, 255)
+    style.default.black_color = (0, 0, 0, 255)
+    style.default.bold = False
+    style.default.italic = False
+    style.default.underline = False
+    style.default.strikethrough = False
+    style.default.kerning = 0.0
+    style.default.drop_shadow = None
+    style.default.drop_shadow_color = (0, 0, 0, 255)
+    style.default.outlines = [ ]
+    style.default.minwidth = 0
+    style.default.text_align = 0
+    style.default.justify = False
+    style.default.text_y_fudge = 0
+    style.default.first_indent = 0
+    style.default.rest_indent = 0
+    style.default.line_spacing = 0
+    style.default.line_leading = 0
+    style.default.line_overlap_split = 0
+    style.default.layout = "tex"
+    style.default.subtitle_width = 0.9
+    style.default.slow_cps = None
+    style.default.slow_cps_multiplier = 1.0
+    style.default.slow_abortable = False
+    # style.default.hyperlink_functions (set in 00library.rpy)
+    
+    # Window properties.
+    style.default.background = None
+    style.default.xpadding = 0
+    style.default.ypadding = 0
+    style.default.xmargin = 0
+    style.default.ymargin = 0
+    style.default.xfill = False
+    style.default.yfill = False
+    style.default.xminimum = 0 # Includes margins and padding.
+    style.default.yminimum = 0 # Includes margins and padding.
+
+    # Placement properties.
+    style.default.xpos = None # 0
+    style.default.ypos = None # 0
+    style.default.xanchor = None # 0
+    style.default.yanchor = None # 0
+    style.default.xmaximum = None
+    style.default.ymaximum = None
+    style.default.xoffset = 0
+    style.default.yoffset = 0
+    style.default.subpixel = False
+    
+    # Sound properties.
+    style.default.sound = None
+
+    # Box properties.
+    style.default.spacing = 0
+    style.default.first_spacing = None
+    style.default.box_layout = None
+    style.default.box_wrap = False
+
+    # Focus properties.
+    style.default.focus_mask = None
+    style.default.focus_rect = None
+
+    # Bar properties.
+    style.default.fore_bar = Null()
+    style.default.aft_bar = Null()
+    style.default.thumb = None
+    style.default.thumb_shadow = None
+    style.default.left_gutter = 0
+    style.default.right_gutter = 0
+    style.default.thumb_offset = 0
+    style.default.unscrollable = None
+    
+    # Misc.
+    style.default.activate_sound = None
+    style.default.clipping = False
+
+    # Boxes.
+    style.hbox.box_layout = 'horizontal'
+    style.vbox.box_layout = 'vertical'
+
+    # Motions, zooms, rotozooms, and transforms.
+    style.motion.xanchor = 0
+    style.motion.yanchor = 0
+    style.motion.xpos = 0
+    style.motion.ypos = 0
+    
+    # Windows.
+    style.window.background = Solid((0, 0, 0, 192))
+    style.window.xpadding = 6
+    style.window.ypadding = 6
+    style.window.xmargin = 0
+    style.window.ymargin = 0
+    style.window.xfill = True
+    style.window.yfill = False
+    style.window.yminimum = 150 # Includes margins and padding.
+    style.window.xalign = 0.5
+    style.window.yalign = 1.0
+
+    # Dialogue
+    style.say_label.bold = True
+    style.say_vbox.spacing = 8
+
+    # Two window styles.
+    style.say_who_window.xminimum = 200
+    style.say_who_window.yminimum = 34
+    style.say_who_window.xfill = False
+    style.say_who_window.xalign = 0
+
+    style.say_two_window_vbox.yalign = 1.0
+
+    # Menus.
+    style.menu_choice.idle_color = "#0ff"
+    style.menu_choice.hover_color = "#ff0"
+    style.input.color = "#ff0"
+
+    # Styles used by centered.
+    style.centered_window.xalign = 0.5
+    style.centered_window.xfill = False                      
+    style.centered_window.yalign = 0.5
+    style.centered_window.yfill = False
+    style.centered_window.xpadding = 10
+
+    style.centered_text.textalign = 0.5
+    style.centered_text.xalign = 0.5
+    style.centered_text.yalign = 0.5
+    style.centered_text.layout = "subtitle"
+
+    # Hyperlinks.
+    style.hyperlink_text.underline = True
+    style.hyperlink_text.hover_color = "#0ff"
+    style.hyperlink_text.idle_color = "#08f"
+    
+    # Ruby.
+    style.ruby_text.size = 22
+    style.ruby_text.xoffset = 0
+    style.default.ruby_style = style.ruby_text
+    
+    # Bars.
+    style.default.bar_invert = False
+    style.default.bar_resizing = False
+    style.default.bar_vertical = False
+
+    style.vbar.bar_vertical = True
+    style.vslider.bar_vertical = True
+    style.vscrollbar.bar_vertical = True
+    style.vscrollbar.bar_invert = True
+
+    # Viewport
+    style.viewport.clipping = True
+
+    # Transform
+    style.transform.subpixel = True
+    
+    # Menu windows.
+    style.mm_root.background = "#000"
+    style.mm_root.xfill = True
+    style.mm_root.yfill = True
+
+    style.gm_root.background = "#000"
+    style.gm_root.xfill = True
+    style.gm_root.yfill = True
+
+    # Lists.
+    style.list_row.xfill = True
+
+    style.list_row.ymargin = 0
+    style.list_row.background = "#eee"
+    style.list_row[1].background = "#ddd"
+    style.list_row.hover_background = "#fff"
+    style.list_row[1].hover_background = "#fff"
+    style.list_row.selected_background = "#cce"
+    style.list_row[1].selected_background = "#cce"
+    style.list_text.color = "#000"
+    style.list_text.size = 14
+    style.list_spacer.xminimum = 15
+
+    # Tile
+    style.tile.clipping = True
+    
+    
+    ######################################################################
+
+    # Error messages.
+    style.error_root.background = Solid((220, 220, 255, 255))
+    style.error_root.xfill = True
+    style.error_root.yfill = True
+    style.error_root.xpadding = 20
+    style.error_root.ypadding = 20
+
+    style.error_title.color = (255, 128, 128, 255)
+    style.error_body.color = (128, 128, 255, 255)
+
+    

common/00stylepreferences.rpy

@@ -0,0 +1,170 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains code for the style preferences system, which allows
+# the user to define preferences that update styles. 
+
+init -1135 python:
+
+    # A map from preference name to list of (alternative, style, property, value) 
+    # tuples.
+    __preferences = { }
+
+    # A map from preference name to the list of alternatives for that preference.
+    __alternatives = { }
+
+    # Are style preferences dirty? If so, we need to update them at the start of
+    # the next operation.
+    __spdirty = object()
+    __spdirty.flag = True
+
+    # A map from preference name to alternative.
+    if persistent._style_preferences is None:      
+        persistent._style_preferences = { } 
+        
+
+    def __register_style_preference(preference, alternative, style, property, value):
+        """
+        :doc: style_preferences
+        :name: renpy.register_style_preference
+        
+        Registers information about an alternative for a style preference.
+        
+        `preference`
+            A string, the name of the style property.
+        
+        `alternative`
+            A string, the name of the alternative.
+        
+        `style`
+            The style that will be updated. This may be a style object or a string giving the style name.
+        
+        `property`
+            A string giving the name of the style property that will be update.
+        
+        `value`
+            The value that will be assigned to the style property.
+        """
+
+        if preference not in __preferences:
+            __preferences[preference] = [ ]
+            __alternatives[preference] = [ ]
+            
+        if alternative not in __alternatives:
+            __alternatives[preference].append(alternative)
+            
+        __preferences[preference].append((alternative, style, property, value))
+        
+    def __init():
+        """
+        Called at the end of the init phase, to ensure that each preference
+        has a valid value.
+        """
+        
+        for preference, alternatives in __alternatives.iteritems():
+            alt = persistent._style_preferences.get(preference, None)
+            
+            if alt not in alternatives:
+                persistent._style_preferences[preference] = alternatives[0]
+                
+    def __update():
+        """
+        Called at least once per interaction, to update the styles if necessary.
+        """
+    
+        if not __spdirty.flag:
+            return
+            
+        for preference, alternatives in __preferences.iteritems():
+
+            alt = persistent._style_preferences.get(preference, None)
+
+            for alternative, style, property, value in alternatives:
+                if alternative == alt:
+                    setattr(style, property, value)
+                    
+        renpy.style.rebuild()
+        
+        __spdirty.flag = False
+        
+    def __check(preference, alternative=None):
+        
+        if preference not in __alternatives:
+            raise Exception("{0} is not a known style preference.".format(preference))
+        
+        if alternative is not None:        
+            if alternative not in __alternatives[preference]:           
+                raise Exception("{0} is not a known alternative for style preference {1}.".format(alternative, preference))
+    
+        
+    def __set_style_preference(preference, alternative):
+        """
+        :doc: style_preferences
+        :name: renpy.set_style_preference
+        
+        Sets the selected alternative for the style preference.
+    
+        `preference`
+            A string giving the name of the style preference.
+    
+        `alternative`
+            A string giving the name of the alternative.
+        """
+        
+        __check(preference, alternative)
+        
+        persistent._style_preferences[preference] = alternative
+        __spdirty.flag = True
+        
+        renpy.restart_interaction()
+        
+    def __get_style_preference(preference):
+        """
+        :doc: style_preferences
+        :name: renpy.get_style_preference
+        
+        Returns a string giving the name of the selected alternative for the named style preference. 
+    
+        `preference`
+            A string giving the name of the style preference.
+        """
+    
+        __check(preference)
+        
+        return persistent._style_preferences[preference]
+        
+    class StylePreference(Action):
+        """
+        :doc: style_preferences
+        
+        An action that causes `alternative` to become the selected alternative for the given style preference.
+    
+        `preference`
+            A string giving the name of the style preference.
+    
+        `alternative`
+            A string giving the name of the alternative.        
+        """
+                
+        def __init__(self, preference, alternative):
+            
+            __check(preference, alternative)
+            
+            self.preference = preference
+            self.alternative = alternative
+            
+        def __call__(self):
+            __set_style_preference(self.preference, self.alternative)
+            
+        def get_selected(self):
+            return __get_style_preference(self.preference) == self.alternative
+    
+    renpy.register_style_preference = __register_style_preference
+    renpy.set_style_preference = __set_style_preference
+    renpy.get_style_preference = __get_style_preference
+    
+    config.interact_callbacks.append(__update)
+    
+init 1135 python:
+    
+    __init()

common/00voice.rpy

@@ -0,0 +1,131 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This extra contains a basic implementation of voice support. Right
+# now, voice is given its own toggle, and can either be turned on or
+# turned off. In the future, we'll probably provide some way of
+# toggling it on or off for individual characters.
+#
+# To use it, place a voice "<sndfile>" line before each voiced line of
+# dialogue.
+#
+#     voice "e_1001.ogg"
+#     e "Voice support lets you add the spoken word to your games."
+#
+# Normally, a voice is cancelled at the start of the next
+# interaction. If you want a voice to span interactions, call
+# voice_sustain.
+#
+#     voice "e_1002.ogg"
+#     e "Voice sustain is a technique that allows the same voice file.."
+#
+#     $ voice_sustain()
+#     e "...to play for two lines of dialogue."
+
+init -1120:
+
+    python:
+
+        _voice = object()
+        _voice.play = None
+        _voice.sustain = False
+        _voice.seen_in_lint = False
+
+        # Call this to specify the voice file that will be played for
+        # the user.
+        def voice(file, **kwargs):
+
+            if not config.has_voice:
+                return
+            
+            _voice.play = file
+            _last_voice_play = file 
+            
+        # Call this to specify that the currently playing voice file
+        # should be sustained through the current interaction.
+        def voice_sustain(ignored="", **kwargs):
+            if not config.has_voice:
+                return
+            
+            _voice.sustain = True
+
+        # Call this to replay the last bit of voice.
+        def voice_replay():
+            renpy.sound.play(_last_voice_play, channel="voice")
+
+        # Returns true if we can replay the voice.
+        def voice_can_replay():
+            return _last_voice_play != None
+            
+    python hide:
+
+        # basics: True if the game will have voice.
+        config.has_voice = True
+
+        # This is called on each interaction, to ensure that the
+        # appropriate voice file is played for the user.        
+        def voice_interact():
+            
+            if not config.has_voice:
+                return
+            
+            if _voice.play and not config.skipping:
+                renpy.sound.play(_voice.play, channel="voice")
+                store._last_voice_play = _voice.play        
+            elif not _voice.sustain:
+                renpy.sound.stop(channel="voice")
+                store._last_voice_play = _voice.play        
+
+            _voice.play = None
+            _voice.sustain = False
+        
+        config.start_interact_callbacks.append(voice_interact)
+        config.say_sustain_callbacks.append(voice_sustain)
+
+        def voice_afm_callback():
+            return not renpy.sound.is_playing(channel="voice")
+
+        config.afm_callback = voice_afm_callback
+                       
+python early hide:
+
+    def parse_voice(l):
+        fn = l.simple_expression()
+        if fn is None:
+            renpy.error('expected simple expression (string)')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return fn
+
+    def execute_voice(fn):
+        fn = eval(fn)
+        voice(fn)
+
+    def lint_voice(fn):
+        _voice.seen_in_lint = True
+
+        fn = _try_eval(fn, 'voice filename')
+        if isinstance(fn, basestring) and not renpy.loadable(fn):
+            renpy.error('voice file %r is not loadable' % fn)
+
+    renpy.statements.register('voice',
+                              parse=parse_voice,
+                              execute=execute_voice,
+                              lint=lint_voice)
+
+    def parse_voice_sustain(l):
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return None
+
+    def execute_voice_sustain(parsed):
+        voice_sustain()
+
+    renpy.statements.register('voice sustain',
+                              parse=parse_voice_sustain,
+                              execute=execute_voice_sustain)
+
+

common/DejaVuSans.txt

@@ -0,0 +1,99 @@
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
+
+Bitstream Vera Fonts Copyright
+------------------------------
+
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is
+a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license ("Fonts") and associated
+documentation files (the "Font Software"), to reproduce and distribute the
+Font Software, including without limitation the rights to use, copy, merge,
+publish, distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright and trademark notices and this permission notice shall
+be included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional glyphs or characters may be added to the Fonts, only if the fonts
+are renamed to names not containing either the words "Bitstream" or the word
+"Vera".
+
+This License becomes null and void to the extent applicable to Fonts or Font
+Software that has been modified and is distributed under the "Bitstream
+Vera" names.
+
+The Font Software may be sold as part of a larger software package but no
+copy of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
+ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE
+FONT SOFTWARE.
+
+Except as contained in this notice, the names of Gnome, the Gnome
+Foundation, and Bitstream Inc., shall not be used in advertising or
+otherwise to promote the sale, use or other dealings in this Font Software
+without prior written authorization from the Gnome Foundation or Bitstream
+Inc., respectively. For further information, contact: fonts at gnome dot
+org. 
+
+Arev Fonts Copyright
+------------------------------
+
+Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the fonts accompanying this license ("Fonts") and
+associated documentation files (the "Font Software"), to reproduce
+and distribute the modifications to the Bitstream Vera Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be included in all copies of one or more of the Font Software
+typefaces.
+
+The Font Software may be modified, altered, or added to, and in
+particular the designs of glyphs or characters in the Fonts may be
+modified and additional glyphs or characters may be added to the
+Fonts, only if the fonts are renamed to names not containing either
+the words "Tavmjong Bah" or the word "Arev".
+
+This License becomes null and void to the extent applicable to Fonts
+or Font Software that has been modified and is distributed under the 
+"Tavmjong Bah Arev" names.
+
+The Font Software may be sold as part of a larger software package but
+no copy of one or more of the Font Software typefaces may be sold by
+itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+Except as contained in this notice, the name of Tavmjong Bah shall not
+be used in advertising or otherwise to promote the sale, use or other
+dealings in this Font Software without prior written authorization
+from Tavmjong Bah. For further information, contact: tavmjong @ free
+. fr.
+
+$Id: LICENSE 2133 2007-11-28 02:46:28Z lechimp $

common/Vera.txt

@@ -1,55 +0,0 @@
-This package was debianized by Michael Fedrowitz <michaelf@debian.org>
-on Sun, 23 Feb 2003.
-
-It was downloaded from
-'http://ftp.gnome.org/pub/GNOME/sources/ttf-bitstream-vera/'.
-
-Upstream Author: Bitstream, Inc.
-
-Copyright:
-
-   Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream
-   Vera is a trademark of Bitstream, Inc.
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of the fonts accompanying this license ("Fonts") and associated
-   documentation files (the "Font Software"), to reproduce and distribute
-   the Font Software, including without limitation the rights to use,
-   copy, merge, publish, distribute, and/or sell copies of the Font
-   Software, and to permit persons to whom the Font Software is furnished
-   to do so, subject to the following conditions:
-
-   The above copyright and trademark notices and this permission notice
-   shall be included in all copies of one or more of the Font Software
-   typefaces.
-
-   The Font Software may be modified, altered, or added to, and in
-   particular the designs of glyphs or characters in the Fonts may be
-   modified and additional glyphs or characters may be added to the
-   Fonts, only if the fonts are renamed to names not containing either
-   the words "Bitstream" or the word "Vera".
-
-   This License becomes null and void to the extent applicable to Fonts
-   or Font Software that has been modified and is distributed under the
-   "Bitstream Vera" names.
-
-   The Font Software may be sold as part of a larger software package but
-   no copy of one or more of the Font Software typefaces may be sold by
-   itself.
-
-   THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-   OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
-   BITSTREAM OR THE GNOME FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR
-   OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL,
-   OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-   OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT
-   SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
-
-   Except as contained in this notice, the names of Gnome, the Gnome
-   Foundation, and Bitstream Inc., shall not be used in advertising or
-   otherwise to promote the sale, use or other dealings in this Font
-   Software without prior written authorization from the Gnome Foundation
-   or Bitstream Inc., respectively. For further information, contact:
-   fonts at gnome dot org.

common/_compat/gamemenu.rpym

@@ -0,0 +1,504 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    ######################################################################
+    # First up, we define a bunch of configuration variable, which the
+    # user can change.
+
+    # The contents of the game menu choices.
+    config.game_menu = [
+            ( "return", u"Return", ui.jumps("_return"), 'True'),
+            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context()._main_menu'),
+            ( "prefs", u"Preferences", _intra_jumps("_prefs_screen", "intra_transition"), 'True' ),
+            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context()._main_menu' ),
+            ( "load", u"Load Game", _intra_jumps("_load_screen", "intra_transition"), 'True'),
+            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context()._main_menu' ),
+            ( "quit", u"Quit", lambda : _quit_prompt("quit"), 'True' ),
+            ]
+
+    # If not None, a map from the names of the game menu
+    # navigation buttons to new fixed positions for them on
+    # the screen.
+    config.game_menu_positions = None
+
+    # The number of columns of files to show at once.
+    config.file_page_cols = 2
+
+    # The number of rows of files to show at once.
+    config.file_page_rows = 5
+
+    # The number of pages to add quick access buttons for.
+    config.file_quick_access_pages = 5
+
+    # The positions of file picker components.
+    config.file_picker_positions = None
+
+    
+    # This lets us disable the file pager. (So we only have one
+    # page of files.)
+    config.disable_file_pager = False
+
+    # This lets us disable the thumbnails in the file pager.
+    config.disable_thumbnails = False
+
+    # How we format time.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format loade_save slot formats.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # If True, we will be prompted before loading a game. (This can
+    # be changed from inside the game code, so that one can load from
+    # the first few screens but not after that.)
+    _load_prompt = True
+
+    
+    _game_menu_screen = "_save_screen"
+
+    ######################################################################
+    # Next, support code.
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    _scratch = object()
+
+    # This returns a window containing the game menu navigation
+    # buttons, set up to jump to the appropriate screen sections.
+    #
+    # This can be overridden by user code. It's called with the
+    # name of the selected screen... one of "mainmenu", "prefs",
+    # "save", "load", or "quit", at least for the default game
+    # menu. If None, then it's an indication that none of the
+    # nav buttons should be shown.
+    def _game_nav(screen, buttons=True):
+
+        global _screen
+        _screen = screen
+
+        ui.add(renpy.Keymap(toggle_fullscreen = renpy.toggle_fullscreen))
+        ui.add(renpy.Keymap(game_menu=ui.jumps("_noisy_return")))
+
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if not screen:
+            return
+
+        if not config.game_menu_positions:
+            ui.window(style='gm_nav_frame')
+            ui.vbox(focus='gm_nav', style='gm_nav_vbox')
+
+        for i, (key, label, clicked, enabled) in enumerate(config.game_menu):
+
+            disabled = False
+
+            if not eval(enabled):
+                disabled = True
+                clicked = None
+
+            if config.game_menu_positions:
+                kwargs = config.game_menu_positions.get(label, { })
+            else:
+                kwargs = { }
+
+            _button_factory(label, "gm_nav",
+                            selected=(key==screen),
+                            disabled=disabled,
+                            clicked=clicked,
+                            properties=kwargs)
+
+        if not config.game_menu_positions:
+            ui.close()
+
+    # This is called from the game menu to interact with the
+    # user.  It suppresses all of the underlays and overlays.
+    def _game_interact():
+
+        return ui.interact(suppress_underlay=True,
+                           suppress_overlay=True,
+                           mouse="gamemenu")
+
+
+    # This renders a slot with a file in it, in the file picker.
+    def _render_savefile(index, name, filename, extra_info, screenshot, mtime, newest, clickable, **positions):
+
+        if clickable:
+            clicked = ui.returns(("return", (filename, True)))
+        else:
+            clicked = None
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  **positions)
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.add(screenshot)
+
+        if newest:
+            ui.text(name + ". ", style=style.file_picker_new[index])
+        else:
+            ui.text(name + ". ", style=style.file_picker_old[index])
+
+
+        s = config.file_entry_format % dict(
+            time=renpy.time.strftime(config.time_format,
+                                     renpy.time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.text(s, style=style.file_picker_extra_info[index])
+
+        ui.close()
+
+    # This renders an empty slot in the file picker.
+    def _render_new_slot(index, name, filename, clickable, **positions):
+
+        if clickable:
+            clicked=ui.returns(("return", (filename, False)))
+            enable_hover = True
+        else:
+            clicked = None
+            enable_hover = True
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  enable_hover=enable_hover,
+                  **positions)
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.null(width=config.thumbnail_width,
+                    height=config.thumbnail_height)
+
+
+        ui.text(name + ". ", style=style.file_picker_old[index])
+
+        ui.text(_(u"Empty Slot."), style=style.file_picker_empty_slot[index])
+        ui.close()
+
+    _scratch.file_picker_page = None
+
+    # The names of the various pages that the file picker knows
+    # about.
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append("Auto")
+
+        if config.has_quicksave:
+            rv.append("Quick")
+
+        for i in range(1, config.file_quick_access_pages + 1):
+            rv.append(str(i))
+
+        return rv
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = config.file_page_cols * config.file_page_rows
+        rv = [ ]
+
+        if config.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), "a" + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if config.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), "q" + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = config.file_page_cols * config.file_page_rows
+
+        base = 0
+
+        if config.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if config.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        return base + int((int(filename) - 1) / per_page)
+
+
+    def _file_picker_process_screenshot(s):
+        return s
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(selected, save):
+
+        # The number of slots in a page.
+        file_page_length = config.file_page_cols * config.file_page_rows
+
+        saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+        newest = None
+        newest_mtime = None
+        save_info = { }
+
+        for fn, extra_info, screenshot, mtime in saved_games:
+            screenshot = _file_picker_process_screenshot(screenshot)
+            save_info[fn] = (extra_info, screenshot, mtime)
+
+            if not fn.startswith("auto-") and mtime > newest_mtime:
+                newest = fn
+                newest_mtime = mtime
+
+        if config.file_picker_positions:
+            positions = config.file_picker_positions
+        else:
+            positions = { }
+
+        # The index of the first entry in the page.
+        fpp = _scratch.file_picker_page
+
+        if fpp is None:
+
+            if newest:
+                fpp = _file_picker_file_page(newest)
+            else:
+                fpp = _file_picker_file_page("1")
+
+
+        while True:
+
+            if fpp < 0:
+                fpp = 0
+
+            _scratch.file_picker_page = fpp
+
+            # Show navigation
+            _game_nav(selected)
+
+            if not config.file_picker_positions:
+
+                ui.window(style='file_picker_frame')
+                ui.vbox(style='file_picker_frame_vbox') # whole thing.
+
+            if not config.disable_file_pager:
+
+                ### file_picker_navbox thick_hbox
+                # (box) The box containing the naviation (next/previous)
+                # buttons in the file picker.
+
+                ### file_picker_nav_button menu_button
+                # (window, hover) The style that is used for enabled file
+                # picker navigation buttons.
+
+                ### file_picker_nav_button_text menu_button_text
+                # (text) The style that is used for the label of enabled
+                # file picker navigation buttons.
+
+                # Draw the navigation.
+                if not config.file_picker_positions:
+                    ui.hbox(style='file_picker_navbox') # nav buttons.
+
+                def tb(cond, label, clicked, selected):
+                    _button_factory(label,
+                                    "file_picker_nav",
+                                    disabled=not cond,
+                                    clicked=clicked,
+                                    selected=selected,
+                                    properties=positions.get("nav_" + label, { }))
+
+                # Previous
+                tb(fpp > 0, _(u'Previous'), ui.returns(("fppdelta", -1)), selected=False)
+    
+                # Quick Access
+                for i, name in enumerate(_file_picker_pages()):
+                    tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+                # Next
+                tb(True, _(u'Next'), ui.returns(("fppdelta", +1)), False)
+
+                # Done with nav buttons.
+                if not config.file_picker_positions:
+                    ui.close()
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                place = positions.get("entry_" + str(offset + 1), { })
+
+                if filename not in save_info:
+                    clickable = save and not ro
+
+                    _render_new_slot(offset, name, filename, clickable, **place)
+                else:
+                    clickable = not save or not ro
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(offset, name, filename, extra_info, screenshot,
+                                     mtime, newest == filename, clickable, **place)
+
+            if not config.file_picker_positions:
+                ui.grid(config.file_page_cols,
+                        config.file_page_rows,
+                        style='file_picker_grid',
+                        transpose=True) # slots
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            if not config.file_picker_positions:                    
+                ui.close() # slots
+                ui.close() # whole thing
+
+            result = _game_interact()
+            type, value = result
+
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+    # This renders a yes/no prompt, as part of the game menu. If
+    # screen is None, then it omits the game menu navigation. 
+    def _yesno_prompt(screen, message):
+        """
+        @param screen: The screen button that should be highlighted when this prompt is shown. If None, then no game menu navigation is shown.
+
+        @param message: The message that is shown to the user to prompt them to answer yes or no.
+
+        This function returns True if the user clicks Yes, or False if the user clicks No.
+        """
+
+        renpy.transition(config.intra_transition)
+
+        _game_nav(screen)
+
+        ui.window(style='yesno_frame')
+        ui.vbox(style='yesno_frame_vbox')
+
+        _label_factory(message, "yesno")
+
+        ui.hbox(style='yesno_button_hbox')
+        
+        # The extra nulls are because we want equal whitespace surrounding
+        # the two buttons. It should work as long as we have xfill=True
+        _button_factory(u"Yes", 'yesno', clicked=ui.returns(True))
+        _button_factory(u"No", 'yesno', clicked=ui.returns(False))
+
+        ui.close()
+        ui.close()
+
+        rv =  _game_interact()
+        renpy.transition(config.intra_transition)
+        return rv
+
+    config.old_names["Are you sure you want to quit?"] = "Are you sure you want to quit the game?"
+
+    def _quit_prompt(screen="quit"):
+
+        def prompt():
+           return _yesno_prompt(screen, u"Are you sure you want to quit?")
+
+        if renpy.invoke_in_new_context(prompt):
+            renpy.quit()
+        else:
+            return
+
+    config.old_names["Are you sure you want to return to the main menu?\nThis will lose unsaved progress."] = "Are you sure you want to return to the main menu?\nThis will end your game."
+
+    def _mainmenu_prompt(screen="mainmenu"):
+
+        def prompt():
+           return _yesno_prompt(screen, u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress.")
+
+        if renpy.invoke_in_new_context(prompt):
+            renpy.full_restart(transition=config.game_main_transition)
+        else:
+            return
+        
+label _compat_confirm_quit:
+    $ _quit_prompt(None)
+    return
+
+
+init -1160:
+    $ config.old_names["Loading will lose unsaved progress.\nAre you sure you want to do this?"] = "Loading a new game will end your current game.\nAre you sure you want to do this?"
+
+label _load_screen:
+
+    if renpy.has_label("_load_screen_hook"):
+        call expression "_load_screen_hook" from _call__load_screen_hook
+    
+    python hide:
+
+        fn, exists = _file_picker("load", False )
+
+        if not renpy.context()._main_menu and _load_prompt:
+            if _yesno_prompt("load", u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                renpy.load(fn)
+        else:                        
+            renpy.load(fn)
+
+    jump _load_screen
+
+label _save_screen:
+    
+    if renpy.has_label("_save_screen_hook"):
+        call expression "_save_screen_hook" from _call__save_screen_hook
+
+    $ _fn, _exists = _file_picker("save", True)
+
+    if not _exists or _yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+        python hide:
+
+            if save_name:
+                full_save_name = save_name
+            else:
+                full_save_name = ""
+
+            try:
+                renpy.save(_fn, full_save_name)
+
+            except Exception, e:
+
+                if config.debug:
+                    raise
+                
+                message = ( _(u"The error message was:") + "\n\n" + 
+                            e.__class__.__name__  + ": " + unicode(e) + "\n\n" +
+                            _(u"You may want to try saving in a different slot, or playing for a while and trying again later.") )
+
+                _show_exception(_(u"Save Failed."), message)
+                
+                
+    jump _save_screen

common/_compat/library.rpym

@@ -0,0 +1,112 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init:
+    python:
+
+        # A dict of 5-tuples mapping button labels to image buttons.
+        config.image_buttons = { }
+
+        # A dict mapping label to image.
+        config.image_labels = { }
+
+        # Maps from button or label to additional properties.
+        config.button_properties = { }
+        config.button_text_properties = { }
+        config.label_properties = { }
+
+        def _button_factory(label,
+                            type=None,
+                            selected=None,
+                            disabled=False,
+                            clicked=None,
+                            properties={},
+                            index=None,
+                            **props):
+            """
+            This function is called to create the various buttons used
+            in the game menu. By overriding this function, one can
+            (for example) replace the default textbuttons with image buttons.
+            When it is called, it's expected to add a button to the screen.
+
+            @param label: The label of this button, before translation. 
+
+            @param type: The type of the button. One of "mm" (main menu),
+            "gm_nav" (game menu), "file_picker_nav", "yesno", or "prefs".
+
+            @param selected: True if the button is selected, False if not,
+            or None if it doesn't matter.
+
+            @param disabled: True if the button is disabled, False if not.
+
+            @param clicked: A function that should be executed when the
+            button is clicked.
+
+            @param properties: Addtional layout properties.
+            """
+
+            props.update(properties)
+            props.update(config.button_properties.get(label, { }))
+            
+            if disabled:
+                clicked = None
+
+            if selected and not disabled:
+                role = "selected_"
+            else:
+                role = ""
+
+                
+            if label in config.image_buttons:
+                
+                (idle, hover, sel_idle, sel_hover, disabled) = config.image_buttons[label]
+
+                ui.imagebutton(idle,
+                               hover,
+                               disabled,
+                               hover,
+                               sel_idle,
+                               sel_hover,
+                               disabled,
+                               sel_hover,
+                               clicked=clicked,
+                               style=style.image_button[label],
+                               role=role,
+                               **props)
+                
+                return
+
+            button_style = type + "_button"
+            text_style = type + "_button_text"
+
+            if index is None:
+                index = label
+            
+            button_style = getattr(style, button_style)[index]
+            text_style = getattr(style, text_style)[index]
+            
+            ui.button(style=button_style, clicked=clicked, role=role, **props)
+            ui.text(_(label), style=text_style, **config.button_text_properties.get(label, { }))
+            
+        def _label_factory(label, type, properties={}, **props):
+            """
+            This function is called to create a new label. It can be
+            overridden by the user to change how these labels are created.
+
+            @param label: The label of the box.
+
+            @param type: "prefs" or "yesno". (perhaps more by now.)
+
+            @param properties: This may contain position properties.
+            """
+
+            props.update(properties)
+            props.update(config.label_properties.get(label, { }))
+
+            if label in config.image_labels:
+                ui.image(config.image_labels[label], **props)
+                return
+
+            style = getattr(store.style, type + "_label")[label]
+            
+            ui.text(_(label), style=style, **props)

common/_compat/mainmenu.rpym

@@ -0,0 +1,62 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1170 python hide:
+
+    config.old_names['Quit'] = 'Quit Game'
+
+    # The contents of the main menu.
+    config.main_menu = [
+        ( u"Start Game", "start", 'True'),
+        ( u"Continue Game", _intra_jumps("_load_screen", "main_game_transition"), 'True' ),
+        ( u"Preferences", _intra_jumps("_prefs_screen", "main_game_transition"), 'True' ),
+        ( u"Quit",  ui.jumps("_quit"), 'True' ),
+        ]
+
+    # If not None, this is used to fix the positions of the
+    # things in the main menu.
+    config.main_menu_positions = None
+
+    # Styles used in this file.
+
+# This is the default main menu, which we get if the user hasn't
+# defined his own, or if that function calls this explicitly.        
+label _library_main_menu:
+
+    python hide:
+
+        ui.add(renpy.Keymap(toggle_fullscreen = renpy.toggle_fullscreen))
+
+        ui.window(style='mm_root')
+        ui.null()
+
+        if not config.main_menu_positions:
+            ui.window(style='mm_menu_frame')
+            ui.vbox(style='mm_menu_frame_vbox')
+
+        for i, (text, clicked, enabled) in enumerate(config.main_menu):
+
+            if isinstance(clicked, basestring):
+                clicked = ui.jumpsoutofcontext(clicked)
+
+            if config.main_menu_positions:
+                kwargs = config.main_menu_positions.get(text, { })
+            else:
+                kwargs = { }
+
+            if not eval(enabled):
+                clicked = None
+                disabled = True
+            else:
+                disabled = False
+
+            _button_factory(text, "mm", clicked=clicked, disabled=disabled, properties=kwargs)
+
+        if not config.main_menu_positions:
+            ui.close()
+
+        store._result = ui.interact(suppress_overlay=True,
+                                    suppress_underlay=True,
+                                    mouse="mainmenu")
+
+    jump _main_menu

common/_compat/preferences.rpym

@@ -0,0 +1,607 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2012 Tom Rothamel
+#
+# Please see the LICENSE.txt distributed with Ren'Py for permission to
+# copy and modify.
+
+# This file contains the code to implement the Ren'Py preferences
+# screen.
+
+init python:
+
+    # This is a map from the name of the style that is applied to
+    # a list of preferences that should be placed into a vbox
+    # with that style.
+    config.preferences = { }
+
+    # Ditto, for joystick preferences.
+    config.joystick_preferences = { }
+
+    # Positions for preferences... overrides the above.
+    config.preference_positions = None
+    config.joystick_preference_positions = None
+
+    # This is a map from preference name to that preference
+    # object, that can be used in rearranging preferences.
+    config.all_preferences = { }
+
+    # If true, the preference choices will be arranged in an
+    # hbox.
+    config.hbox_pref_choices = False
+
+    # A list of (readable name, synthetic key) tuples
+    # corresponding to joystick events.
+    config.joystick_keys = [
+        (u'Left', 'joy_left'),
+        (u'Right', 'joy_right'),
+        (u'Up', 'joy_up'),
+        (u'Down', 'joy_down'),
+        (u'Select/Dismiss', 'joy_dismiss'),
+        (u'Rollback', 'joy_rollback'),
+        (u'Hold to Skip', 'joy_holdskip'),
+        (u'Toggle Skip', 'joy_toggleskip'),
+        (u'Hide Text', 'joy_hide'),
+        (u'Menu', 'joy_menu'),
+        ]
+
+    # If True, then we can always get into the joystick
+    # preferences.
+    config.always_has_joystick = False
+
+    
+    def _prefs_screen_run(prefs_map, positions):
+
+
+        _game_nav("prefs")
+
+        if positions is not None:
+            for name, pos in positions.iteritems():
+                ui.vbox(**pos)
+                config.all_preferences[name].render_preference()
+                ui.close()
+
+        else:
+
+            ### prefs_frame default
+            # (window) A window containing all preferences.
+
+            ui.window(style='prefs_frame')
+            ui.fixed()
+
+            for style, prefs in prefs_map.iteritems():
+
+                ui.vbox(style=style)
+                for i in prefs:
+                    i.render_preference()
+                ui.close()
+
+            ui.close()
+
+        _game_interact()
+
+
+    class _Preference(object):
+        """
+        This is a class that's used to represent a multiple-choice
+        preference.
+        """
+
+        def __init__(self, name, field, values, base=_preferences):
+            """
+            @param name: The name of this preference. It will be
+            displayed to the user.
+
+            @param variable: The field on the base object
+            that will be assigned the selected value. This field
+            must exist.
+
+            @param values: A list of value name, value, condition
+            triples. The value name is the name of this value that
+            will be shown to the user. The value is the literal
+            python value that will be assigned if this value is
+            selected. The condition is a condition that will be
+            evaluated to determine if this is a legal value. If no
+            conditions are true, this preference will not be
+            displayed to the user. A condition of None is always
+            considered to be True.
+
+            @param base: The base object on which the variable is
+               read from and set. This defaults to _preferences,
+               the user preferences object.
+            """
+
+            self.name = name
+            self.field = field
+            self.values = values
+            self.base = base
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+            values = [ (name, val) for name, val, cond in self.values
+                       if cond is None or renpy.eval(cond) ]
+
+            if not values:
+                return
+
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            ### prefs_hbox default
+            # If config.hbox_pref_choices is True, the style
+            # of the hbox containing the choices.
+
+            if config.hbox_pref_choices:
+                ui.hbox(style=style.prefs_hbox[self.name])
+
+            for name, value in values:
+
+                ### prefs_button menu_button
+                # (window, hover) The style of an unselected preferences
+                # button.
+
+                ### prefs_button_text menu_button_text
+                # (text, hover) The style of the text of an unselected
+                # preferences button.
+
+                def clicked(value=value):
+                    setattr(self.base, self.field, value)
+                    return True
+
+                _button_factory(name, "prefs",
+                                selected=cur==value,
+                                clicked=clicked)
+
+            if config.hbox_pref_choices:
+                ui.close()
+
+            ui.close()
+
+
+    class _VolumePreference(object):
+        """
+        This represents a preference that controls one of the
+        volumes in the system. It is represented as a slider bar,
+        and a button that can be pushed to play a sample sound on
+        a channel.
+        """
+
+        def __init__(self, name, mixer, enable='True', sound='None', channel=0):
+            """
+            @param name: The name of this preference, as shown to the user.
+
+            @param mixer: The mixer this preference controls.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+
+            @param sound: A string that is evaluated to yield
+            another string. The yielded string is expected to give
+            a sound file, which is played as the sample sound. (We
+            apologize for the convolution of this.)
+
+            @param channel: The number of the channel the sample
+            sound is played on.                
+            """
+
+            self.name = name
+            self.mixer = mixer
+            self.enable = enable
+            self.sound = sound
+            self.channel = channel
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not eval(self.enable):
+                return
+
+            sound = eval(self.sound)
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            def changed(v):
+
+                _preferences.set_volume(self.mixer, v / 128.0)
+                
+            ui.bar(128,
+                   int(_preferences.get_volume(self.mixer) * 128),
+                   changed=changed,
+                   style=style.prefs_volume_slider[self.name])
+
+            if sound:
+                def clicked():
+                    renpy.sound.play(sound, channel=self.channel)
+
+                _button_factory(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            ui.close()
+
+    class _SliderPreference(object):
+        """
+        A class that represents a preference that is controlled by a
+        slider.
+        """
+
+        def __init__(self, name, range, get, set, enable='True'):
+            """
+            @param set: The name of this preference, that is shown to the user.
+
+            @param range: An integer giving the maximum value of
+            this slider. The slider goes from 0 to range.
+
+            @param get: A function that's called to get the
+            initial value of the slider. It's called with no
+            arguments, and should return an integet between 0 and
+            range, inclusive.
+
+            @param set: A function that's called when the value of
+            the slider is set by the user. It is called with a
+            single integer, in the range 0 to range, inclusive.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+            """
+
+            self.name = name
+            self.range = range
+            self.get = get
+            self.set = set
+            self.enable = enable
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not eval(self.enable):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            def changed(v):
+                self.set(v)
+
+            ### prefs_slider bar
+            # (bar) The style that is applied to preference
+            # sliders.
+
+            ui.bar(self.range,
+                   self.get(),
+                   changed=changed,
+                   style=style.prefs_slider[self.name])
+
+            ui.close()
+
+
+    class _PreferenceSpinner(object):
+        """
+        This is a class that's used to represent a preference
+        spinner, which is a preference that can be incremented
+        and decremented, when shown to the user.
+        """
+
+        def __init__(self, name, field, minimum, maximum, delta,
+                     cond = "True", render = lambda x : str(x),
+                     base=_preferences):
+            """
+            @param name: The name of this preference, that is presented
+            to the user.
+
+            @param field: The name of the field on the base object
+            that is updated by this spinner.
+
+            @param minimum: The minimum value that this spinner can set
+            the value to.
+
+            @param maximum: The maximum value that this spinner can set
+            the value to.
+
+            @param delta: The delta by which this spinner is
+            incremented or decremented.
+
+            @param cond: If this condition is not true, this spinner is
+            not shown.
+
+            @param render: This function is called with the value of
+            the field, and is expected to render that value to a
+            string.
+
+            @param base: The base object that this spinner updates
+            the field on. It defaults to _preferences, the preferences
+            object.
+            """
+
+            self.name = name
+            self.field = field
+            self.minimum = minimum
+            self.maximum = maximum
+            self.delta = delta
+            self.cond = cond
+            self.render = render
+            self.base = base
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not renpy.eval(self.cond):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            def minus_clicked():
+                value = cur - self.delta
+                value = max(self.minimum, value)
+                setattr(self.base, self.field, value)
+                return True
+
+            def plus_clicked():
+                value = cur + self.delta
+                value = min(self.maximum, value)
+                setattr(self.base, self.field, value)
+                return True
+
+            ui.hbox(style=style.prefs_spinner[self.name])
+            _button_factory("-", "prefs_spinner", clicked=minus_clicked)
+            _label_factory(self.render(cur), "prefs_spinner")
+            _button_factory("+", "prefs_spinner", clicked=plus_clicked)
+            ui.close()
+
+            ui.close()
+
+    def _joystick_select_binding():
+
+        for label, key in config.joystick_keys:
+
+            def my_clicked(label=label, key=key):
+                return (label, key)
+
+            _button_factory(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=my_clicked, index=label)
+        
+
+    def _joystick_get_binding():
+        ui.add(renpy.display.joystick.JoyBehavior())
+        ui.saybehavior()
+
+    def _joystick_take_binding(binding, key):
+
+        if not isinstance(binding, basestring):
+            if key in _preferences.joymap:
+                del _preferences.joymap[key]
+        else:
+            _preferences.joymap[key] = binding
+
+        
+            
+    class _JoystickPreference(object):
+
+        def __init__(self, name):
+            self.name = name
+            config.all_preferences[name] = self
+
+            
+        def render_preference(self):
+
+            def set_binding(label, key):
+                _game_nav(None)
+
+                ui.window(style='js_frame')
+                ui.vbox(style='js_frame_vbox')
+                _label_factory(_(u"Joystick Mapping") + " - " + _(label), "js_function")
+                _label_factory(u'Move the joystick or press a joystick button to create the mapping. Click the mouse to remove the mapping.', 'js_prompt')
+                ui.close()
+
+                _joystick_get_binding()
+                binding = _game_interact()
+                _joystick_take_binding(binding, key)
+                
+                return True
+                
+
+            ui.window(style='prefs_js_frame')
+            ui.vbox(style='prefs_js_vbox')
+            _label_factory(self.name, 'prefs')
+
+            for label, key in config.joystick_keys:
+
+                def clicked(label=label, key=key):
+                    return renpy.invoke_in_new_context(set_binding, label, key)
+
+                _button_factory(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=clicked, index=label)
+            
+            ui.close()
+            
+
+    class _JumpPreference(object):
+
+        def __init__(self, name, target, condition="True"):
+            self.name = name
+            self.target = target
+            self.condition = condition
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            ui.window(style=style.prefs_jump[self.name])
+
+            if eval(self.condition):
+                clicked=ui.jumps(self.target)
+            else:
+                clicked=None
+
+            _button_factory(self.name, 'prefs_jump', clicked=clicked)
+
+    def _remove_preference(name):
+        """
+        Removes the preference with the given name from the
+        preferences menu.
+        """
+
+        pref = config.all_preferences.get(name, None)
+        if not pref:
+            return
+
+        for k, v in config.preferences.iteritems():
+            if pref in v:
+                v.remove(pref)
+            
+init python hide:
+
+    # Enablers for some preferences.
+    config.has_music = True
+    config.has_sound = True
+    config.sample_sound = None
+    config.has_transitions = True
+    config.has_cps = True
+    config.has_afm = True
+    config.has_skipping = True
+    config.has_skip_after_choice = True
+
+
+    # Left
+
+    pl1 = _Preference(u'Display', 'fullscreen', [
+        (u'Window', False, None),
+        (u'Fullscreen', True, None),
+        ])
+
+    pl2 = _Preference(u'Transitions', 'transitions', [
+        (u'All', 2, 'config.has_transitions'),
+        (u'Some', 1, 'config.has_transitions and default_transition'),
+        (u'None', 0, 'config.has_transitions'),
+        ])
+
+    # Center
+
+    pc1 = _Preference(u'Skip', 'skip_unseen', [
+        (u'Seen Messages', False, 'config.allow_skipping and config.has_skipping'),
+        (u'All Messages', True, 'config.allow_skipping and config.has_skipping'),
+        ])
+
+    config.old_names['Skip'] = 'TAB and CTRL Skip'
+    config.all_preferences['TAB and CTRL Skip'] = pc1
+
+
+    pc2= _Preference(u'After Choices', 'skip_after_choices', [
+        (u'Stop Skipping', False, 'config.allow_skipping and config.has_skip_after_choice'),
+        (u'Keep Skipping', True, 'config.allow_skipping and config.has_skip_after_choice'),
+        ])
+
+    config.old_names['Keep Skipping'] = 'Continue Skipping' 
+
+    def cps_get():
+        cps = _preferences.text_cps
+        if cps == 0:
+            cps = 150
+        else:
+            cps -= 1
+        return cps
+
+    def cps_set(cps):
+        cps += 1
+        if cps == 151:
+            cps = 0
+        _preferences.text_cps = cps
+
+
+    pc3 = _SliderPreference(u'Text Speed', 150, cps_get, cps_set,
+                            'config.has_cps')
+
+
+    def afm_get():
+        afm = _preferences.afm_time
+        if afm == 0:
+            afm = 40
+        else:
+            afm -= 1
+        return afm
+
+    def afm_set(afm):
+        afm += 1
+        if afm == 41:
+            afm = 0
+        _preferences.afm_time = afm
+
+    pc4 = _SliderPreference(u'Auto-Forward Time', 40, afm_get, afm_set,
+                            'config.has_afm')
+
+    # Right
+
+    pr1 = _VolumePreference(u"Music Volume", 'music', 'config.has_music')
+    pr2 = _VolumePreference(u"Sound Volume", 'sfx', 'config.has_sound', 'config.sample_sound')
+
+    _JumpPreference(u'Joystick...', '_joystick_screen', 'renpy.display.joystick.enabled or config.always_has_joystick')
+
+    _JoystickPreference(u'Joystick Configuration')
+
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+    config.preferences['prefs_center'] = [
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        ]
+
+    config.joystick_preferences['prefs_joystick'] = [
+        config.all_preferences[u'Joystick Configuration'],
+        ]
+
+    config.sample_voice = None
+
+    vp = _VolumePreference(u'Voice Volume',
+                           'voice',
+                           'config.has_voice',
+                           'config.sample_voice',
+                           2)
+
+    config.preferences['prefs_right'].insert(1, vp)
+
+label _prefs_screen:
+
+    $ _prefs_screen_run(config.preferences, config.preference_positions)
+    
+    jump _prefs_screen
+    
+label _joystick_screen:    
+        
+    $ _prefs_screen_run(config.joystick_preferences, config.joystick_preference_positions)
+
+    jump _joystick_screen
+
+            
+                        
+
+                         
+                         

common/_compat/styles.rpym

@@ -0,0 +1,357 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    style.menu_button = Style(style.button, heavy=True, help='Buttons that are part of the main or game menus.')
+    style.menu_button_text = Style(style.button_text, heavy=True, help='The label of buttons that are part of the main or game menus.')
+    
+    style.thin_hbox = Style(style.hbox, heavy=True, help='A hbox with a small amount of spacing.')
+    style.thick_hbox = Style(style.hbox, heavy=True, help='A hbox with a large amount of spacing.')
+    style.thin_vbox = Style(style.vbox, heavy=True, help='A vbox with a small amount of spacing.')
+    style.thick_vbox = Style(style.vbox, heavy=True, help='A vbox with a large amount of spacing.')
+
+    style.mm_menu_frame = Style(style.default, heavy=True, help='The frame containing the main menu.')
+    style.mm_menu_frame_vbox = Style(style.thin_vbox, heavy=True, help='The vbox containing the main menu.')
+    style.mm_button = Style(style.menu_button, heavy=True, help='A main menu button.')
+    style.mm_button_text = Style(style.menu_button_text, heavy=True, help='A main menu button label.')
+    style.default.drop_shadow = (1, 1)
+
+    style.gm_nav_frame = Style(style.default, heavy=True, help='The frame containing the navigation buttons.')
+    style.gm_nav_vbox = Style(style.thin_vbox, heavy=True, help='The vbox containing the navigation buttons.')
+    style.gm_nav_button = Style(style.menu_button, heavy=True, help='A navigation button.')
+    style.gm_nav_button_text = Style(style.menu_button_text, heavy=True, help='A navigation button label.')
+
+    style.file_picker_entry = Style(style.menu_button, heavy=True, help='A button you click to save or load a file.')
+    style.file_picker_entry_box = Style(style.thin_hbox, heavy=True, help='The box inside that button.')
+    style.file_picker_text = Style(style.default, heavy=True, help='Base style for text inside a file picker entry.')
+    style.file_picker_new = Style(style.file_picker_text, heavy=True, help='The number of the newest file.')
+    style.file_picker_old = Style(style.file_picker_text, heavy=True, help='The number of non-newest files.')
+    style.file_picker_extra_info = Style(style.file_picker_text, heavy=True, help='Extra text (the date and save info) of a file.')
+    style.file_picker_empty_slot = Style(style.file_picker_text, heavy=True, help='The style of "Empty Slot" text.')
+    style.file_picker_frame = Style(style.default, heavy=True, help='The frame containing the file picker.')
+    style.file_picker_frame_vbox = Style(style.thin_vbox, heavy=True, help='The box containing file picker navigation and the file picker grid.')
+    style.file_picker_navbox = Style(style.thick_hbox, heavy=True, help='The box containing the file picker navigation buttons.')
+    style.file_picker_nav_button = Style(style.menu_button, heavy=True, help='A file picker navigation button.')
+    style.file_picker_nav_button_text = Style(style.menu_button_text, heavy=True, help='A file picker navigation button label.')
+    style.file_picker_grid = Style(style.default, heavy=True, help='The grid containing the entries in the file picker.')
+
+    style.yesno_frame = Style(style.default, heavy=True, help='The frame containing the yes/no dialog.')
+    style.yesno_frame_vbox = Style(style.thick_vbox, heavy=True, help='Separates the label from the buttons in a yes/no dialog.')
+    style.yesno_label = Style(style.default, heavy=True, help='The label of a yes/no dialog.')
+    style.yesno_button_hbox = Style(style.thick_hbox, heavy=True, help="The box containing the Yes and No buttons.")
+    style.yesno_button = Style(style.menu_button, heavy=True, help='A Yes/No button.')
+    style.yesno_button_text = Style(style.menu_button_text, heavy=True, help='A Yes/No button label.')
+
+
+    style.prefs_frame = Style(style.default, heavy=True, help='')
+    style.prefs_pref_frame = Style(style.default, heavy=True, help='')
+    style.prefs_pref_vbox = Style(style.thin_vbox, heavy=True, help='')
+    style.prefs_label = Style(style.default, heavy=True, help='')
+    style.prefs_hbox = Style(style.default, heavy=True, help='')
+    style.prefs_button = Style(style.menu_button, heavy=True, help='')
+    style.prefs_button_text = Style(style.menu_button_text, heavy=True, help='')
+    style.soundtest_button = Style(style.prefs_button, heavy=True, help='')
+    style.soundtest_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_slider = Style(style.bar, heavy=True, help='')
+    style.prefs_volume_slider = Style(style.prefs_slider, heavy=True, help='')
+    style.prefs_spinner = Style(style.default, heavy=True, help='')
+    style.prefs_spinner_label = Style(style.prefs_label, heavy=True, help='')
+    style.prefs_spinner_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_spinner_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_js_frame = Style(style.prefs_pref_frame, heavy=True, help='')
+    style.prefs_js_vbox = Style(style.prefs_pref_vbox, heavy=True, help='')
+    style.prefs_js_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_js_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.js_frame = Style(style.prefs_frame, heavy=True, help='')
+    style.js_frame_vbox = Style(style.thick_vbox, heavy=True, help='')
+    style.js_function_label = Style(style.prefs_label, heavy=True, help='')
+    style.js_prompt_label = Style(style.prefs_label, heavy=True, help='')
+    style.prefs_jump = Style(style.prefs_pref_frame, heavy=True, help='')
+    style.prefs_jump_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_jump_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_column = Style(style.default, heavy=True, help='')
+    style.prefs_left = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_center = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_right = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_joystick = Style(style.prefs_center, heavy=True, help='')
+
+    style.thin_hbox.spacing = 3
+    style.thick_hbox.spacing = 30
+    style.thin_vbox.spacing = 0
+    style.thick_vbox.spacing = 30
+
+    dark_cyan = (0, 192, 255, 255)
+    bright_cyan = (0, 255, 255, 255)
+    dark_red = (255, 128, 128, 255)
+    bright_red = (255, 64, 64, 255)
+    green = (0, 128, 0, 255)
+
+    # Frames.
+    style.frame.background = Solid((0, 0, 128, 128))
+    style.frame.xpadding = 10
+    style.frame.ypadding = 5
+    style.frame.xmargin = 10
+    style.frame.ymargin = 5
+
+
+    ######################################################################
+    # Buttons.
+
+    style.button_text.color = dark_cyan
+    style.button_text.hover_color = bright_cyan
+    style.button_text.insensitive_color = (192, 192, 192, 255)
+    style.button_text.size = 24
+    style.button_text.drop_shadow = (2, 2)        
+
+    style.button_text.selected_color = dark_red
+    style.button_text.selected_hover_color = bright_red
+
+    style.button_text.xpos = 0.5
+    style.button_text.xanchor = 0.5
+
+    style.menu_button.xpos = 0.5
+    style.menu_button.xanchor = 0.5
+
+
+    ######################################################################
+    # Bar.
+
+    style.bar.ymaximum = 22
+
+    style.bar.left_bar = Solid(bright_cyan)
+    style.bar.right_bar = Solid((0, 0, 0, 128))
+    style.bar.bottom_bar = Solid(bright_cyan)
+    style.bar.top_bar = Solid((0, 0, 0, 128))
+    style.bar.left_gutter = 0
+    style.bar.right_gutter = 0
+    style.bar.thumb = None
+    style.bar.thumb_offset = 0
+    style.bar.thumb_shadow = None
+
+    style.vbar.xmaximum = 22
+
+    style.vbar.left_bar = Solid(bright_cyan)
+    style.vbar.right_bar = Solid((0, 0, 0, 128))
+    style.vbar.bottom_bar = Solid(bright_cyan)
+    style.vbar.top_bar = Solid((0, 0, 0, 128))
+    style.vbar.left_gutter = 0
+    style.vbar.right_gutter = 0
+    style.vbar.bottom_gutter = 0
+    style.vbar.top_gutter = 0
+    style.vbar.thumb = None
+    style.vbar.thumb_offset = 0
+    style.vbar.thumb_shadow = None
+
+    style.vscrollbar.set_parent(style.vbar)
+    style.scrollbar.set_parent(style.bar)
+    
+    style.vscrollbar.bottom_bar = Solid((0, 0, 0, 128))        
+    style.vscrollbar.top_bar = Solid(bright_cyan) 
+
+    style.slider.ymaximum = 1
+    style.vslider.xmaximum = 1
+    
+    ######################################################################
+    # Main menu.
+
+    style.mm_menu_frame.xpos = 0.9
+    style.mm_menu_frame.xanchor = 1.0
+    style.mm_menu_frame.ypos = 0.9
+    style.mm_menu_frame.yanchor = 1.0
+
+
+    ######################################################################
+    # Game menu common.
+
+    style.gm_nav_frame.xpos = 0.95
+    style.gm_nav_frame.xanchor = 1.0
+    style.gm_nav_frame.ypos = 0.95
+    style.gm_nav_frame.yanchor = 1.0
+
+
+    ##############################################################################
+    # File picker.
+
+    style.file_picker_frame.xpos = 0
+    style.file_picker_frame.xanchor = 0.0
+    style.file_picker_frame.ypos = 0
+    style.file_picker_frame.yanchor = 0.0
+    style.file_picker_frame.xpadding = 5
+
+    style.file_picker_navbox.xpos = 10
+
+    style.file_picker_grid.xfill = True
+
+    style.file_picker_entry.xpadding = 5
+    style.file_picker_entry.ypadding = 2
+    style.file_picker_entry.xmargin = 5
+    style.file_picker_entry.xfill = True
+    style.file_picker_entry.ymargin = 2        
+    style.file_picker_entry.background = Solid((255, 255, 255, 255))
+    style.file_picker_entry.hover_background = Solid((255, 255, 192, 255))
+
+    style.file_picker_text.size = 16
+    style.file_picker_text.color = dark_cyan
+    style.file_picker_text.hover_color = bright_cyan
+
+    style.file_picker_new.hover_color = bright_red
+    style.file_picker_new.idle_color = dark_red
+
+    style.file_picker_new.minwidth = 40
+    style.file_picker_old.minwidth = 40
+
+    style.file_picker_new.text_align = 1.0
+    style.file_picker_old.text_align = 1.0
+
+
+    ######################################################################
+    # Yes/No Dialog
+
+    style.yesno_label.color = green
+    style.yesno_label.textalign = 0.5
+    style.yesno_label.xpos = 0.5
+    style.yesno_label.xanchor = 0.5
+
+    style.yesno_frame.xfill = True
+    style.yesno_frame.yminimum = 0.5
+    style.yesno_frame.xmargin = .1
+
+    style.yesno_frame_vbox.xpos = 0.5
+    style.yesno_frame_vbox.xanchor = 0.5
+    style.yesno_frame_vbox.ypos = 0.5
+    style.yesno_frame_vbox.yanchor = 0.5
+
+    style.yesno_button_hbox.xalign = 0.5
+    style.yesno_button_hbox.spacing = 100
+    
+    ##############################################################################
+    # Preferences.
+
+
+    style.prefs_pref_frame.xpos = 0.5
+    style.prefs_pref_frame.xanchor = 0.5
+    style.prefs_pref_frame.bottom_margin = 10
+
+    style.prefs_label.xpos = 0.5
+    style.prefs_label.xanchor = 0.5
+    style.prefs_label.color = green
+
+    style.prefs_slider.xmaximum=200
+    style.prefs_slider.ymaximum=22
+    style.prefs_slider.xpos = 0.5
+    style.prefs_slider.xanchor = 0.5
+
+    style.prefs_hbox.xpos = 0.5
+    style.prefs_hbox.xanchor = 0.5
+
+    style.prefs_button.xpos = 0.5
+    style.prefs_button.xanchor = 0.5
+
+    style.prefs_button.selected_xpos = 0.5
+    style.prefs_button.selected_xanchor = 0.5
+
+    style.prefs_frame.xfill=True
+    style.prefs_frame.ypadding = 0.05
+
+    style.prefs_column.spacing = 6
+
+    style.prefs_left.xanchor = 0.5
+    style.prefs_left.xpos = 1.0 / 6.0
+
+    style.prefs_center.xanchor = 0.5
+    style.prefs_center.xpos = 3.0 / 6.0
+
+    style.prefs_right.xanchor = 0.5
+    style.prefs_right.xpos = 5.0 / 6.0
+
+    style.prefs_spinner.xpos = 0.5
+    style.prefs_spinner.xanchor = 0.5
+
+    style.prefs_spinner_label.minwidth = 100
+    style.prefs_spinner_label.textalign = 0.5
+
+    style.prefs_js_button_text.size = 18
+    style.prefs_js_button_text.drop_shadow = (1, 1)
+
+    style.js_function_label.textalign = 0.5
+    style.js_prompt_label.textalign = 0.5
+
+    style.js_frame.xfill = True
+    style.js_frame.yminimum = 0.5
+    style.js_frame.xmargin = .1
+
+    style.js_frame_vbox.xpos = 0.5
+    style.js_frame_vbox.xanchor = 0.5
+    style.js_frame_vbox.ypos = 0.5
+    style.js_frame_vbox.yanchor = 0.5
+
+    style.soundtest_button.activate_sound = None
+
+    style.window.background = Solid((0, 0, 128, 128))
+    style.window.xpadding = 10
+    style.window.ypadding = 5
+    style.window.xmargin = 10
+    style.window.ymargin = 5
+    style.window.xfill = True
+    style.window.yfill = False
+    style.window.xminimum = 0 # Includes margins and padding.
+    style.window.yminimum = 150 # Includes margins and padding.
+
+
+    
+    ######################################################################
+    # Compatibility names for renamed styles.
+    style.file_picker_window_vbox = style.file_picker_frame_vbox
+    style.prefs_window = style.prefs_frame
+    style.mm_root_window = style.mm_root
+    style.file_picker_window = style.file_picker_frame
+    style.prefs_pref = style.prefs_pref_frame
+    style.gm_root_window = style.gm_root
+    style.yesno_window_vbox = style.yesno_frame_vbox
+    style.joyprompt_label = style.js_prompt_label
+    style.gm_nav_window = style.gm_nav_frame
+    style.joy_window = style.js_frame
+    style.mm_menu_window = style.mm_menu_frame
+    style.error_window = style.error_root
+    style.joyfunc_label = style.js_function_label
+    style.joy_vbox = style.js_frame_vbox
+    style.yesno_window = style.yesno_frame
+    style.mm_menu_window_vbox = style.mm_menu_frame_vbox
+    style.menu_choice_button_text = style.menu_choice
+    style.menu_choice_chosen_button_text = style.menu_choice_chosen
+
+    store._selected_compat = [ ]
+
+    class _SelectedCompat(object):
+
+        def __init__(self, target):
+            self.__dict__["target"] = target
+            self.__dict__["property_updates"] = [ ]
+
+            store._selected_compat.append(self)
+
+        def __setattr__(self, k, v):
+            self.property_updates.append((k, v))
+
+        def apply(self):
+            target = getattr(style, self.target)
+            for k, v in self.property_updates:
+                setattr(target, "selected_" + k, v)
+
+        def clear(self):
+            self.__dict__["property_updates"] = [ ]
+
+
+    style.selected_button = _SelectedCompat('button')
+    style.selected_button_text = _SelectedCompat('button_text')
+    style.gm_nav_selected_button = _SelectedCompat('gm_nav_button')
+    style.gm_nav_selected_button_text = _SelectedCompat('gm_nav_button_text')
+    style.prefs_selected_button = _SelectedCompat('prefs_button')
+    style.prefs_selected_button_text = _SelectedCompat('prefs_button_text')
+    
+    def apply_selected_compat():
+        for scs in _selected_compat:
+            scs.apply()
+
+    layout.compat_funcs.append(apply_selected_compat)

common/_compat/themes.rpym

@@ -0,0 +1,503 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2012 Tom Rothamel
+#
+# Please see the LICENSE.txt distributed with Ren'Py for permission to
+# copy and modify.
+
+init -1100:
+    python:
+
+        theme = object()
+
+        def RoundRect(color, small=False):
+            """
+            Creates a roundrect displayable. Size should be one of
+            6 or 12, while color is the color of the roundrect.
+            """
+
+            if small:
+                size = 6
+            else:
+                if config.screen_width <= 640:
+                    size = 6
+                else:
+                    size = 12
+
+            return Frame(theme.OneOrTwoColor("_roundrect/rr%dg.png" % size, color), size, size)
+                            
+        def _display_button_menu(menuitems):
+
+            narration = [ s for s, i in menuitems if i is None and s ]
+            menuitems = [ (s, i) for s, i in menuitems if i is not None or not s ]
+
+            if narration:
+                renpy.say(None, "\n".join(narration), interact=False)
+
+            return renpy.display_menu(menuitems)
+
+        def _button_menu():
+
+            store.menu = _display_button_menu
+
+            style.menu.clear()
+            style.menu.box_spacing = 2
+
+            style.menu_window.clear()
+            style.menu_window.take(style.default)
+            style.menu_window.xpos = 0.5
+            style.menu_window.xanchor = 0.5
+            style.menu_window.ypos = 0.5
+            style.menu_window.yanchor = 0.5
+
+            style.menu_choice.clear()
+            style.menu_choice.take(style.button_text)
+
+            style.menu_choice_button.clear()
+            style.menu_choice_button.take(style.button)
+
+            style.menu_choice_chosen.clear()
+            style.menu_choice_chosen_button.clear()
+
+            style.menu_choice_button.xminimum = int(config.screen_width * 0.75)
+            style.menu_choice_button.xmaximum = int(config.screen_width * 0.75)
+
+
+        theme.button_menu = _button_menu
+            
+    python hide:
+
+        def OneOrTwoColor(image, color):
+            if len(color) == 2:
+                return im.Twocolor(image, color[0], color[1])
+            else:
+                return im.Twocolor(image, color, color)
+            
+        theme.OneOrTwoColor = OneOrTwoColor
+        
+
+        def theme_roundrect(
+            widget = (0, 60, 120, 255),
+            widget_hover = (0, 80, 160, 255),
+            widget_text = (200, 225, 255, 255),
+            widget_selected = (255, 255, 200, 255),
+            disabled = (64, 64, 64, 255),
+            disabled_text = (200, 200, 200, 255),
+            label = (255, 255, 255, 255),
+            frame = (100, 150, 200, 255),
+            window = (0, 0, 0, 192),
+            mm_root = Solid((220, 235, 255, 255)),
+            gm_root = Solid((220, 235, 255, 255)),
+            centered = False,
+            button_menu = True,
+            launcher = False,
+            rounded_window = True,
+            less_rounded = False,
+            ):
+
+            """This enables the use of the roundrect theme. By
+               default, this theme styles the game in a blue color
+               scheme. However, by supplying one or more of the
+               parameters given below, the color scheme can be
+               changed.
+
+               @param widget: The background color of non-focued
+               buttons and sliders.
+
+               @param widget_hover: The background color of focused
+               buttons and sliders.
+
+               @param widget_text: The text color of non-selected buttons.
+
+               @param widget_selected: The text color of selected buttons.
+
+               @param disabled: The background color of disabled buttons.
+
+               @param disabled_text: The text color of disabled buttons.
+
+               @param label: The text color of non-selected labels.
+
+               @param frame: The background color of frames.
+
+               @param mm_root: A displayable (such as
+               an Image or Solid) that will be used as
+               the background for the main menu.
+
+               @param gm_root: A displayable (such as
+               an Image or Solid) that will be used as
+               the background for the game menu.
+
+               @param centered: If True, the buttons and sliders will
+               be centered in the frames or windows that contain
+               them. If False, the default, they will be pushed to the
+               right side.
+               """
+
+            if config.screen_width <= 640:
+                size = 18
+                small = 12
+
+                big = False
+
+                spacing = 0
+                pref_spacing = 5
+                title_spacing = 6
+
+                frame_width = 200
+                widget_width = 160
+
+                config.thumbnail_width = 60
+                config.thumbnail_height = 45
+
+                config.file_page_cols = 2
+                config.file_page_rows = 4
+                # style.file_picker_frame.xmaximum = 450
+
+                prefcols = [ 110, 320, 530 ]
+
+                nav_xpos = 530
+                    
+            else:
+
+                size = 22
+                small = 16
+
+                big = True
+
+                spacing = 0
+                pref_spacing = 10
+                title_spacing = 12
+
+                frame_width = 250
+                widget_width = 200
+
+                prefcols = [ 137, 400, 663 ]
+
+                nav_xpos = 663
+                
+            rrslider_empty = "_roundrect/rrslider_empty.png"
+            rrslider_full = "_roundrect/rrslider_full.png"
+            rrslider_thumb = "_roundrect/rrslider_thumb.png"
+
+            rrslider_radius = 6
+            rrslider_height = 24
+
+            rrvslider_empty = "_roundrect/rrvslider_empty.png"
+            rrvslider_full = "_roundrect/rrvslider_full.png"
+            rrvslider_thumb = "_roundrect/rrvslider_thumb.png"
+
+            rrscrollbar = "_roundrect/rrscrollbar.png"
+            rrscrollbar_thumb = "_roundrect/rrscrollbar_thumb.png"
+            rrvscrollbar = "_roundrect/rrvscrollbar.png"
+            rrvscrollbar_thumb = "_roundrect/rrvscrollbar_thumb.png"
+            
+            rrvslider_radius = 6
+            rrvslider_width = 24
+
+
+            def rrframe(sty):
+                sty.background = RoundRect(frame, less_rounded)
+                sty.xpadding = 6
+                sty.ypadding = 6
+
+            if big and not less_rounded:
+                store._roundrect_radius = 12
+            else:
+                store._roundrect_radius = 6
+
+            style.button.clear()
+            style.button.background = RoundRect(widget, less_rounded)
+            style.button.hover_background = RoundRect(widget_hover, less_rounded)
+            style.button.xminimum = widget_width
+            style.button.ypadding = 1
+            style.button.xpadding = _roundrect_radius
+            style.button.xmargin = 1
+            style.button.ymargin = 1
+
+            style.button_text.clear()
+            style.button_text.drop_shadow = None
+            style.button_text.color = widget_text
+            style.button_text.size = size
+            style.button_text.xpos = 0.5
+            style.button_text.xanchor = 0.5
+            style.button_text.ypos = 0.5
+            style.button_text.yanchor = 0.5
+            style.button_text.textalign = 0.5 
+
+            style.button.insensitive_background = RoundRect(disabled, less_rounded)
+            style.button_text.insensitive_color = disabled_text
+
+            style.button_text.selected_color = widget_selected 
+
+            style.menu_button.clear()
+            
+            style.mm_root.background = mm_root
+            style.gm_root.background = gm_root
+            
+            style.mm_menu_frame_vbox.box_spacing = spacing
+            rrframe(style.mm_menu_frame)
+            style.mm_menu_frame.xpos = nav_xpos
+            style.mm_menu_frame.xanchor = 0.5
+
+            style.gm_nav_vbox.box_spacing = spacing
+            rrframe(style.gm_nav_frame)
+            style.gm_nav_frame.xpos = nav_xpos
+            style.gm_nav_frame.xanchor = 0.5
+
+            
+            rrframe(style.prefs_pref_frame)
+            del style.prefs_pref_frame.bottom_margin
+            style.prefs_pref_frame.xfill = True
+
+            style.prefs_pref_vbox.box_spacing = spacing
+            style.prefs_pref_vbox.box_first_spacing = title_spacing
+            style.prefs_pref_vbox.xfill = True
+
+            style.prefs_frame.ypadding = pref_spacing
+
+            rrframe(style.prefs_column)
+            style.prefs_column.box_spacing = pref_spacing
+            style.prefs_column.xmaximum = frame_width
+
+            style.prefs_left.xpos = prefcols[0]
+            style.prefs_center.xpos = prefcols[1]
+            style.prefs_right.xpos = prefcols[2]
+
+            style.prefs_label.color = label
+            style.prefs_label.size = size
+            style.prefs_label.drop_shadow = None
+            style.prefs_label.xpos = 0
+            style.prefs_label.xanchor = 0
+
+            if centered:
+                style.prefs_button.xpos = 0.5
+                style.prefs_button.xanchor = 0.5
+            else:
+                style.prefs_button.xpos = 1.0
+                style.prefs_button.xanchor = 1.0
+
+
+                
+            style.bar.ymaximum = rrslider_height
+            style.bar.left_gutter = rrslider_radius
+            style.bar.right_gutter = rrslider_radius
+            style.bar.thumb_offset = -rrslider_radius
+
+            style.bar.left_bar = Frame(theme.OneOrTwoColor(rrslider_full, widget), rrslider_radius * 2, 0)
+            style.bar.right_bar = Frame(theme.OneOrTwoColor(rrslider_empty, widget), rrslider_radius * 2, 0)
+            style.bar.thumb = theme.OneOrTwoColor(rrslider_thumb, widget)
+
+            style.bar.hover_left_bar = Frame(theme.OneOrTwoColor(rrslider_full, widget_hover), rrslider_radius * 2, 0)
+            style.bar.hover_right_bar = Frame(theme.OneOrTwoColor(rrslider_empty, widget_hover), rrslider_radius * 2, 0)
+            style.bar.hover_thumb = theme.OneOrTwoColor(rrslider_thumb, widget_hover)
+
+            style.scrollbar.clear()
+            style.scrollbar.left_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget), 6, 0)
+            style.scrollbar.right_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget), 6, 0)
+            style.scrollbar.hover_left_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget_hover), 6, 0)
+            style.scrollbar.hover_right_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget_hover), 6, 0)
+            style.scrollbar.thumb = Frame(theme.OneOrTwoColor(rrscrollbar_thumb, widget), 6, 0) 
+            style.scrollbar.hover_thumb = Frame(theme.OneOrTwoColor(rrscrollbar_thumb, widget_hover), 6, 0) 
+            style.scrollbar.left_gutter = 6
+            style.scrollbar.right_gutter = 6
+            style.scrollbar.ymaximum = 12
+            style.scrollbar.thumb_offset = 6
+            
+            style.vbar.xmaximum = rrvslider_width
+            style.vbar.top_gutter = rrvslider_radius
+            style.vbar.bottom_gutter = rrvslider_radius
+            style.vbar.thumb_offset = -rrvslider_radius
+
+            style.vbar.bottom_bar = Frame(theme.OneOrTwoColor(rrvslider_full, widget), 0, rrvslider_radius * 2)
+            style.vbar.top_bar = Frame(theme.OneOrTwoColor(rrvslider_empty, widget), 0, rrvslider_radius * 2)
+            style.vbar.thumb = theme.OneOrTwoColor(rrvslider_thumb, widget)
+
+            style.vbar.hover_bottom_bar = Frame(theme.OneOrTwoColor(rrvslider_full, widget_hover), 0, rrvslider_radius * 2)
+            style.vbar.hover_top_bar = Frame(theme.OneOrTwoColor(rrvslider_empty, widget_hover), 0, rrvslider_radius * 2)
+            style.vbar.hover_thumb = theme.OneOrTwoColor(rrvslider_thumb, widget_hover)
+
+            style.vscrollbar.clear()
+            style.vscrollbar.bar_invert = True
+            style.vscrollbar.top_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget), 0, 6)
+            style.vscrollbar.bottom_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget), 0, 6)
+            style.vscrollbar.hover_top_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget_hover), 0, 6)
+            style.vscrollbar.hover_bottom_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget_hover), 0, 6)
+            style.vscrollbar.thumb = Frame(theme.OneOrTwoColor(rrvscrollbar_thumb, widget), 0, 6) 
+            style.vscrollbar.hover_thumb = Frame(theme.OneOrTwoColor(rrvscrollbar_thumb, widget_hover), 0, 6) 
+            style.vscrollbar.top_gutter = 6
+            style.vscrollbar.bottom_gutter = 6
+            style.vscrollbar.xmaximum = 12
+            style.vscrollbar.thumb_offset = 6
+            
+            style.prefs_slider.xmaximum=widget_width
+            del style.prefs_slider.ymaximum
+
+            if centered:
+                style.prefs_slider.xpos = 0.5
+                style.prefs_slider.xanchor = 0.5
+            else:                
+                style.prefs_slider.xpos = 1.0
+                style.prefs_slider.xanchor = 1.0
+
+            style.soundtest_button.xminimum = 0
+
+            # Joystick
+
+            style.prefs_joystick.xmaximum = 600
+            style.prefs_joystick.xpos = 0.5
+            style.prefs_joystick.xanchor = 0.5
+            style.prefs_js_button.background = RoundRect(widget, True)
+            style.prefs_js_button.hover_background = RoundRect(widget_hover, True)
+            style.prefs_js_button_text.drop_shadow = None
+            style.prefs_js_button_text.size = small
+            style.prefs_js_button.xminimum = 450
+
+            rrframe(style.js_frame)
+            del style.js_frame.yminimum
+            style.js_frame.ypadding = .05
+            style.js_frame.xpadding = rrslider_radius
+            style.js_frame.xmargin = .05
+            style.js_frame.ypos = .1
+            style.js_frame.yanchor = 0
+
+            style.js_function_label.xpos = 0.5
+            style.js_function_label.xanchor = 0.5
+
+            style.js_prompt_label.xpos = 0.5
+            style.js_prompt_label.xanchor = 0.5
+
+            # Yes/No
+
+            rrframe(style.yesno_frame)
+            del style.yesno_frame.yminimum
+            style.yesno_frame.ypadding = .05
+            style.yesno_frame.xpadding = rrslider_radius
+            style.yesno_frame.xmargin = .05
+            style.yesno_frame.ypos = .1
+            style.yesno_frame.yanchor = 0
+
+            style.yesno_label.color = label
+            style.yesno_label.drop_shadow = None
+
+            # File Picker
+
+            rrframe(style.file_picker_frame)
+            style.file_picker_frame.xmargin = 6
+            style.file_picker_frame.ymargin = 6
+
+            style.file_picker_frame_vbox.box_spacing = 4            
+            style.file_picker_nav_button.xminimum = 0
+
+            style.file_picker_navbox.box_spacing = spacing
+            del style.file_picker_navbox.xpos
+
+            style.file_picker_entry.background = RoundRect(widget, less_rounded)
+            style.file_picker_entry.hover_background = RoundRect(widget_hover, less_rounded)
+            style.file_picker_entry.xpadding = _roundrect_radius
+            style.file_picker_entry.xmargin = 2
+
+            style.file_picker_text.size = small
+            style.file_picker_text.drop_shadow = None
+            style.file_picker_text.color = widget_text
+            style.file_picker_new.color = widget_selected
+
+            style.file_picker_old.minwidth = 40
+            style.file_picker_new.minwidth = 40
+            
+            style.file_picker_old.text_align = 1.0
+            style.file_picker_new.text_align = 1.0
+            
+            if config.script_version is None or config.script_version > (6, 0, 0):
+                style.file_picker_text.insensitive_color = disabled_text
+                style.file_picker_entry.insensitive_background = RoundRect(disabled, less_rounded)
+
+            
+            config.file_quick_access_pages = 8
+
+            # In-game.
+
+            if rounded_window:
+
+                style.window.background = RoundRect(window, less_rounded)
+                style.window.xpadding = 6
+                style.window.ypadding = 6
+                style.window.xmargin = 6
+                style.window.ymargin = 6
+
+            else:
+                
+                style.window.background = Solid(window)
+                style.window.xpadding = 6
+                style.window.ypadding = 6
+                style.window.xmargin = 0
+                style.window.ymargin = 0
+                
+                
+            style.default.size = size
+            style.default.drop_shadow = None
+
+            rrframe(style.frame)
+            style.frame.xpadding = 6
+            style.frame.ypadding = 6
+            style.frame.xmargin = 6
+            style.frame.ymargin = 6
+
+            if button_menu:
+                _button_menu()
+
+            if launcher:
+                style.launcher_mid_vbox.xpos = 80
+                style.launcher_mid_vbox.ypos = 50
+
+                style.launcher_bottom_vbox.xpos = 80
+                style.launcher_bottom_vbox.ypos = 360
+                style.launcher_bottom_vbox.yanchor = 1.0
+
+                style.launcher_button.xpos = 20
+                style.launcher_button.xminimum = 240
+
+                style.launcher_title_label.color = label
+                style.launcher_title_label.size = 28
+                
+                style.launcher_text.xpos = 140
+                style.launcher_text.xanchor = 0.5
+                style.launcher_text.xmaximum = 240
+                style.launcher_text.color = label
+                style.launcher_text.text_align = 0.5
+                
+                
+                style.launcher_label.xpos = 140
+                style.launcher_label.xanchor = 0.5
+                style.launcher_label.xmaximum = 240
+                style.launcher_label.color = label
+                style.launcher_label.text_align = 0.5
+                
+                style.launcher_input.xpos = 140
+                style.launcher_input.xanchor = 0.5
+                style.launcher_input.xmaximum = 240
+                style.launcher_input.color = widget
+                style.launcher_input.text_align = 0.5
+                
+                store._launcher_per_page = 9
+                
+        theme.roundrect = theme_roundrect
+
+        def theme_roundrect_red(**params):
+            """
+            This sets up a red/pink variant of the roundrect theme.
+            """
+            
+            args = dict(widget=(150, 50, 50, 255),
+                        widget_hover=(200, 50, 50, 255),
+                        widget_text=(255, 225, 225, 255),
+                        frame=(225, 115, 115, 192),
+                        mm_root=Solid((255, 225, 225, 255)),
+                        gm_root=Solid((255, 225, 225, 255)),
+                        )
+
+            args.update(params)
+            theme.roundrect(**args)
+
+        theme.roundrect_red = theme_roundrect_red
+

common/_developer.rpym

@@ -0,0 +1,584 @@
+# This file contains code that helps support the development of Ren'Py
+# games.
+
+screen _developer:
+
+    frame:
+        style_group ""
+
+        align (.025, .05)
+
+        has vbox
+
+        label "Developer Menu"
+
+        textbutton _(u"Reload Game (Shift+R)"): 
+            action ui.callsinnewcontext("_save_reload_game")
+            size_group "developer"
+        textbutton _(u"Variable Viewer"):
+            action Jump("_debugger_screen")
+            size_group "developer"
+        textbutton _(u"Theme Test"): 
+            action Jump("_theme_test")
+            size_group "developer"
+        textbutton _(u"Style Hierarchy"): 
+            action Jump("_style_hierarchy")
+            size_group "developer"
+        textbutton _(u"Image Location Picker"): 
+            action Jump("_image_location_picker")
+            size_group "developer"
+        textbutton _(u"Filename List"): 
+            action Jump("_filename_list")
+            size_group "developer"
+
+        null height 15
+
+        textbutton _(u"Return"):
+            action Return()
+            size_group "developer"
+         
+label _developer_screen:
+
+    call screen _developer
+        
+    return 
+        
+label _debugger_screen:
+
+    python hide:
+
+        ui.window(style=style.gm_root)
+        ui.null()
+
+        ui.frame(ymargin=10, xmargin=10, style=style.menu_frame)
+        ui.side(['t', 'c', 'r', 'b'])
+
+        layout.label("Variable Viewer", None)
+
+        entries = [ ]
+        
+        ebc = store.__dict__.ever_been_changed
+        ebc = list(ebc)
+        ebc.sort()
+
+        ebc.remove("nvl_list")
+
+        import repr
+        aRepr = repr.Repr()
+        aRepr.maxstring = 40
+
+        for var in ebc:
+            if not hasattr(store, var):
+                continue
+
+            if var.startswith("__00"):
+                continue
+
+            if var.startswith("_") and not var.startswith("__"):
+                continue
+
+            val = aRepr.repr(getattr(store, var))
+            s = (var + " = " + val)
+            s = s.replace("{", "{{")
+            s = s.replace("[", "[[")
+            entries.append((0, s))
+
+        if entries:
+            vp = ui.viewport(mousewheel=True)
+            layout.list(entries)
+            ui.bar(adjustment=vp.yadjustment, style='vscrollbar')
+        else:
+            layout.prompt("No variables have changed since the game started.", None)
+            ui.null()
+
+        layout.button(u"Return to the developer menu", None, clicked=ui.returns(True))
+
+        ui.close()
+        
+        ui.interact()
+        
+    jump _developer_screen
+
+label _theme_test:
+
+    python hide:
+
+        # Never gets pickled
+        def role(b):
+            if b:
+                return "selected_"
+            else:
+                return ""
+        
+        toggle_var = True
+        adj = ui.adjustment(100, 25, page=25, adjustable=True)
+        
+        while True:
+
+            ui.window(style=style.gm_root)
+            ui.null()
+
+            # Buttons
+            ui.hbox(box_spacing=10, xpos=10, ypos=10)
+
+            ui.vbox(box_spacing=10)
+
+            sg = "theme_test"
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Button", None)
+            ui.textbutton("Button", size_group=sg, clicked=ui.returns("gndn"))
+            ui.textbutton("Button (Selected)", size_group=sg, clicked=ui.returns("gndn"), role=role(True))
+            ui.textbutton("Small", clicked=ui.returns("gndn"), style='small_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Radio Button", None)
+            ui.textbutton("True", size_group=sg, clicked=ui.returns("set"), role=role(toggle_var), style='radio_button')
+            ui.textbutton("False", size_group=sg, clicked=ui.returns("unset"), role=role(not toggle_var), style='radio_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Check Button", None)
+            ui.textbutton("Check Button", size_group=sg, clicked=ui.returns("toggle"), role=role(toggle_var), style='check_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox(box_spacing=2)
+            ui.bar(adjustment=adj, style='bar', xmaximum=200)
+            ui.bar(adjustment=adj, style='slider', xmaximum=200)
+            ui.bar(adjustment=adj, style='scrollbar', xmaximum=200)
+            ui.close()
+            
+            ui.close() # vbox
+
+            ui.frame(style='menu_frame')
+            ui.hbox(box_spacing=2)
+            ui.bar(adjustment=adj, style='vbar', ymaximum=200)
+            ui.bar(adjustment=adj, style='vslider', ymaximum=200)
+            ui.bar(adjustment=adj, style='vscrollbar', ymaximum=200)
+            ui.close()
+            
+            ui.frame(style='menu_frame', xmaximum=0.95)
+            ui.vbox(box_spacing=20)
+            layout.prompt("This is a prompt. We've made this text long enough to wrap around so it fills multiple lines.", None)
+            ui.close()
+
+            ui.close() # hbox
+
+            ui.frame(style='menu_frame', xalign=.01, yalign=.99)
+            ui.textbutton("Return to the developer menu", clicked=ui.returns("return"))
+            
+            rv = ui.interact()
+            if rv == "return":
+                renpy.jump("_developer_screen")
+
+            elif rv == "set":
+                toggle_var = True
+            elif rv == "unset":
+                toggle_var = False
+            elif rv == "toggle":
+                toggle_var = not toggle_var
+
+label _style_hierarchy:
+
+    python hide:
+
+        ui.window(style=style.gm_root)
+        ui.null()
+
+        ui.frame(ymargin=10, xmargin=10, style=style.menu_frame)
+        ui.side(['t', 'c', 'r', 'b'], spacing=2)
+
+        layout.label("Style Hierarchy", None)
+
+        hier = renpy.style.style_hierarchy()
+
+        entries = [ (i[0], i[1] + " - " + str(i[2])) for i in hier if i[2] ]
+        
+        vp = ui.viewport(mousewheel=True)
+        layout.list(entries)
+        ui.bar(adjustment=vp.yadjustment, style='vscrollbar')
+
+        layout.button(u"Return to the developer menu", None, clicked=ui.returns(True))
+        
+        ui.close()
+        
+        ui.interact()
+        
+    jump _developer_screen
+
+init -1050 python:
+    config.missing_background = "black"
+    
+init 1050 python:
+
+    if config.developer:
+
+        # This is used to indicate that a scene has just occured,
+        # and so if the next thing is a missing_show, we should
+        # blank the screen.
+        __missing_scene = False
+
+        # This returns the __missing dictionary from the current
+        # context object.
+        def __missing():
+            try:
+                return renpy.context().__missing
+            except AttributeError:
+                rv = dict()
+                renpy.context().__missing = rv
+                return rv
+        
+        def __missing_show_callback(name, what, layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            if __missing_scene:
+                renpy.show(name, what=config.missing_background)
+            __missing_scene = False
+                
+            what = " ".join(what).replace("{", "{{").replace("[", "[[")
+            __missing()[name[0]] = what
+            return True
+
+        def __missing_hide_callback(name, layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            __missing_scene = False
+
+            __missing().pop(name[0], None)
+            return True
+            
+        def __missing_scene_callback(layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            __missing_scene = True
+            __missing().clear()
+
+            return True
+            
+        def __missing_overlay():
+            missing = __missing()
+
+            if not missing:
+                return
+
+            ui.vbox(xalign=0.5, yalign=0.0)
+            ui.text(_("Undefined Images"), xalign=0.5)
+
+            for what in sorted(missing.values()):
+                ui.text(what, xalign=0.5)
+
+            ui.close()
+
+                
+        config.missing_scene = __missing_scene_callback
+        config.missing_show = __missing_show_callback
+        config.missing_hide = __missing_hide_callback
+        config.overlay_functions.append(__missing_overlay)
+
+init -1050 python:
+
+    class __FPSMeter(object):
+
+        def __init__(self):
+            self.last_frames = None
+            self.last_time = None
+
+        def __call__(self, st, at):
+
+            if self.last_time is not None:
+                frames = config.frames - self.last_frames
+                time = st - self.last_time
+
+                text = "FPS: %.1f" % (frames / time)
+
+            else:
+                text = "FPS: --.-"
+
+            self.last_frames = config.frames
+            self.last_time = st
+
+            return Text(text, xalign=1.0), .5
+    
+label _fps_meter:
+
+    python hide:
+        def fps_overlay():
+            ui.add(DynamicDisplayable(__FPSMeter()))
+        
+        # We normally don't want to change this at runtime... but here
+        # it's okay, because we don't want to save the FPS meter anyway.
+        #
+        # Do as I say, not as I do.
+        config.overlay_functions.append(fps_overlay)
+
+    return
+
+init python:
+    
+    # This is a displayable that can keep track of the mouse coordinates,
+    # and show them to the user.
+    class __ImageLocationPicker(renpy.Displayable):
+
+        def __init__(self, fn, **kwargs):
+            super(__ImageLocationPicker, self).__init__(**kwargs)
+            
+            self.child = Image(fn)
+
+            self.mouse = None
+            self.point1 = None
+            self.point2 = None
+            
+        def render(self, width, height, st, at):
+            rv = renpy.Render(width, height)
+
+            cr = renpy.render(self.child, width, height, st, at)
+            rv.blit(cr, (0, 0))
+
+            text = [ ]
+            
+
+            if self.point1 and self.point2 and not self.point1 == self.point2:
+                x1, y1 = self.point1
+                x2, y2 = self.point2
+
+                x1 = min(x1, cr.width)
+                x2 = min(x2, cr.width)
+                y1 = min(y1, cr.height)
+                y2 = min(y2, cr.height)
+                
+                minx = min(x1, x2)
+                miny = min(y1, y2)
+                maxx = max(x1, x2)
+                maxy = max(y1, y2)
+                
+                w = maxx - minx
+                h = maxy - miny
+
+                if w and h:
+
+                    sr = renpy.render(Solid("#0ff4"), w, h, st, at)
+                    rv.blit(sr, (minx, miny))
+
+                    # text.append("Imagemap rectangle: %r" % ((minx, miny, maxx, maxy),))
+                    text.append("Rectangle: %r" % ((minx, miny, w, h),))
+                
+            if self.mouse:
+                mx, my = self.mouse
+                if mx < cr.width and my < cr.height:
+                    text.append(_("Mouse position: %r") % (self.mouse,))
+                    
+            text.append(_("Right-click or escape to quit."))
+                
+            td = Text("\n".join(text), size=14, color="#fff", outlines=[ (1, "#000", 0, 0 ) ])
+            tr = renpy.render(td, width, height, st, at)
+
+            rv.blit(tr, (0, height - tr.height))
+            
+            return rv
+
+        def event(self, ev, x, y, st):
+            import pygame
+
+            self.mouse = (x, y)
+            renpy.redraw(self, 0)
+
+            if ev.type == pygame.MOUSEBUTTONDOWN and ev.button == 1:
+                self.point1 = (x, y)
+                self.point2 = (x, y)
+
+            elif ev.type == pygame.MOUSEMOTION and ev.buttons[0]:
+                self.point2 = (x, y)
+                
+            elif ev.type == pygame.MOUSEBUTTONUP and ev.button == 1:
+                self.point2 = (x, y)
+                
+
+label _image_location_picker:
+
+    scene black
+    
+    python hide:
+
+        image_files = [
+            fn
+            for dir, fn in renpy.loader.listdirfiles()
+            if fn.lower().endswith(".jpg") or fn.lower().endswith(".png")
+            if not fn[0] == "_"
+            ]
+
+        image_files.sort()
+        
+        
+        xadjustment = ui.adjustment()
+        yadjustment = ui.adjustment()
+
+        
+        while True:
+
+            ui.frame()
+            ui.vbox()
+
+            layout.label(u"Image Location Picker", None)
+
+            ui.textbutton(_(u"Done"), clicked=ui.returns(False), size_group="files")
+            
+            ui.side(['c', 'b', 'r'], spacing=5)
+            vp = ui.viewport(xadjustment=xadjustment, yadjustment=yadjustment, mousewheel=True)
+
+            ui.vbox()
+
+            for fn in image_files:
+                ui.button(clicked=ui.returns(fn), size_group="files", xminimum=1.0)
+                ui.text(fn.replace("{", "{{").replace("[", "[["), style="button_text", xalign=0.0)
+                
+            ui.close()
+
+            ui.bar(adjustment=xadjustment, style='scrollbar')
+            ui.bar(adjustment=yadjustment, style='vscrollbar')
+            ui.close()
+
+            ui.close()
+            
+            rv = ui.interact()
+
+            if rv is False:
+                renpy.jump("_developer_screen")
+
+            # Now, allow the user to pick the image.
+
+            ui.keymap(game_menu=ui.returns(True))
+            ui.add(__ImageLocationPicker(rv))
+            ui.interact()
+
+                
+
+        # ...
+
+        renpy.jump("_image_location_picker")
+
+label _filename_list:
+
+    python hide:
+        import os
+        f = file("files.txt", "w")
+
+        for dirname, dirs, files in os.walk(config.gamedir):
+
+            dirs.sort()
+            files.sort()
+            
+            for fn in files:
+                fn = os.path.join(dirname, fn)
+                fn = fn[len(config.gamedir) + 1:]
+                print >>f, fn.encode("utf-8", "replace")
+                print fn.encode("utf-8", "replace")
+                
+        f.close()
+        
+        renpy.launch_editor(["files.txt"], transient=1)
+        
+    
+    jump _developer_screen
+
+# The style inspector.
+screen _inspector:
+    zorder 1010
+    modal True
+    
+    frame:
+        style_group ""
+        
+        xfill True
+        yfill True
+        
+        
+        has vbox
+        
+        label _("Style Inspector")
+        
+        null height 20
+        
+        if not tree:
+            text _("Nothing to inspect.")
+        else:
+            for depth, width, height, d in tree:      
+                $ t = ( "  " * depth + 
+                        u" \u2022 " + 
+                        d.__class__.__name__ + " : " + 
+                        "style=%s, " % (__format_style(d.style),) + 
+                        "size=(%dx%d)" % (width, height) ) 
+                 
+                text "[t!q]"
+                  
+        null height 20
+        
+        text _("(Click to continue.)")
+    
+    python:
+        ui.saybehavior()
+
+init python:
+    def _image_load_log_function(st, at):
+        
+        ill = list(renpy.get_image_load_log(3))
+        
+        if not ill:
+            return Null(), .25
+        
+        vbox = VBox()
+        
+        for when, filename, preload in ill:
+            if preload:
+                color="#ffffff"
+            else:
+                color="#ffcccc"
+            
+            vbox.add(Text(filename.replace("{", "{{").replace("[", "[["), size=12, color=color, style="_default"))
+            
+        rv = Window(vbox, style="_frame", background="#0004", xpadding=5, ypadding=5, xminimum=200)
+        return rv, .25
+
+screen _image_load_log:
+    zorder 1000
+
+    add DynamicDisplayable(_image_load_log_function)
+
+
+init python:
+
+    def __format_style(s):
+        
+        while s:
+            if s.name:
+                break
+            
+            if s.parent:
+                s = style.get(s.parent)
+            else:
+                break
+                
+        return s.name[0] + "".join([ "[%r]" % i for i in s.name[1:] ]) 
+    
+    def __inspect(tree):
+        renpy.context_dynamic("_window")
+        store._window = False
+        
+        renpy.exports.show_screen("_inspector", _transient=True, tree=tree)
+        renpy.ui.interact(mouse="screen", type="screen", suppress_overlay=True, suppress_underlay=True)
+             
+    config.inspector = __inspect
+
+init python:
+    config.underlay.append(im.Tile("_transparent_tile.png"))
+    

common/_errorhandling.rpym

@@ -0,0 +1,488 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+#
+# This file contains the code for in-game Ren'Py error handling. It's a 
+# module (as opposed to a .rpy file) because that allows us to ensure 
+# that it is fully loaded or run before any other Ren'Py code runs. 
+
+
+
+# These styles define the look of the Ren'Py in-game interface (the 
+# amie2-inspired look). They're also used in the launcher.
+init python:
+    # default
+    style._default = Style(None)
+
+    # Temporarily, until the real styles can be defined.
+    style.default = style._default
+    style.image = style._default
+    style.fixed = style._default
+    
+    style._default.font = "DejaVuSans.ttf"
+    style._default.language = "unicode"
+    style._default.antialias = True
+    style._default.size = 14
+    style._default.color = "#111"
+    style._default.black_color = (0, 0, 0, 255)
+    style._default.bold = False
+    style._default.italic = False
+    style._default.underline = False
+    style._default.strikethrough = False
+    style._default.kerning = 0.0
+    style._default.drop_shadow = None
+    style._default.drop_shadow_color = (0, 0, 0, 255)
+    style._default.outlines = [ ]
+    style._default.minwidth = 0
+    style._default.text_align = 0
+    style._default.justify = False
+    style._default.text_y_fudge = 0
+    style._default.first_indent = 0
+    style._default.rest_indent = 0
+    style._default.line_spacing = 0
+    style._default.line_leading = 0
+    style._default.line_overlap_split = 0
+    style._default.layout = "tex"
+    style._default.subtitle_width = 0.9
+    style._default.slow_cps = None
+    style._default.slow_cps_multiplier = 1.0
+    style._default.slow_abortable = False
+    
+    # Window properties.
+    style._default.background = None
+    style._default.xpadding = 0
+    style._default.ypadding = 0
+    style._default.xmargin = 0
+    style._default.ymargin = 0
+    style._default.xfill = False
+    style._default.yfill = False
+    style._default.xminimum = 0 # Includes margins and padding.
+    style._default.yminimum = 0 # Includes margins and padding.
+
+    # Placement properties.
+    style._default.xpos = None # 0
+    style._default.ypos = None # 0
+    style._default.xanchor = None # 0
+    style._default.yanchor = None # 0
+    style._default.xmaximum = None
+    style._default.ymaximum = None
+    style._default.xoffset = 0
+    style._default.yoffset = 0
+    style._default.subpixel = False
+    
+    # Sound properties.
+    style._default.sound = None
+
+    # Box properties.
+    style._default.spacing = 0
+    style._default.first_spacing = None
+    style._default.box_layout = None
+    style._default.box_wrap = False
+
+    # Focus properties.
+    style._default.focus_mask = None
+    style._default.focus_rect = None
+
+    # Bar properties.
+    style._default.fore_bar = Null()
+    style._default.aft_bar = Null()
+    style._default.thumb = None
+    style._default.thumb_shadow = None
+    style._default.left_gutter = 0
+    style._default.right_gutter = 0
+    style._default.thumb_offset = 0
+    style._default.unscrollable = None
+    style._default.bar_invert = False
+    style._default.bar_vertical = False
+    
+    # Misc.
+    style._default.activate_sound = None
+    style._default.clipping = False
+
+    ##########################################################################
+
+    # frame
+    style._frame = Style(style._default)
+    style._frame.background = Frame("_theme_amie2/frame.png", 40, 40)
+    style._frame.xmargin = 0
+    style._frame.ymargin = 0
+    style._frame.xpadding = 15
+    style._frame.ypadding = 10
+
+    # text    
+    style._text = Style(style._default)
+ 
+    # boxes/boxlike
+    style._fixed = Style(style._default)
+    style._hbox = Style(style._default)
+    style._vbox = Style(style._default)
+    style._grid = Style(style._default)
+    style._side = Style(style._default)
+    style._viewport = Style(style._default)    
+
+    style._hbox.box_layout = 'horizontal'
+    style._vbox.box_layout = 'vertical'
+    style._viewport.clipping = True
+           
+    # button
+    style._button = Style(style._default)
+    style._button_text = Style(style._default)
+    style._button.xpadding = 8
+    style._button.ypadding = 6
+    style._button.xoffset = -5
+
+    style._button.background = Frame("_theme_amie2/button.png", 10, 10)
+    style._button.hover_background = Frame("_theme_amie2/button_hover.png", 10, 10)
+    style._button_text.size = 16
+    style._button_text.color = "#111"
+    style._button_text.selected_color = "#11f"
+    style._button_text.insensitive_color = "#ccc"
+    style._button_text.xalign = 0.5
+    style._button_text.yoffset = 0
+    
+    # label
+    style._label = Style(style._default)
+    style._label_text = Style(style._default)
+    
+    style._label.top_margin = 10
+    style._label.bottom_margin = 5
+
+    style._label_text.color = "#000"
+    style._label_text.bold = True
+    
+    # bar
+    style._bar = Style(style._default)
+
+    style._bar.left_bar = Frame("_theme_amie2/hover_frame.png", 10, 10)
+    style._bar.right_bar = Frame("_theme_amie2/bar.png", 10, 10)
+    style._bar.thumb = None
+    style._bar.hover_thumb = None
+    style._bar.ymaximum = 20
+    
+    style._scrollbar = Style(style._default)
+    style._vscrollbar = Style(style._default)
+
+    style._scrollbar.left_bar = Frame("_theme_amie2/bar.png", 10, 10)
+    style._scrollbar.right_bar = Frame("_theme_amie2/bar.png", 10, 10)
+    style._scrollbar.thumb = Frame("_theme_amie2/frame.png", 10, 10)
+    style._scrollbar.hover_thumb = Frame("_theme_amie2/hover_frame.png", 10, 10)
+    style._scrollbar.thumb_offset = 10
+    style._scrollbar.left_gutter = 5
+    style._scrollbar.right_gutter = 5
+    style._scrollbar.unscrollable = "hide"
+    
+    style._scrollbar.ymaximum = 20
+    style._vscrollbar.xmaximum = 20   
+    style._vscrollbar.bar_vertical = True
+    style._vscrollbar.bar_invert = True
+
+    style._hyperlink = Style(style._default)
+    style._hyperlink.color = "#008"
+    style._hyperlink.hover_underline = True
+
+# Early hyperlink support.
+init python hide:
+    def hyperlink_styler(target):
+        return style._hyperlink
+
+    def hyperlink_function(target):
+        if target.startswith("http:"):
+            try:
+                import webbrowser
+                webbrowser.open(target)
+            except:
+                pass
+
+        if target.startswith("edit:"):
+            prefix, line, filename = target.split(":", 2)
+            line = int(line)
+            
+            renpy.launch_editor([ filename ], line)
+    
+    style._default.hyperlink_functions = (hyperlink_styler, hyperlink_function, None)
+
+init python:
+
+    # Null translation function. This gets redefined once things start
+    # successfully.
+    def _(s):
+        return s
+
+    # This function is responsible for taking a traceback, and converting 
+    # it to a string that can be shown with text.
+    def __format_traceback(s):
+        import re
+        
+        lines = [ i.replace("{", "{{") for i in s.split("\n") ]
+    
+        rv = [ "{b}" + lines[0] + "{/b}" ]
+        
+        for i in lines[1:]:
+            i = re.sub(r'(File "(.*)", line (\d+))', r'{a=edit:\3:\2}\1{/a}', i)
+            rv.append(i)
+            
+        return "\n".join(rv)
+
+
+    def __format_parse_errors(s):
+        import re
+
+        rv = ""
+
+        lines = s.split("\n")
+        len_lines = len(lines)
+        
+        ln = 0
+                
+        while ln < len_lines:
+            line = lines[ln]
+            ln += 1
+             
+            if ln < len_lines and lines[ln].endswith("^"):
+                highlight = len(lines[ln]) - 1
+                ln += 1
+            else:
+                highlight = -1
+                
+            pos = 0
+            
+            for c in line:
+                if pos == highlight:
+                    rv += u"{color=#c00}\u2192{/color}"
+                    highlight = -1
+
+                pos += 1
+                    
+                if c == "{":
+                    rv += "{{"
+                else:
+                    rv += c
+                    
+            if highlight > 0:
+                rv += u"{color=#c00}\u2190{/color}"
+            
+            rv += "\n"
+
+             
+        rv = re.sub(r'(File "(.*)", line (\d+))', r'{a=edit:\3:\2}\1{/a}', rv)
+             
+        return rv
+            
+    class __EditFile(Action):
+        def __init__(self, filename):
+            self.filename = filename
+            
+        def __call__(self):
+            try:
+                renpy.launch_editor([ self.filename ], 1, transient=1)
+            except:
+                pass
+        
+    def __can_open_traceback():
+        return True
+
+    # The transform used for errors. ATL isn't ready yet.    
+    def __transform_function(state, st, at):
+        done = min(st / .1, 1.0) 
+        state.zoom = .5 + .5 * done
+        state.alpha = done
+        state.xalign = 0.5
+        state.yalign = 0.5
+        
+        if done < 1.0:
+            return 0
+        else:
+            return None
+            
+    __transform = Transform(function=__transform_function, style='_default')
+     
+    class __TooltipAction(object):
+
+        def __init__(self, tooltip, value):
+            self.tooltip = tooltip
+            self.value = value
+
+        def __call__(self):
+            if self.tooltip.value != self.value:
+                self.tooltip.value = self.value
+                renpy.restart_interaction()            
+
+        def unhovered(self):
+            if self.tooltip.value != self.tooltip.default:
+                self.tooltip.value = self.tooltip.default
+                renpy.restart_interaction()            
+
+    class __Tooltip(object):        
+        def __init__(self, default):
+            self.value = default
+            self.default = default
+
+        def action(self, value):
+            return __TooltipAction(self, value)
+
+    class __XScrollValue(BarValue):
+        def __init__(self, viewport):
+            self.viewport = viewport
+
+        def get_adjustment(self):
+            w = renpy.get_widget(None, self.viewport)
+            if not isinstance(w, Viewport):
+                raise Exception("The displayable with id %r is not declared, or not a viewport." % self.viewport)
+
+            return w.xadjustment
+
+        def get_style(self):
+            return "scrollbar", "vscrollbar"
+
+    class __YScrollValue(BarValue):
+        def __init__(self, viewport):
+            self.viewport = viewport
+
+        def get_adjustment(self):
+            w = renpy.get_widget(None, self.viewport)
+            if not isinstance(w, Viewport):
+                raise Exception("The displayable with id %r is not declared, or not a viewport." % self.viewport)
+
+            return w.yadjustment
+
+        def get_style(self):
+            return "scrollbar", "vscrollbar"
+
+          
+# The screen that is used for error handling.
+screen _exception:
+    modal True
+    zorder 1090
+
+    default tt = __Tooltip("")
+    default fmt_short = __format_traceback(short)
+    default fmt_full = __format_traceback(full)
+    
+    add Solid("#000")
+    
+    frame:
+        style_group ""
+        xfill True
+
+        at __transform
+
+        has side "t c r b"
+            
+        vbox:   
+            label _("An exception has occurred.")
+
+        viewport:
+            id "viewport"
+            child_size (4000, None)
+            mousewheel True
+            
+            has vbox
+
+            text fmt_short substitute False
+            text fmt_full substitute False
+      
+        bar:
+            style "_vscrollbar"
+            value __YScrollValue("viewport")
+
+        vbox:
+
+            bar:
+                style "_scrollbar"
+                value __XScrollValue("viewport")
+
+            hbox:
+                box_wrap True
+
+                if rollback_action:
+                    textbutton _("Rollback"):
+                        action rollback_action
+                        hovered tt.action(_("Attempts a roll back to a prior time, allowing you to save or choose a different choice."))
+                        
+                if ignore_action:
+                    textbutton _("Ignore"):
+                        action ignore_action
+                        hovered tt.action(_("Ignores the exception, allowing you to continue. This often leads to additional errors."))
+
+                if config.developer:                    
+                    textbutton _("Reload"):
+                        action reload_action
+                        hovered tt.action(_("Reloads the game from disk, saving and restoring game state if possible."))
+                        
+                textbutton _("Open Traceback"):
+                    action __EditFile(traceback_fn)
+                    hovered tt.action(_("Opens the traceback.txt file in a text editor."))
+                    
+                null width 30
+                
+                textbutton _("Quit"):
+                    action renpy.quit
+                    hovered tt.action(_("Quits the game."))
+
+            # Tooltip.
+            text tt.value size 12
+            
+    if config.developer and reload_action:
+        key "R" action reload_action
+            
+# The screen that is used for error handling.
+screen _parse_errors:
+    modal True
+    zorder 1090
+
+    default tt = __Tooltip("")
+    default fmt_errors = __format_parse_errors(errors)
+    
+    add Solid("#000")
+
+    frame:
+        style_group ""
+        xfill True
+
+        at __transform
+
+        has side "t c r b"
+            
+        vbox:   
+            label _("Parsing the script failed.")
+
+        viewport:
+            id "viewport"
+            child_size (None, None)
+            mousewheel True
+            
+            has vbox
+            text fmt_errors substitute False
+      
+        bar:
+            style "_vscrollbar"
+            value __YScrollValue("viewport")
+
+        vbox:
+
+            bar:
+                style "_scrollbar"
+                value __XScrollValue("viewport")
+
+            hbox:
+                box_wrap True
+
+                textbutton _("Reload"):
+                    action reload_action
+                    hovered tt.action(_("Reloads the game from disk, saving and restoring game state if possible."))
+                        
+                textbutton _("Open Parse Errors"):
+                    action __EditFile(error_fn)
+                    hovered tt.action(_("Opens the errors.txt file in a text editor."))
+                    
+                null width 30
+                
+                textbutton _("Quit"):
+                    action renpy.quit
+                    hovered tt.action(_("Quits the game."))
+
+            # Tooltip.
+            text tt.value size 12
+
+    if config.developer and reload_action:
+        key "R" action reload_action
+            

common/_layout/classic_joystick_preferences.rpym

@@ -0,0 +1,109 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('joystick_preferences')
+    
+    style.js_frame = Style(style.menu_frame, help="frame used for changing a joystick binding")
+    style.js_frame_box = Style(style.vbox, help="vbox used for changing a joystick binding")
+    style.js_function_prompt = Style(style.prompt, help="the name of the joystick binding to change (window)")
+    style.js_function_prompt_text = Style(style.prompt_text, help="the name of the joystick binding to change (text)")
+    style.js_action_prompt = Style(style.prompt, help="prompting the user how to change a joystick binding (window)")
+    style.js_action_prompt_text = Style(style.prompt_text, help="prompting the user how to change a joystick binding (text)")
+
+    style.js_prefs_frame = Style(style.menu_frame, help="frame containing all joystick bindings")
+    style.js_prefs_box = Style(style.vbox, help="box containing all joystick bindings")
+    style.js_prefs_button = Style(style.button, help="button containing a joystick binding")
+    style.js_prefs_button_text = Style(style.button_text, help="button containing a joystick binding (text)")
+    
+    style.js_prefs_label = Style(style.label, help="joystick preferences label (window)") 
+    style.js_prefs_label_text = Style(style.label_text, help="joystick preferences label (text)") 
+
+    style.js_frame.ypos = .1
+    style.js_frame.ypadding = .05
+    style.js_frame.xmargin = .1
+    style.js_frame_box.box_spacing = 30
+
+    style.js_prefs_frame.xpos = 10
+    style.js_prefs_frame.ypos = 10
+
+    style.js_prefs_button.xminimum = 0.5
+    style.js_prefs_box.box_first_spacing = 10
+    
+    config.joystick_keys = [
+        (u'Left', 'joy_left'),
+        (u'Right', 'joy_right'),
+        (u'Up', 'joy_up'),
+        (u'Down', 'joy_down'),
+        (u'Select/Dismiss', 'joy_dismiss'),
+        (u'Rollback', 'joy_rollback'),
+        (u'Hold to Skip', 'joy_holdskip'),
+        (u'Toggle Skip', 'joy_toggleskip'),
+        (u'Hide Text', 'joy_hide'),
+        (u'Menu', 'joy_menu'),
+        ]
+    
+    def _joystick_select_binding():
+
+        for label, key in config.joystick_keys:
+
+            def my_clicked(label=label, key=key):
+                return (label, key)
+
+            layout.button(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=my_clicked, index=label)
+    
+    def _joystick_get_binding():
+        ui.saybehavior()
+        ui.add(renpy.display.joystick.JoyBehavior())
+
+    def _joystick_take_binding(binding, key):
+
+        if not isinstance(binding, basestring):
+            if key in _preferences.joymap:
+                del _preferences.joymap[key]
+        else:
+            _preferences.joymap[key] = binding
+        
+            
+    def _joystick_preferences():
+
+            def set_binding(label, key):
+                layout.navigation(None)
+
+                ui.window(style='js_frame')
+                ui.vbox(style='js_frame_box')
+                layout.prompt(_(u"Joystick Mapping") + " - " + _(label), "js_function")
+                layout.prompt(u'Move the joystick or press a joystick button to create the mapping. Click the mouse to remove the mapping.', 'js_action')
+                ui.close()
+
+                _joystick_get_binding()
+                binding = ui.interact(mouse="gamemenu")
+                _joystick_take_binding(binding, key)
+                
+                return True
+
+            ui.window(style='js_prefs_frame')
+            ui.vbox(style='js_prefs_box')
+
+            layout.label("Joystick Configuration", "js_prefs")
+            
+            for label, key in config.joystick_keys:
+
+                def clicked(label=label, key=key):
+                    return renpy.invoke_in_new_context(set_binding, label, key)
+
+                layout.button(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "js_prefs", clicked=clicked, index=label)
+            
+            ui.close()
+
+label joystick_preferences_screen:
+
+    while True:
+        python:
+            layout.navigation("joystick_preferences")
+            _joystick_preferences()
+            ui.interact(mouse="gamemenu")
+
+            
+        

common/_layout/classic_load_save.rpym

@@ -0,0 +1,353 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    
+    # Define styles
+    style.file_picker_entry = Style(style.large_button, help="used to select a file to load or save")
+    style.file_picker_entry_box = Style(style.hbox, help="the box inside a file picker entry")
+
+    style.file_picker_text = Style(style.large_button_text, help="text inside a file picker entry")
+    style.file_picker_empty_slot = Style(style.file_picker_text, help="text inside an empty file picker entry slot")
+    style.file_picker_extra_info = Style(style.file_picker_text)
+    style.file_picker_new = Style(style.file_picker_text)
+    style.file_picker_old = Style(style.file_picker_text)
+
+    style.file_picker_frame = Style(style.menu_frame, help="the frame enclosing the entire file picker")
+    style.file_picker_frame_box = Style(style.vbox, help="the box containing the navbox and the grid of file picker entries")
+
+    style.file_picker_navbox = Style(style.hbox, help="the box containing navigation buttons")
+
+    style.file_picker_nav_button = Style(style.small_button, help="a file picker navigation button")
+    style.file_picker_nav_button_text = Style(style.small_button_text, help="file picker navigation button text")
+
+    style.file_picker_grid = Style(style.default, help="a grid containing file picker navigation buttons")
+
+    # Adjust styles.
+    style.file_picker_entry.xminimum = 0.5
+
+    style.file_picker_frame.xmargin = 6
+    style.file_picker_frame.ymargin = 6
+
+    style.file_picker_frame_box.box_spacing = 4            
+    style.file_picker_entry_box.box_spacing = 4
+    
+    # The number of columns per page of files.
+    config.file_page_cols = 2
+
+    if config.screen_width <= 640:
+        # The number of rows per page of files.
+        config.file_page_rows = 4
+
+        # The number of quick access pages.
+        config.file_quick_access_pages = 6
+    else:
+        config.file_page_rows = 5
+        config.file_quick_access_pages = 8
+
+    # True if we want to disable the file pager.
+    config.disable_file_pager = False
+
+    # True to suppress the display of thumbnails.
+    config.disable_thumbnails = False
+
+    # The default thumbnail to use when no file exists.
+    config.load_save_empty_thumbnail = None
+    
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # True if we should prompt before loading a game.
+    _load_prompt = True
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    __scratch = object()
+    __scratch.file_picker_page = None
+    
+    def _render_savefile(index, name, extra_info, screenshot, mtime, newest, clicked):
+
+        import time
+        
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  role=("selected_" if newest else ""),
+                  keymap={ "save_delete" : ui.returns(("unlink", name)) }
+                  )
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.add(screenshot)
+
+        if newest:
+            ui.text(name + ". ", style=style.file_picker_new[index])
+        else:
+            ui.text(name + ". ", style=style.file_picker_old[index])
+            
+        s = config.file_entry_format % dict(
+            time=time.strftime(config.time_format,
+                               time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.text(s, style=style.file_picker_extra_info[index])
+
+        ui.close()
+        
+    def _render_new_slot(index, name, clicked):
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked)
+
+        
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+
+            if config.load_save_empty_thumbnail:
+                ui.add(config.load_save_empty_thumbnail)
+            else:
+                ui.null(width=config.thumbnail_width,
+                        height=config.thumbnail_height)
+        
+        ui.text(name + ". ", style=style.file_picker_old[index])
+
+        ui.text(_(u"Empty Slot."), style=style.file_picker_empty_slot[index])
+        ui.close()
+
+
+    # Returns the names of the various pages that the file picker knows
+    # about.
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append(u"Auto")
+
+        if config.has_quicksave:
+            rv.append(u"Quick")
+
+        for i in range(1, config.file_quick_access_pages + 1):
+            rv.append(str(i))
+
+        return rv
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = config.file_page_cols * config.file_page_rows
+        rv = [ ]
+
+        if config.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), _(u"a") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if config.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), _(u"q") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = config.file_page_cols * config.file_page_rows
+
+        base = 0
+
+        if config.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if config.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        try:
+            return base + int((int(filename) - 1) / per_page)
+        except:
+            return base
+        
+    # Processes a screenshot.
+    def _file_picker_process_screenshot(s):
+        return s
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(screen, save):
+
+        # Should we update the list of saved games?
+        update = True
+        
+        while True:
+
+
+            if update:
+
+                update = False
+
+                # The number of slots in a page.
+                file_page_length = config.file_page_cols * config.file_page_rows
+
+                # The list of saved games.
+                saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+                # Figure out which game is the newest and so on.
+                newest = None
+                newest_mtime = None
+                save_info = { }
+
+                for fn, extra_info, screenshot, mtime in saved_games:
+                    screenshot = _file_picker_process_screenshot(screenshot)
+                    save_info[fn] = (extra_info, screenshot, mtime)
+
+                    if not fn.startswith("auto-") and mtime > newest_mtime:
+                        newest = fn
+                        newest_mtime = mtime
+
+                # The index of the first entry in the page.
+                fpp = __scratch.file_picker_page
+
+                if fpp is None:
+                    if newest:
+                        fpp = _file_picker_file_page(newest)
+                    else:
+                        fpp = _file_picker_file_page("1")
+
+            
+            if fpp < 0:
+                fpp = 0
+
+            __scratch.file_picker_page = fpp
+
+            # Show navigation
+            layout.navigation(screen)
+
+            ui.window(style='file_picker_frame')
+            ui.vbox(style='file_picker_frame_box') # whole thing.
+
+            if not config.disable_file_pager:
+
+                # Draw the navigation.
+                ui.hbox(style='file_picker_navbox') # nav buttons.
+
+                def tb(cond, label, clicked, selected):
+                    layout.button(label,
+                                  "file_picker_nav",
+                                  enabled=cond,
+                                  clicked=clicked,
+                                  selected=selected)
+
+                # Previous
+                tb(fpp > 0, u'Previous', ui.returns(("fppdelta", -1)), selected=False)
+    
+                # Quick Access
+                for i, name in enumerate(_file_picker_pages()):
+                    tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+                # Next
+                tb(True, u'Next', ui.returns(("fppdelta", +1)), False)
+
+                ui.close()
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                clicked = ui.returns(("return", filename))
+                
+                if filename not in save_info:
+                    if (not save) or ro:
+                        clicked = None
+
+                    _render_new_slot(offset, name, clicked)
+                else:
+                    if save and ro:
+                        clicked = None
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(offset,
+                                     name,
+                                     extra_info,
+                                     screenshot,
+                                     mtime,
+                                     newest == filename,
+                                     clicked)
+
+            ui.grid(config.file_page_cols,
+                    config.file_page_rows,
+                    style='file_picker_grid',
+                    transpose=True) # slots
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            ui.close() # slots
+            ui.close() # whole thing
+
+            result = ui.interact(mouse="gamemenu")
+            type, value = result
+
+            if type == "unlink":
+                if layout.yesno_prompt(screen, layout.DELETE_SAVE):
+                    renpy.unlink_save(value)
+                    update = True
+                    
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save", True)
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+
+        while True:
+            fn = _file_picker("load", False)
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load", layout.LOADING):
+                    continue
+
+            renpy.load(fn)

common/_layout/classic_main_menu.rpym

@@ -0,0 +1,60 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+    style.mm_menu_frame = Style(style.menu_frame, help="frame containing main menu")
+    style.mm_menu_frame_box = Style(style.vbox, help="box containing main menu buttons")
+
+    style.mm_button = Style(style.button, help="main menu button")
+    style.mm_button_text = Style(style.button_text, help="main menu button (text)")
+
+    style.mm_button.size_group = "mm"
+
+    style.mm_menu_frame.xpos = 5.0/6.0
+    style.mm_menu_frame.xanchor = 0.5
+    style.mm_menu_frame.ypos = 0.9
+    style.mm_menu_frame.yanchor = 1.0
+    
+label main_menu_screen:
+
+    python hide:
+
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+        
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ui.frame(style='mm_menu_frame')
+        ui.vbox(style='mm_menu_frame_box')
+
+        for e in config.main_menu:
+
+            if len(e) == 3:
+                label, clicked, enabled = e
+                shown = "True"
+            else:
+                label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            # This checks to see if clicked is a string. If so, we want clicked
+            # to jump us out of the current context.
+            if isinstance(clicked, basestring):
+                clicked=ui.jumpsoutofcontext(clicked)
+
+            # Create each button.
+            layout.button(label, "mm", enabled=eval(enabled), clicked=clicked)
+
+        ui.close()
+
+        ui.interact(mouse="mainmenu")
+        
+    return
+            
+    

common/_layout/classic_navigation.rpym

@@ -0,0 +1,53 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+
+    style.gm_nav_frame = Style(style.menu_frame, help="game menu navigation frame")
+    style.gm_nav_box = Style(style.vbox, help="box containing game menu navigation buttons")
+
+    style.gm_nav_button = Style(style.button, help="game menu navigation button")
+    style.gm_nav_button_text = Style(style.button_text, help="game menu navigation button (text)")
+
+    style.gm_nav_button.size_group = "gm_nav_button"
+    
+    style.gm_nav_frame.xpos = 5.0/6.0
+    style.gm_nav_frame.xanchor = 0.5
+    style.gm_nav_frame.ypos = 0.95
+    style.gm_nav_frame.yanchor = 1.0
+    
+    def _navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # Display the navigation frame.
+        ui.frame(style='gm_nav_frame')
+        ui.vbox(focus='gm_nav', style='gm_nav_box')
+
+        for e in config.game_menu:
+
+            if len(e) == 4:
+                 key, label, clicked, enabled = e
+                 shown = "True"
+            else:
+                 key, label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+                 
+            layout.button(label,
+                          "gm_nav",
+                          selected=(screen==key),
+                          enabled=eval(enabled),
+                          clicked=clicked)
+
+        ui.close()
+
+    layout.navigation = _navigation

common/_layout/classic_preferences.rpym

@@ -0,0 +1,86 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="preference columns")
+    style.prefs_left = Style(style.prefs_column, help="the left preference column")
+    style.prefs_center = Style(style.prefs_column, help="the center preference column")
+    style.prefs_right = Style(style.prefs_column, help="the right preference column")
+
+    # Customize styles.
+    style.prefs_pref_frame.xfill = True
+    style.prefs_column.xanchor = 0.5
+    
+    if config.screen_width <= 640:
+        style.prefs_pref_box.box_spacing = 6
+
+        style.prefs_column.xmaximum = 200
+        style.prefs_column.box_spacing = 5
+        style.prefs_frame.top_margin = 5
+        
+        style.prefs_left.xpos = 110
+        style.prefs_center.xpos = 320
+        style.prefs_right.xpos = 530
+
+        style.prefs_slider.xmaximum = 160
+        
+    else:
+        style.prefs_pref_box.box_spacing = 12
+
+        style.prefs_column.xmaximum = 250
+        style.prefs_column.box_spacing = 10
+        style.prefs_frame.top_margin = 10
+
+        style.prefs_left.xpos = 137
+        style.prefs_center.xpos = 400
+        style.prefs_right.xpos = 663
+
+        style.prefs_slider.xmaximum = 200
+        
+    style.prefs_pref_box.xfill = True
+    style.prefs_volume_box.xfill = True
+    style.prefs_pref_choicebox.xfill = True
+    style.prefs_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    style.prefs_slider.xalign = 1.0
+    style.soundtest_button.xalign = 1.0
+
+    style.prefs_button.size_group = "prefs"
+    style.prefs_jump_button.size_group = "prefs"
+    
+    # Place preferences into groups.
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+    config.preferences['prefs_center'] = [
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        ]
+
+
+label preferences_screen:
+
+    python hide:
+        _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+    

common/_layout/classic_preferences_common.rpym

@@ -0,0 +1,380 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+    
+    # Styles
+    style.prefs_frame = Style(style.default, help="the frame containing all of the preferences")
+    style.prefs_frame_box = Style(style.default, help="the box inside the frame containing all of the preferences")
+    
+    style.prefs_pref_frame = Style(style.menu_frame, help="a frame containing a single preference")
+    style.prefs_pref_box = Style(style.vbox, help="the box separating the preference label from the preference choices")
+    style.prefs_pref_choicebox = Style(style.vbox, help="the box containing the preference choices")
+
+    style.prefs_label = Style(style.label, help="a preference label (window)")
+    style.prefs_label_text = Style(style.label_text, help="a preference label (text)")
+
+    style.prefs_button = Style(style.radio_button, help="preference value button")
+    style.prefs_button_text = Style(style.radio_button_text, help="preference value button (text)")
+
+    style.prefs_slider = Style(style.slider, help="preference value slider bar")
+
+    style.prefs_volume_box = Style(style.vbox, help="box containing a volume slider and soundtest button")
+    style.prefs_volume_slider = Style(style.prefs_slider, help="volume slider bar")
+    
+    style.soundtest_button = Style(style.small_button, help="soundtest button")
+    style.soundtest_button_text = Style(style.small_button_text, help="soundtest button (text)")
+
+    style.prefs_jump = Style(style.prefs_pref_frame, help="jump preference frame")
+    style.prefs_jump_button = Style(style.button, help="jump preference button")
+    style.prefs_jump_button_text = Style(style.button_text, help="jump preference button (text)")
+    
+    # This is a map from the name of the style that is applied to
+    # a list of preferences that should be placed into a vbox
+    # with that style.
+    config.preferences = { }
+
+    # This is a map from preference name to that preference
+    # object, that can be used in rearranging preferences.
+    config.all_preferences = { }
+
+    # Should the soundtest button be before the volume slider?
+    config.soundtest_before_volume = False
+    
+    def _prefs_screen_run(prefs_map):
+
+        layout.navigation("preferences")
+        
+        ui.window(style='prefs_frame')
+        ui.fixed(style='prefs_frame_box')
+
+        for style, prefs in prefs_map.iteritems():
+
+            ui.vbox(style=style)
+            for i in prefs:
+                i.render()
+            ui.close()
+
+        ui.close()
+
+        ui.interact(mouse="gamemenu")
+
+    class _Preference(object):
+        """
+        This is a class that's used to represent a multiple-choice
+        preference.
+        """
+
+        def __init__(self, name, field, values, base=_preferences):
+            """
+            @param name: The name of this preference. It will be
+            displayed to the user.
+
+            @param variable: The field on the base object
+            that will be assigned the selected value. This field
+            must exist.
+
+            @param values: A list of value name, value, condition
+            triples. The value name is the name of this value that
+            will be shown to the user. The value is the literal
+            python value that will be assigned if this value is
+            selected. The condition is a condition that will be
+            evaluated to determine if this is a legal value. If no
+            conditions are true, this preference will not be
+            displayed to the user. A condition of None is always
+            considered to be True.
+
+            @param base: The base object on which the variable is
+               read from and set. This defaults to _preferences,
+               the user preferences object.
+            """
+
+            self.name = name
+            self.field = field
+            self.values = values
+            self.base = base
+
+            config.all_preferences[name] = self
+
+            
+        def render(self):
+            values = [ (name, val) for name, val, cond in self.values
+                       if cond is None or renpy.eval(cond) ]
+
+            if not values:
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            ui.hbox(style=style.prefs_pref_choicebox[self.name])
+
+            for name, value in values:
+                def clicked(value=value):
+                    setattr(self.base, self.field, value)
+                    return True
+
+                layout.button(name, "prefs",
+                              selected=(cur==value),
+                              clicked=clicked)
+
+            ui.close() # choicebox
+            ui.close() # vbox
+
+    class _VolumePreference(object):
+        """
+        This represents a preference that controls one of the
+        volumes in the system. It is represented as a slider bar,
+        and a button that can be pushed to play a sample sound on
+        a channel.
+        """
+
+        def __init__(self, name, mixer, enable='True', sound='None', channel="sound"):
+            """
+            @param name: The name of this preference, as shown to the user.
+
+            @param mixer: The mixer this preference controls.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+
+            @param sound: A string that is evaluated to yield
+            another string. The yielded string is expected to give
+            a sound file, which is played as the sample sound. (We
+            apologize for the convolution of this.)
+
+            @param channel: The number of the channel the sample
+            sound is played on.                
+            """
+
+            self.name = name
+            self.mixer = mixer
+            self.enable = enable
+            self.sound = sound
+            self.channel = channel
+
+            config.all_preferences[name] = self
+
+        def render(self):
+
+            if not eval(self.enable):
+                return
+
+            sound = eval(self.sound)
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            ui.vbox(style=style.prefs_volume_box[self.name])
+            
+            if sound:
+                def clicked():
+                    renpy.sound.play(sound, channel=self.channel)
+            
+            if sound and config.soundtest_before_volume:
+                layout.button(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            def changed(v):
+                _preferences.set_volume(self.mixer, v / 128.0)
+                
+            ui.bar(128,
+                   int(_preferences.get_volume(self.mixer) * 128),
+                   changed=changed,
+                   style=style.prefs_volume_slider[self.name])
+
+            if sound and not config.soundtest_before_volume:
+                layout.button(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            ui.close()
+            ui.close()
+
+    class _SliderPreference(object):
+        """
+        A class that represents a preference that is controlled by a
+        slider.
+        """
+
+        def __init__(self, name, field, range, enable='True', base=_preferences):
+            """
+            @param name: The name of this preference, that is shown to the user.
+
+            @param range: An integer giving the maximum value of
+            this slider. The slider goes from 0 to range.
+
+            @param get: A function that's called to get the
+            initial value of the slider. It's called with no
+            arguments, and should return an integet between 0 and
+            range, inclusive.
+
+            @param set: A function that's called when the value of
+            the slider is set by the user. It is called with a
+            single integer, in the range 0 to range, inclusive.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+            """
+
+            self.name = name
+            self.field = field
+            self.range = range
+            self.enable = enable
+            self.base = base
+            
+            config.all_preferences[name] = self
+
+        def get(self):
+            value = getattr(self.base, self.field)
+            if value == 0:
+                value = self.range
+            else:
+                value -= 1
+
+            return value
+
+        def set(self, value):
+            value += 1
+            if value == self.range + 1:
+                value = 0
+
+            setattr(self.base, self.field, value)
+            
+        def render(self):
+
+            if not eval(self.enable):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            def changed(v):
+                self.set(v)
+
+            ui.bar(self.range,
+                   self.get(),
+                   changed=changed,
+                   style=style.prefs_slider[self.name])
+
+            ui.close()
+
+
+    class _JumpPreference(object):
+
+        def __init__(self, name, target, condition="True", show="True"):
+            self.name = name
+            self.target = target
+            self.condition = condition
+            self.show = show
+            
+            config.all_preferences[name] = self
+
+        def render(self):
+
+            if not eval(self.show):
+                return
+            
+            ui.window(style=style.prefs_jump[self.name])
+
+            if eval(self.condition):
+                clicked=ui.jumps(self.target)
+            else:
+                clicked=None
+
+            layout.button(self.name, 'prefs_jump', clicked=clicked)
+
+    def _remove_preference(name):
+        """
+        Removes the preference with the given name from the
+        preferences menu.
+        """
+
+        pref = config.all_preferences.get(name, None)
+        if not pref:
+            return
+
+        for k, v in config.preferences.iteritems():
+            if pref in v:
+                v.remove(pref)
+            
+init python hide:
+
+    # Enablers for some preferences.
+    config.sample_sound = None
+    config.sample_voice = None
+    config.has_transitions = True
+    config.has_cps = True
+    config.has_afm = True
+    config.has_skipping = True
+    config.has_skip_after_choice = True
+    config.always_has_joystick = False
+    config.has_joystick = True
+    
+
+    # Left
+
+    _Preference(u'Display', 'fullscreen', [
+        (u'Window', False, None),
+        (u'Fullscreen', True, None),
+        ])
+
+    _Preference(u'Transitions', 'transitions', [
+        (u'All', 2, 'config.has_transitions'),
+        (u'Some', 1, 'config.has_transitions and default_transition'),
+        (u'None', 0, 'config.has_transitions'),
+        ])
+
+    # Center
+
+    _Preference(u'Skip', 'skip_unseen', [
+        (u'Seen Messages', False, 'config.allow_skipping and config.has_skipping'),
+        (u'All Messages', True, 'config.allow_skipping and config.has_skipping'),
+        ])
+
+    _JumpPreference(u'Begin Skipping',
+                    '_return_skipping',
+                    'not main_menu',
+                    'config.allow_skipping and config.has_skipping')
+    
+    
+    _Preference(u'After Choices', 'skip_after_choices', [
+        (u'Stop Skipping', False, 'config.allow_skipping and config.has_skip_after_choice'),
+        (u'Keep Skipping', True, 'config.allow_skipping and config.has_skip_after_choice'),
+        ])
+
+    config.old_names['Keep Skipping'] = 'Continue Skipping' 
+
+    _SliderPreference(u'Text Speed', "text_cps", 150, 'config.has_cps')
+    _SliderPreference(u'Auto-Forward Time', "afm_time", 40, 'config.has_afm')
+
+    # Right
+
+    _VolumePreference(u"Music Volume",
+                      'music',
+                      'config.has_music')
+
+    _VolumePreference(u"Sound Volume",
+                      'sfx',
+                      'config.has_sound',
+                      'config.sample_sound',
+                      'sound')
+
+    _VolumePreference(u'Voice Volume',
+                      'voice',
+                      'config.has_voice',
+                      'config.sample_voice',
+                      'voice')
+
+    _JumpPreference(u'Joystick...',
+                    'joystick_preferences_screen',
+                    'renpy.display.joystick.enabled or config.always_has_joystick',
+                    'config.has_joystick')
+

common/_layout/classic_yesno_prompt.rpym

@@ -0,0 +1,60 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+    
+    # Define styles
+    style.yesno_frame = Style(style.menu_frame, help="frame containing a yes/no prompt and yes/no buttons")
+    style.yesno_frame_vbox = Style(style.vbox, help="box separating yes/no prompt from yes/no buttons")
+
+    style.yesno_prompt = Style(style.prompt, help="a yes/no prompt")
+    style.yesno_prompt_text = Style(style.prompt_text, help="a yes/no prompt (text)")
+
+    style.yesno_button_hbox = Style(style.hbox, help="the box separating yes and no buttons")
+    style.yesno_button = Style(style.button, help="a yes or no button")
+    style.yesno_button_text = Style(style.button_text, help="a yes or no button (text)")
+
+    # Alter styles.
+    style.yesno_frame.xfill = True
+    style.yesno_frame.xmargin = .05
+    style.yesno_frame.ypos = .1
+    style.yesno_frame.yanchor = 0
+    style.yesno_frame.ypadding = .05
+    
+    style.yesno_frame_vbox.xalign = 0.5
+    style.yesno_frame_vbox.yalign = 0.5
+    style.yesno_frame_vbox.box_spacing = 30
+    
+    style.yesno_button_hbox.xalign = 0.5
+    style.yesno_button_hbox.spacing = 100
+
+    style.yesno_button.size_group = "yesno"
+    
+    def yesno_prompt(screen, message):
+        renpy.transition(config.intra_transition)
+
+        layout.navigation(screen)
+
+        ui.window(style='yesno_frame')
+        ui.vbox(style='yesno_frame_vbox')
+
+        layout.prompt(message, "yesno")
+
+        ui.hbox(style='yesno_button_hbox')
+        
+        # The extra nulls are because we want equal whitespace surrounding
+        # the two buttons. It should work as long as we have xfill=True
+        layout.button(u"Yes", 'yesno', clicked=ui.returns(True))
+        layout.button(u"No", 'yesno', clicked=ui.returns(False))
+
+        ui.close()
+        ui.close()
+
+        rv = ui.interact(mouse="gamemenu")
+        renpy.transition(config.intra_transition)
+        return rv
+
+    layout.yesno_prompt = yesno_prompt
+    

common/_layout/grouped_main_menu.rpym

@@ -0,0 +1,72 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+    style.mm_menu_frame = Style(style.menu_frame, help="frame containing main menu")
+    style.mm_outer_box = Style(style.vbox, help="outer box containing main menu buttons")
+    style.mm_inner_box = Style(style.hbox, help="inner box containing main menu buttons")
+    
+    style.mm_button = Style(style.button, help="main menu button")
+    style.mm_button_text = Style(style.button_text, help="main menu button (text)")
+
+    style.mm_menu_frame.xalign = 0.5
+    style.mm_menu_frame.yalign = 0.98
+    style.mm_inner_box.xalign = 0.5
+    
+    config.main_menu_per_group = 2
+
+
+label main_menu_screen:
+
+    python hide:
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ui.frame(style='mm_menu_frame')
+        ui.vbox(style='mm_outer_box')
+
+        inner_open = False
+        
+        for i, e in enumerate(config.main_menu):
+            
+            if len(e) == 3:
+                label, clicked, enabled = e
+                shown = "True"
+            else:
+                label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            if i % config.main_menu_per_group == 0:
+                if inner_open:
+                    ui.close()
+
+                ui.hbox(style='mm_inner_box')
+                inner_open = True
+                
+            # This checks to see if clicked is a string. If so, we want clicked
+            # to jump us out of the current context.
+            if isinstance(clicked, basestring):
+                clicked=ui.jumpsoutofcontext(clicked)
+
+            # Create each button.
+            layout.button(label, "mm", enabled=eval(enabled), clicked=clicked)
+
+        if inner_open:
+            ui.close() # inner box
+            
+        ui.close() # outer box
+
+        ui.interact(mouse="mainmenu")
+        
+    return
+            
+    

common/_layout/grouped_navigation.rpym

@@ -0,0 +1,69 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+
+    style.gm_nav_frame = Style(style.menu_frame, help="game menu navigation frame")
+    style.gm_nav_inner_box = Style(style.hbox, help="inner box containing game menu navigation buttons")
+    style.gm_nav_outer_box = Style(style.vbox, help="outer box containing game menu navigation buttons")
+
+    style.gm_nav_button = Style(style.button, help="game menu navigation button")
+    style.gm_nav_button_text = Style(style.button_text, help="game menu navigation button (text)")
+
+    style.gm_nav_button.size_group = "gm_nav_button"
+    
+    style.gm_nav_frame.xalign = 0.5
+    style.gm_nav_frame.ypos = 0.98
+    style.gm_nav_frame.yanchor = 1.0
+
+    style.gm_nav_inner_box.xalign = 0.5
+    
+    config.navigation_per_group = 4
+    
+    def navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # Display the navigation frame.
+        ui.frame(style='gm_nav_frame')
+        ui.vbox(focus='gm_nav', style='gm_nav_outer_box')
+
+        box_open = False
+        
+        for i, e in enumerate(config.game_menu):
+
+            if len(e) == 4:
+                 key, label, clicked, enabled = e
+                 shown = "True"
+            else:
+                 key, label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            if i % config.navigation_per_group == 0:
+                if box_open:
+                    ui.close()
+                    
+                ui.hbox(style='gm_nav_inner_box')
+                box_open = True
+                
+            layout.button(label,
+                          "gm_nav",
+                          selected=(screen==key),
+                          enabled=eval(enabled),
+                          clicked=clicked)
+
+        if box_open:
+            ui.close() # inner box.
+            
+        ui.close() # outer box.
+
+    layout.navigation = navigation

common/_layout/imagemap_common.rpym

@@ -0,0 +1,127 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+    
+    class _ImageMapper(object):
+
+        def __init__(self, screen, ground, idle, hover, selected_idle, selected_hover, hotspots, navigation=True, variant=None):
+
+            # If the argument is a dict, look up the screen in that dict, and
+            # return the result. Otherwise, just return the result.
+            def maybe_variant(a):
+                if isinstance(a, dict):
+                    if variant in a:
+                        return a[variant]
+                    else:                        
+                        return a[None]
+                return a
+
+            ground = maybe_variant(ground)
+            
+            self.idle = maybe_variant(idle) or ground
+            self.hover = maybe_variant(hover) or self.idle 
+            self.selected_idle = maybe_variant(selected_idle) or self.idle
+            self.selected_hover = maybe_variant(selected_hover) or self.hover
+            
+            self.hotspots = { }
+            for (x1, y1, x2, y2, name) in maybe_variant(hotspots):
+                self.hotspots[name] = (x1, y1, x2, y2)
+
+            self.remaining_hotspots = set(self.hotspots.keys())
+                
+            if navigation:
+
+                # Display the layout navigation only if there are no
+                # game menu buttons defined. 
+                for i in config.game_menu:
+                    if i[1] in self.hotspots:
+                        break
+                else:
+                    layout.navigation(screen)
+
+            ui.fixed(style='imagemap')
+            ui.image(ground)
+
+            if navigation:
+            
+                # Display any navigation buttons that exist.
+                for e in config.game_menu:
+                    screen_ = e[0]
+                    name = e[1]
+                    act = e[2]
+                    enable = e[3]
+
+                    if not eval(enable):
+                        continue
+
+                    self.button(name, act, screen == screen_)
+                
+        def button(self, name, clicked, selected, keymap={}):
+
+            if name not in self.hotspots:
+                return None
+
+            self.remaining_hotspots.discard(name)
+            
+            x1, y1, x2, y2 = self.hotspots[name]
+
+            if clicked is None:
+                return (x1, y1, x2, y2)
+            
+            if selected:
+                idle = self.selected_idle
+                hover = self.selected_hover
+            else:
+                idle = self.idle
+                hover = self.hover
+                
+            ui.imagebutton(
+                LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), idle),
+                LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), hover),
+                xpos=x1,
+                ypos=y1,
+                xanchor=0,
+                yanchor=0,
+                clicked=clicked,
+                focus_mask=True,
+                style='imagemap_button',
+                keymap=keymap,
+                )
+
+            return (x1, y1, x2, y2)
+
+            
+        def bar(self, name, range, value, changed):
+
+            if name not in self.hotspots:
+                return
+
+            self.remaining_hotspots.discard(name)
+
+            x1, y1, x2, y2 = self.hotspots[name]
+
+            ui.bar(
+                range,
+                value,
+                changed=changed,
+                left_gutter=0,
+                right_gutter=0,
+                left_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.selected_idle),
+                right_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.idle),
+                hover_left_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.selected_hover),
+                hover_right_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.hover),
+                bar_resizing=False,
+                xpos=x1,
+                ypos=y1,
+                xmaximum=(x2-x1),
+                ymaximum=(y2-y1),
+                thumb=None,
+                thumb_shadow=None,
+                thumb_offset=0)
+
+        def nothing(self, name):
+            self.remaining_hotspots.discard(name)
+            
+        def close(self):
+            ui.close()

common/_layout/imagemap_load_save.rpym

@@ -0,0 +1,354 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    renpy.load_module("_layout/imagemap_common")
+    
+    # The ground image.
+    config.load_save_ground = { }
+
+    # The idle image.
+    config.load_save_idle = { }
+
+    # The hover image.
+    config.load_save_hover = { }
+
+    # The selected idle image.
+    config.load_save_selected_idle = { }
+
+    # The selected hover image.
+    config.load_save_selected_hover = { }
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the button or slider this is equivalent to.
+    config.load_save_hotspots = { }
+    
+    # Define styles
+    style.file_picker_text = Style(style.large_button_text, help="text inside a file picker entry")
+    style.file_picker_empty_slot = Style(style.file_picker_text, help="text inside an empty file picker entry slot")
+    style.file_picker_text_window = Style(style.default, help="a window containing the file picker text.") 
+    style.file_picker_ss_window = Style(style.default, help="a window containing the screenshot.")
+
+    # Should we disable thumbnails?
+    config.disable_thumbnails = False
+    
+    # The default thumbnail to use when no file exists.
+    config.load_save_empty_thumbnail = None
+    
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # True if we should prompt before loading a game.
+    _load_prompt = True
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    __scratch = object()
+    __scratch.file_picker_page = None
+    __scratch.initialized = False
+    __scratch.per_page = 0
+    __scratch.pages = 0
+    __scratch.has_autosave = False
+    __scratch.has_quicksave = False
+    
+    def _render_savefile(ime, index, name, extra_info, screenshot, mtime, newest, clicked):
+
+        import time
+
+        (x1, y1, x2, y2) = ime.button(
+            "slot_%d" % index, clicked, newest,
+            keymap={ "save_delete" : ui.returns(("unlink", name)) })
+
+        ui.fixed(xpos=x1, ypos=y1, xmaximum=x2-x1, ymaximum=y2-y1)
+        
+        if not config.disable_thumbnails:
+            ui.window(style=style.file_picker_ss_window[index])
+            ui.add(screenshot)
+
+        s = name + ". " + config.file_entry_format % dict(
+            time=time.strftime(config.time_format,
+                               time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.window(style=style.file_picker_text_window[index])
+        ui.text(s, style=style.file_picker_text[index])
+
+        ui.close()
+        
+    def _render_new_slot(ime, index, name, clicked):
+
+        (x1, y1, x2, y2) = ime.button("slot_%d" % index, clicked, False)
+        
+        ui.fixed(xpos=x1, ypos=y1, xmaximum=x2-x1, ymaximum=y2-y1)
+
+        if not config.disable_thumbnails:
+
+            if config.load_save_empty_thumbnail:
+                ui.window(style=style.file_picker_ss_window[index])
+                ui.add(config.load_save_empty_thumbnail)
+        
+        ui.window(style=style.file_picker_text_window[index])
+        ui.text(name + ". " + _(u"Empty Slot.") + "\n", style=style.file_picker_empty_slot[index])
+
+        ui.close()
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = __scratch.per_page
+        rv = [ ]
+
+        if __scratch.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), _(u"a") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if __scratch.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), _(u"q") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = __scratch.per_page
+
+        base = 0
+
+        if __scratch.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if __scratch.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        try:
+            return base + int((int(filename) - 1) / per_page)
+        except:
+            return base
+        
+    # Processes a screenshot.
+    def _file_picker_process_screenshot(s):
+        return s
+
+    # Initialize the scratch information.
+    def _file_picker_init():
+
+        hotspots = set()
+
+        if isinstance(config.load_save_hotspots, dict):
+            for d in config.load_save_hotspots.values():
+                for (x1, y1, x2, y2, name) in d:
+                    hotspots.add(name)
+        else:
+            for (x1, y1, x2, y2, name) in config.load_save_hotspots:
+                hotspots.add(name)
+
+        __scratch.has_autosave = ("page_auto" in hotspots)
+        __scratch.has_quicksave = ("page_quick" in hotspots)
+
+        __scratch.per_page = 0
+
+        while ("slot_%d" % __scratch.per_page) in hotspots:
+            __scratch.per_page += 1
+
+        __scratch.pages = 1
+            
+        while ("page_%d" % __scratch.pages) in hotspots:
+            __scratch.pages += 1
+
+        __scratch.pages -= 1
+
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append("page_auto")
+
+        if config.has_quicksave:
+            rv.append("page_quick")
+
+        for i in range(1, __scratch.pages + 1):
+            rv.append("page_%d" % i)
+
+        return rv
+           
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(screen, save):
+
+        if not __scratch.initialized:
+            __scratch.initialized = True
+            _file_picker_init()
+        
+        # The number of slots in a page.
+        file_page_length = __scratch.per_page
+
+        update = True
+        
+        while True:
+
+            if update:
+                
+                update = False
+                
+                saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+                newest = None
+                newest_mtime = None
+                save_info = { }
+
+                for fn, extra_info, screenshot, mtime in saved_games:
+                    screenshot = _file_picker_process_screenshot(screenshot)
+                    save_info[fn] = (extra_info, screenshot, mtime)
+
+                    if not fn.startswith("auto-") and mtime > newest_mtime:
+                        newest = fn
+                        newest_mtime = mtime
+
+                # The index of the first entry in the page.
+                fpp = __scratch.file_picker_page
+
+                if fpp is None:
+
+                    if newest:
+                        fpp = _file_picker_file_page(newest)
+                    else:
+                        fpp = _file_picker_file_page("1")
+
+
+            if fpp < 0:
+                fpp = 0
+
+            __scratch.file_picker_page = fpp
+
+            ime = _ImageMapper(
+                screen,
+                config.load_save_ground,
+                config.load_save_idle,
+                config.load_save_hover,
+                config.load_save_selected_idle,
+                config.load_save_selected_hover,
+                config.load_save_hotspots,
+                variant=screen)
+                
+
+            def tb(enabled, label, clicked, selected):
+
+                if not enabled:
+                    return
+
+                ime.button(label, clicked, selected)
+
+            # Previous
+            tb(fpp > 0, 'previous', ui.returns(("fppdelta", -1)), selected=False)
+
+            # Quick Access
+            for i, name in enumerate(_file_picker_pages()):
+                tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+            # Next
+            tb(True, 'next', ui.returns(("fppdelta", +1)), False)
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                clicked = ui.returns(("return", filename))
+                
+                if filename not in save_info:
+                    if (not save) or ro:
+                        clicked = None
+
+                    _render_new_slot(ime, offset, name, clicked)
+
+                else:
+                    if save and ro:
+                        clicked = None
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(ime,
+                                     offset,
+                                     name,
+                                     extra_info,
+                                     screenshot,
+                                     mtime,
+                                     newest == filename,
+                                     clicked)
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            ime.close()
+                
+            result = ui.interact(mouse="gamemenu")
+            type, value = result
+
+            if type == "unlink":
+                if layout.yesno_prompt(screen, layout.DELETE_SAVE):
+                    renpy.unlink_save(value)
+                    update = True
+
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save", True)
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("load", False)
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load",  layout.LOADING):
+                    continue
+
+            renpy.load(fn)

common/_layout/imagemap_main_menu.rpym

@@ -0,0 +1,80 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+    renpy.load_module("_layout/imagemap_common")
+
+    # The ground image.
+    config.main_menu_ground = { }
+
+    # The selected/hover image.
+    config.main_menu_selected = { }
+
+    # The idle image.
+    config.main_menu_idle = { }
+    
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - Either the (untranslated) name of the main menu button this hotspot
+    #   is equivalent to, or, a label in the program to jump to when this
+    #   hotspot is clicked.
+    config.main_menu_hotspots = { }
+
+    # This can be set from user code to define the main menu variant to use.
+    _main_menu_variant = None
+    
+label main_menu_screen:
+
+    python hide:
+        
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+        
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ime = _ImageMapper(
+            None,
+            config.main_menu_ground,
+            config.main_menu_idle,
+            config.main_menu_selected,
+            config.main_menu_idle,
+            config.main_menu_selected,
+            config.main_menu_hotspots,
+            navigation=False,
+            variant=_main_menu_variant)
+            
+        for e in config.main_menu:
+            if len(e) == 4:
+                name, act, enabled, shown = e
+            else:
+                name, act, enabled = e
+                shown = "True"
+                
+            if not eval(shown):
+                ime.nothing(name)
+
+            if not eval(enabled):
+                act = None
+
+            if isinstance(act, basestring):
+                act = ui.jumpsoutofcontext(act)
+                
+            ime.button(name, act, False)
+
+        for i in list(ime.remaining_hotspots):
+            ime.button(i, ui.jumpsoutofcontext(i), None)
+
+        ime.close()
+        ui.interact(mouse='mainmenu')
+                    
+    jump main_menu_screen
+            
+            
+    

common/_layout/imagemap_navigation.rpym

@@ -0,0 +1,85 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+    
+    # The ground image.
+    config.navigation_ground = None
+
+    # The idle image.
+    config.navigation_idle = None
+
+    # The hover image.
+    config.navigation_hover = None
+
+    # The selected idle image.
+    config.navigation_selected_idle = None
+
+    # The selected hover image.
+    config.navigation_selected_hover = None
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the game menu button this is equivalent to.
+    config.navigation_hotspots = None
+
+    def _navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # A map from button name to game menu information.
+        gm = dict()
+        
+        for e in config.game_menu:
+            screen_ = e[0]
+            name_ = e[1]
+            act = e[2]
+            enable = e[3]
+
+            gm[name_] = (screen_, act, enable)
+
+        ui.fixed(style='imagemap')
+        ui.image(config.navigation_ground)
+            
+        for (x0, y0, x1, y1, name) in config.navigation_hotspots:
+
+            if name not in gm:
+                raise Exception("%r was used in a game menu hotspot, but isn't the name of a game menu button." % name)
+
+            screen_, act, enable = gm[name]
+
+            if not eval(enable):
+                continue
+            
+            if screen_ == screen:
+                idle = config.navigation_selected_idle
+                hover = config.navigation_selected_hover
+            else:
+                idle = config.navigation_idle
+                hover = config.navigation_hover
+            
+            ui.imagebutton(
+                LiveCrop((x0, y0, x1-x0, y1-y0), idle),
+                LiveCrop((x0, y0, x1-x0, y1-y0), hover),
+                clicked=act,
+                style='imagemap_button',
+                xpos=x0,
+                ypos=y0,
+                xanchor=0,
+                yanchor=0,
+                focus_mask=True,
+                )
+
+        ui.close()
+
+    layout.navigation = _navigation

common/_layout/imagemap_preferences.rpym

@@ -0,0 +1,147 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    renpy.load_module("_layout/imagemap_common")
+    
+    # The ground image.
+    config.preferences_ground = None
+
+    # The idle image.
+    config.preferences_idle = None
+
+    # The hover image.
+    config.preferences_hover = None
+
+    # The selected idle image.
+    config.preferences_selected_idle = None
+
+    # The selected hover image.
+    config.preferences_selected_hover = None
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the button or slider this is equivalent to.
+    config.preferences_hotspots = None
+
+    config.sample_sound = None
+    config.sample_voice = None
+    config.always_has_joystick = False
+
+    def __set(base, field, value):
+        setattr(base, field, value)
+        return True
+
+    __curried_set = renpy.curry(__set)
+
+
+    def __show_preferences():
+
+        ime = _ImageMapper(
+            "preferences",
+            config.preferences_ground,
+            config.preferences_idle,
+            config.preferences_hover,
+            config.preferences_selected_idle,
+            config.preferences_selected_hover,
+            config.preferences_hotspots)
+
+        def pref(name, pref, value):
+            ime.button(
+                name,
+                __curried_set(_preferences, pref, value),
+                getattr(_preferences, pref) == value) 
+            
+        pref("Window", "fullscreen", False)
+        pref("Fullscreen", "fullscreen", True)
+
+        pref("All", "transitions", 2)
+        pref("Some", "transitions", 1)
+        pref("None", "transitions", 0)
+
+        pref("Seen Messages", "skip_unseen", False)
+        pref("All Messages", "skip_unseen", True)
+
+        if not main_menu:
+            ime.button("Begin Skipping", ui.jumps("_return_skipping"), False)
+            
+        pref("Stop Skipping", "skip_after_choices", False)
+        pref("Keep Skipping", "skip_after_choices", True)
+
+        if renpy.display.joystick.enabled or config.always_has_joystick:
+            ime.button("Joystick", ui.jumps("joystick_preferences_screen"), False)
+
+        def play_sound():
+            renpy.music.play(config.sample_sound, channel="sound")
+
+        ime.button("Sound Test", play_sound, False)
+
+        def play_voice():
+            renpy.music.play(config.sample_sound, channel="voice")
+
+        ime.button("Voice Test", play_voice, False)
+
+        v = _preferences.text_cps
+        if v == 0:
+            v = 150
+        else:
+            v = v - 1
+
+        def set_text_cps(v):
+            if v == 150:
+                v = 0
+            else:
+                v = v + 1
+
+            _preferences.text_cps = v
+
+        ime.bar("Text Speed", 150, v, set_text_cps)
+        
+        v = _preferences.afm_time
+        if v == 0:
+            v = 40
+        else:
+            v = v - 1
+
+        def set_afm_time(v):
+            if v == 40:
+                v = 0
+            else:
+                v = v + 1
+
+            _preferences.afm_time = v
+                
+        ime.bar("Auto-Forward Time", 40, v, set_afm_time)
+
+        def set_music(v):
+            _preferences.set_volume('music', v / 128.0)
+        def set_sound(v):
+            _preferences.set_volume('sfx', v / 128.0)
+        def set_voice(v):
+            _preferences.set_volume('voice', v / 128.0)
+
+        if config.has_music:
+            ime.bar("Music Volume", 128, int(_preferences.get_volume('music') * 128), set_music)            
+        if config.has_sound:
+            ime.bar("Sound Volume", 128, int(_preferences.get_volume('sfx') * 128), set_sound)
+        if config.has_voice:
+            ime.bar("Voice Volume", 128, int(_preferences.get_volume('voice') * 128), set_voice)
+        
+        ime.close()
+        ui.interact(mouse="gamemenu")
+        
+label preferences_screen:
+
+    while True:
+        $ __show_preferences()
+
+
+        
+        
+
+            

common/_layout/imagemap_yesno_prompt.rpym

@@ -0,0 +1,53 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+
+    renpy.load_module("_layout/imagemap_common")
+    
+    # Define styles
+    style.yesno_prompt = Style(style.prompt, help="a yes/no prompt")
+    style.yesno_prompt_text = Style(style.prompt_text, help="a yes/no prompt (text)")
+
+    # Define config variables.
+    config.yesno_prompt_ground = None
+    config.yesno_prompt_idle = None
+    config.yesno_prompt_hover = None
+    config.yesno_prompt_hotspots = None
+
+    config.yesno_prompt_message_images = { }
+
+    
+    def yesno_prompt(screen, message):
+        renpy.transition(config.intra_transition)
+        
+        ime = _ImageMapper(
+            screen,
+            config.yesno_prompt_ground,
+            config.yesno_prompt_idle,
+            config.yesno_prompt_hover,
+            config.yesno_prompt_idle,
+            config.yesno_prompt_hover,
+            config.yesno_prompt_hotspots)
+
+        ime.button("Yes", ui.returns(True), False)
+        ime.button("No", ui.returns(False), False)
+
+        ime.close()
+        
+        default = config.yesno_prompt_message_images.get(layout.ARE_YOU_SURE, None)
+        message_image = config.yesno_prompt_message_images.get(message, default)
+        
+        if message_image:
+            ui.add(message_image)
+        else:
+            layout.prompt(message, "yesno")
+
+        rv = ui.interact(mouse="gamemenu")
+        renpy.transition(config.intra_transition)
+        return rv
+
+    layout.yesno_prompt = yesno_prompt
+    

common/_layout/one_column_preferences.rpym

@@ -0,0 +1,71 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="the single preferences column")
+
+    style.prefs_frame.set_parent(style.menu_frame)
+    style.prefs_pref_frame.set_parent(style.default)
+
+    # Adjust styles.
+    style.prefs_frame_box.box_layout = 'vertical'
+
+    style.prefs_frame.xalign = 0.0
+    style.prefs_frame.ypos = 10
+    style.prefs_frame.xmargin = 10
+    
+    style.prefs_slider.xmaximum = 200
+    style.prefs_slider.xalign = 1.0
+
+    style.prefs_volume_slider.xmaximum = 200
+    style.prefs_volume_slider.xalign = 1.0
+    style.prefs_volume_box.xalign = 1.0
+    style.prefs_volume_box.box_layout = 'horizontal'
+
+    style.prefs_pref_box.xfill = True
+    style.prefs_pref_box.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.xalign = 1.0
+
+    style.prefs_jump.xfill = True
+    
+    style.prefs_column.box_spacing = 5
+
+    style.soundtest_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    
+    config.translations["Fullscreen 16:9"] = "16:9"
+    config.translations["Fullscreen 16:10"] = "16:10"
+
+    config.soundtest_before_volume = True
+    
+    
+    # Place preferences into groups.
+    config.preferences['prefs_column'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+
+label preferences_screen:
+
+    $ _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+    

common/_layout/screen_joystick_preferences.rpym

@@ -0,0 +1,16 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('joystick_preferences')
+
+label joystick_preferences_screen:
+
+    $ renpy.show_screen('joystick_preferences')
+    $ ui.interact()
+
+    jump _noisy_return
+    
+
+

common/_layout/screen_load_save.rpym

@@ -0,0 +1,19 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+
+label load_screen:
+
+    $ renpy.show_screen('load')
+    $ ui.interact()
+    jump _noisy_return
+
+label save_screen:
+
+    $ renpy.show_screen('save')
+    $ ui.interact()
+    jump _noisy_return
+

common/_layout/screen_main_menu.rpym

@@ -0,0 +1,14 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+label main_menu_screen:
+    
+    $ renpy.show_screen("main_menu")
+    $ ui.interact()
+    
+    return
+

common/_layout/screen_preferences.rpym

@@ -0,0 +1,16 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+
+label preferences_screen:
+
+    $ renpy.show_screen('preferences')
+    $ ui.interact()
+    
+    jump _noisy_return
+    
+
+

common/_layout/screen_yesno_prompt.rpym

@@ -0,0 +1,12 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+
+    def yesno_prompt(screen, message):
+        rv = renpy.call_screen('yesno_prompt', message=message, yes_action=Return(True), no_action=Return(False))
+        return rv
+    
+    layout.yesno_prompt = yesno_prompt

common/_layout/scrolling_load_save.rpym

@@ -0,0 +1,229 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    
+    # Store some global information that won't be saved.
+    __session = object()
+    __session.scrollbar_position = None
+
+    # Should we prompt to load?
+    _load_prompt = True
+    
+    # The number of normal save slots.
+    config.load_save_slots = 50
+
+    # The number of autosave slots.
+    config.load_save_auto_slots = 5
+
+    # The number of quicksave slots.
+    config.load_save_quick_slots = 5
+
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # Set the default size of thumbnails.
+    config.thumbnail_width = 320
+    config.thumbnail_height = 240
+
+    # The default empty slot thumbnail.
+    config.load_save_empty_thumbnail = None
+    
+    # Styles.
+    style.file_picker_frame = Style(style.frame, help="frame containing the file picker")
+    style.file_picker_side = Style(style.default, help="ui.side containing the file picker and the scrollbars")
+    style.file_picker_viewport = Style(style.viewport, help="viewport containing the file picker entries")
+    style.file_picker_box = Style(style.vbox, help="box containing the file picker entries")
+    style.file_picker_entry = Style(style.large_button, help="the buttons containing information about each file")
+    style.file_picker_text = Style(style.large_button_text, help="the text inside a file picker entry.")
+    style.file_picker_scrollbar = Style(style.vscrollbar, help="the text inside a file picker entry.")
+
+    style.thumbnail_frame = Style(style.frame, help="the style of the frame containing a thumbnail")
+
+
+    # Position things correctly.
+    style.file_picker_frame.xmaximum = 0.5
+    style.file_picker_frame.xmargin = 6
+    style.file_picker_frame.ymargin = 6
+    style.file_picker_frame.yfill = True
+    
+    style.file_picker_entry.xfill = True
+    style.file_picker_entry.yminimum = 58
+    
+    style.thumbnail_frame.ymargin = 6
+    style.thumbnail_frame.xpos = 0.75
+    style.thumbnail_frame.xanchor = 0.5
+    
+    def _file_picker_thumbnail(st, at):
+        if __session.thumbnail:
+            rv = __session.thumbnail
+        elif config.load_save_empty_thumbnail:
+            rv = config.load_save_empty_thumbnail
+        else:
+            rv = Null(width=config.thumbnail_width, height=config.thumbnail_height)
+            
+        return rv, None
+            
+            
+    def _file_picker(screen):
+
+        while True:
+
+            @renpy.curry
+            def hovered(thumbnail):
+                if __session.thumbnail is not thumbnail:
+                    __session.thumbnail = thumbnail
+                    renpy.restart_interaction()
+
+            @renpy.curry
+            def unhovered(thumbnail):
+                if __session.thumbnail is thumbnail:
+                    __session.thumbnail = None
+                    renpy.restart_interaction()
+
+            __session.thumbnail = None
+
+            layout.navigation(screen)
+
+            newest = None
+            newest_time = None
+
+            info = { }
+
+            for name, extra_info, thumbnail, time in renpy.list_saved_games():
+
+                info[name] = (extra_info, thumbnail, time)
+
+                if not name[0] in "0123456789":
+                    continue
+
+                if time > newest_time:
+                    newest = name
+                    newest_time = time
+
+            slots = [ ]
+
+            for i in range(1, config.load_save_slots + 1):
+                slots.append((str(i), str(i)))
+
+            if config.has_quicksave:
+                for i in range(1, config.load_save_quick_slots + 1):
+                    slots.append(('quick-'+ str(i), _(u'q') + str(i)))
+
+            if config.has_autosave:
+                for i in range(1, config.load_save_auto_slots + 1):
+                    slots.append(('auto-' + str(i), _(u'a') + str(i)))
+
+            ui.frame(style=style.file_picker_frame)
+            ui.side(['c', 'r'], style=style.file_picker_side)
+
+
+
+            if __session.scrollbar_position is None:
+                if newest is None:
+                    yoffset = 0
+                else:
+                    yoffset = 1.0 * (int(newest) - 1) / len(slots)
+                value = 0
+
+            else:
+                value = __session.scrollbar_position
+                yoffset = None
+
+            adj = ui.adjustment(value=value)
+            ui.viewport(yadjustment=adj, offsets=(0, yoffset), style=style.file_picker_viewport, mousewheel=True)
+
+            ui.vbox(style=style.file_picker_box, focus=renpy.time.time())
+
+
+            for i, (fn, n) in enumerate(slots):
+
+                clicked = ui.returns(("select", fn))
+
+                if screen == "save" and fn.startswith("auto-"):
+                    clicked = None
+
+                if screen == "load" and fn not in info:
+                    clicked = None
+
+                if fn in info:
+                    extra_info, thumbnail, time = info[fn]
+
+                    ui.button(style=style.file_picker_entry[i],
+                              clicked=clicked,
+                              hovered=hovered(thumbnail),
+                              unhovered=unhovered(thumbnail),
+                              role = "selected_" if (fn == newest) else "",
+                              keymap = { "save_delete" : ui.returns(("unlink", fn)) },
+                              )
+
+                    s = config.file_entry_format % dict(
+                        time=renpy.time.strftime(
+                            config.time_format,
+                            renpy.time.localtime(time)),
+                        save_name=extra_info)
+
+                    ui.text(n + ". " + s, style=style.file_picker_text[i])
+
+                else:
+                    ui.button(style=style.file_picker_entry[i],
+                              clicked=clicked,
+                              role = "selected_" if (fn == newest) else "")
+
+                    ui.text(n + ". " + _(u"Empty Slot."),
+                            style=style.file_picker_text[i])
+
+            ui.close() # vbox/viewport
+
+            ui.bar(adjustment=adj, style=style.file_picker_scrollbar)
+
+            ui.close() # side/window
+
+            # Thumbnail.
+            ui.frame(style=style.thumbnail_frame)
+            ui.add(DynamicDisplayable(_file_picker_thumbnail))
+
+            try:
+                action, arg = ui.interact(mouse="gamemenu")
+            finally:
+                __session.scrollbar_position = adj.value
+                __session.thumbnail = None
+
+            if action == "select":
+                return arg
+
+            elif action == "unlink":
+                if layout.yesno_prompt("save", layout.DELETE_SAVE):
+                    renpy.unlink_save(arg)
+        
+        
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save")
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+
+        while True:
+            fn = _file_picker("load")
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load",  layout.LOADING):
+                    continue
+
+            renpy.load(fn)

common/_layout/two_column_preferences.rpym

@@ -0,0 +1,81 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="columns of preferences")
+    style.prefs_left = Style(style.prefs_column, help="the left preference column")
+    style.prefs_right = Style(style.prefs_column, help="the right preference column")
+
+    style.prefs_left.xmaximum = 520
+    style.prefs_right.xmaximum = 250
+
+    style.prefs_left.xpos = 271
+    style.prefs_left.xanchor = 0.5
+    style.prefs_left.ypos = 10
+    
+    style.prefs_right.xpos = 667
+    style.prefs_right.xanchor = 0.5
+    style.prefs_right.ypos = 10
+
+    style.prefs_slider.xmaximum = 400
+    style.prefs_slider.xalign = 1.0
+
+    style.prefs_volume_slider.xmaximum = 200
+    style.prefs_volume_slider.xalign = 1.0
+    
+    style.prefs_pref_box.xfill = True    
+    style.prefs_pref_choicebox.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.xalign = 1.0
+    style.prefs_volume_box.xalign = 1.0
+
+    style.prefs_jump.xfill = True
+    
+    style.prefs_column.box_spacing = 5
+
+    style.prefs_button.set_parent(style.small_button)
+    style.prefs_button_text.set_parent(style.small_button_text)
+
+    style.soundtest_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    
+    
+    config.sample_voice = "18005551212.ogg"
+    
+    config.translations["Fullscreen 16:9"] = "16:9"
+    config.translations["Fullscreen 16:10"] = "16:10"
+
+    
+    
+    
+    # Place preferences into groups.
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+
+label preferences_screen:
+
+    $ _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+