Remove unnecessary change.

Use the 6.11.2 (hacky) frame code when using the software renderer, to
prevent visual artifacts.
2011-01-30 20:46:41 -05:00 · 2011-01-30 20:38:14 -05:00 · 2011-01-30 19:47:49 -05:00 · 2011-01-30 09:19:21 -05:00 · 2011-01-30 09:03:36 -05:00 · 2011-01-30 08:35:54 -05:00
373 changed files with 46733 additions and 13276 deletions
@@ -5,10 +5,6 @@ renpy.app
 **/*.rpyc
 **/*.rpyb
 **/*.rpymc
-_renpy.c
-nativemidi.c
-sound.c
-winmixer.c
 jedit
 lint.txt
 renpy.code
@@ -53,4 +49,52 @@ renpygame-1.2.zip
 speedtest
 styles.txt
 renpygame-demo/game/saves
-./lib
+Lucy Sprites.zip
+translate
+close_bugs.py
+.logplayer
+scite-6.10.zip
+scite-renpy-20090803.zip
+module/cython.sh
+old_demo
+opengl.txt
+Microsoft.VC90.CRT.manifest
+console.exe
+msvcr90.dll
+python26.dll
+renpy.exe
+lib/windows-x86
+sphinx/source/inc/*
+doc/*
+updates/prerelease
+module/render.c
+module/_renpy.c
+module/_renpy_pysdlgl.c
+module/_renpybidi.c
+module/sound.c
+module/winmixer.c
+module/accelerator.html
+module/gldraw.html
+module/glenviron_fixed.html
+module/glenviron.html
+module/glenviron_limited.html
+module/glenviron_shader.html
+module/glrtt_copy.html
+module/glshader.html
+module/gltexture.html
+module/render.html
+module/accelerator.c
+module/gldraw.c
+module/glenviron.c
+module/glenviron_fixed.c
+module/glenviron_limited.c
+module/glenviron_shader.c
+module/glrtt_copy.c
+module/glshader.c
+module/gltexture.c
+log.txt
+lib/linux-x86
+lib/python
+lib/update-version.txt
+sphinx/game/saves
+tutorial/game/saves
@@ -1,3 +1,295 @@
+
+New in Ren'Py 6.10.2
+--------------------
+
+Ren'Py now caches the individual words of text that are rendered. This
+can lead to a speedup in text display when there are many words of
+text on the screen, and that text is re-displayed, as is the case
+where the text text speed is not the maximum. This is especially 
+beneficial for eastasian languages, where every character is treated
+as a word.
+
+
+The new config.menu_clear_layers variable allows layers to be cleared 
+when entering the game menu. This makes it easier for a layer to have 
+overlay-like things on it when in the game, but not when in the game
+menu.
+
+
+The new renpy.cache_pin function pins images into memory, loading them
+as soon as possible and keeping them loaded. The renpy.cache_unpin function
+undoes this.
+
+
+The new config.automatic_images_strip variable can strip out prefixes
+when automatically defining images.
+
+
+It's now possible to assign style properties to individual imagemap
+buttons, by indexing style.imagemap_button. (So for example, one could 
+assign to style.imagemap_button["Start Game"].hover_sound .)
+
+
+The new voice_replay function replays the voice played on the current
+interaction. The new voice_can_replay function returns True if a voice
+can be replayed.
+
+
+The launcher now accepts a RENPY_DEFAULT_PROJECTS_DIRECTORY, which sets
+the default for the projects directory, if it has not already been set 
+by the user. It also will report an error when creating a project fails,
+rather than producing a traceback.
+
+
+The launcher now links to the new Ren'Py Games List, at
+http://games.renpy.org/.
+
+
+Previously, it was impossible to pass an arguments list to a call
+expression. Now, we allow the pass keyword to be used to distinguish 
+the two, using code like:
+
+call expression foo pass (bar, baz)
+
+
+Ren'Py will now not show the click-to-continue indicator when a
+character is called with interact=False, unless that character is also
+called with ctc_force=True.
+
+
+Ren'Py now builds zip files in distributions 64k at a time. 
+
+
+Ren'Py will now ignore music files that do not exist. Previously, it
+could loop trying to play them. (This would increase CPU usage, rather
+than causing a crash.)
+
+
+The following numbered bugs were fixed:
+
+* lp:501351 - Displaying a Frame() with tile=True crashes
+* lp:506322 - MoveTransition is not applied to overlay even when explicitly stated
+
+In addition:
+
+* Fixed a bug that caused pixellate to crash.
+* Fixed a bug that caused the overlay to display twice in some cases.
+* Fix an infinite loop that could rarely occur when rolling back or saving.
+
+
+
+New in Ren'Py 6.10.1
+--------------------
+
+Images and other surfaces are now created with a 1px transparent border
+around them. This change allows transform to work correctly with a 1:1
+scale, where as previously Ren'Py would blur the image slightly, while
+trying to ensure it never accessed a pixel outside of the original 
+image bounds.
+
+
+ATL now has a "function" statement, which allows an ATL transform to
+use the same functions that are supplied to Transform.
+
+
+The layout.imagemap_main_menu and layout.imagemap_load_save functions 
+now allow one to define variant screens. This allows one to select an 
+imagemap main menu screen to use, or to define different screens for
+loading and saving.
+
+
+The overlay semantics were changed such that transitions apply to overlays
+in the same way they apply to everything else. (So, for example, dissolves
+will apply to overlays.)
+
+
+The image text tag can now take any textual image representation. So 
+something like {image=eileen happy} is legal, if odd.
+
+
+The following numbered bugs were fixed:
+
+lp:366412 - Ren'Py could crash on shift+R at the main menu, under some circumstances.
+
+lp:485631 - The transfer of state from a transfrom to a transform  supplied as part of an image didn't work.
+
+lp:487688 - non-ASCII characters didn't display in the window title bar.
+
+lp:487701 - Ren'Py didn't work when in a directory containing non-ASCII characters.
+
+lp:488814 - Scaling to the same size could blur an image.
+
+lp:489212 - Interpolation didn't work when the starting value was None.
+
+lp:493062 - One could roll back into an imagemap main menu.
+
+lp:494779 - The window shown state wasn't being tracked correctly.
+
+lp:494820 - Error handling in ATL hid too many error messages.
+
+A major bug that caused Ren'Py to fail as scaling was enabled was fixed.
+
+A number of minor bugs revealed by pyflakes were fixed.
+
+
+
+New in Ren'Py 6.10.0
+--------------------
+
+The demo game is in the process of being converted into a new tutorial
+game, which shows recommended Ren'Py code examples rather than
+requiring the user to learn from the game itself's source code.
+
+
+Ren'Py now supports an Animation and Transformation language
+(ATL). This provides a convenient syntax for animating an image, or
+transforming it by positioning it, rotating it, zooming it, and
+adjusting its opacity.
+
+To a large extent, ATL supersedes the Animation, TransitionAnimation,
+anim.SMAnimation, anim.Blink, Zoom, FactorZoom, RotoZoom, SizeZoom,
+LiveCrop, Move, Pan, Position, Motion, and Revolve functions, and
+perhaps others. As it allows properties to be scripted, ATL is more
+powerful that all of these functions. (For example, many of these
+functions can only do relatively simple repeats, while ATL allows
+complex patterns to be easily specified.)
+
+ATL can be used in the new transform statement, and new variants of
+the image, scene, and show statements.
+
+
+When an image is shown, Ren'Py checks to see if there was a previous
+image with that tag, and if that image used a transform. If this is
+true, Ren'Py does two things:
+
+# If the new image is not a transform, it wraps it in a transform.
+# The transform is initialized to have the properties of the old transform.
+
+The generally has the effect of "remembering" the position of images
+shown on the screen. In some cases, this memory effect may override a
+position encoded into an image. In that case, the image must be hidden
+and shown again.
+
+
+The default positions (left, right, center, truecenter, offscreenleft,
+and offscreenright) are now defined as ATL transforms. This means that showing
+an image at such a position will cause the position to be remembered.
+
+
+Support for Arabic and Hebrew has been added to Ren'Py. To enable this
+support, config.rtl needs to be set to True. It may also be necessary
+to set various style properties to do a credible job of right-to-left 
+layout.)
+
+
+The freetype library has been updated, and we have added support for
+the use of TrueType collections. Using a name of 0@font.ttc will get
+the first font in the collection, 1@font.ttc will get the second font,
+and so on.
+
+
+The displayable code has been adjusted to consider strings that do not
+contain at least one dot as image references. Now, one can write
+"eileen happy" to refer to an image with that name.
+
+
+A pause statement has been added to Ren'Py. 
+
+
+The new config.auto_load variable allows you to specify a save file
+that is automatically loaded when Ren'Py starts. For example, setting
+this to "1" loads the game in save slot 1. This is intended for use by
+developers, so they can easily return to a point in the game after 
+restarting Ren'Py.
+
+
+The layout.imagemap_yesno_prompt now supports a prompt_images
+argument, which is can be used to specify images to replace the
+text of a yes/no prompt.
+
+
+The new ui.tag function allows one to specify the image tag of a UI
+widget. This can have positive interactions with transforms.
+
+
+Ren'Py now has a define statement, which combines into a single
+statement running code at init time, and assigning it to a
+variable. Ren'Py keeps track of these definitions, which may in the 
+future make it easier for editors to determine where something is
+defined.
+
+
+The new config.window_overlay_functions variable contains a list of
+functions that should be called only when once the dialogue window has
+been shown.
+
+
+The new config.automatic_images variable, when set correctly, will
+cause Ren'Py to automatically define images for appropriately-named
+image files found in the archives and game directory.
+
+
+Python blocks are now compiled in a mode that allows the python "with"
+statement. Container displayables now support the context manager
+protocol, automatically closing at the end of a with block. (Note
+that the python with statement postdates the Ren'Py with statement,
+and has totally different semantics.)
+
+
+The play and queue statements now take optional loop and noloop
+modifiers, which force looping (or lack of looping) on that channel.
+The play statement takes an if_changed modifier, which prevents a song
+from being restarted if it is already playing on the channel. [doc]
+
+
+Ren'Py now allows save games to be deleted. To do this, select a save
+game (either with the keyboard, or by hovering the mouse over it), and
+hit delete.
+
+
+Buttons now take a keymap argument, which specifies an alternate 
+keymap that is used when the button is focused.
+
+
+Added the Image Location Picker to the Developer (shift+D) menu. This
+tool lets the user pick an image, and then pick locations that
+image. It displays the mouse coordinates, imagemap rectangle, and
+cropping rectangle.
+
+
+Added a FPS meter to the Developer (shift+D) menu.
+
+Added a .001s sleep for frames that are framerate-limited. This should
+prevent Ren'Py from consuming all CPU unless the game is CPU-bound.
+
+
+Added config.file_open_callback, which allows Ren'Py to load files
+from user-definable archive types.
+
+
+Added the renpy.get_roll_forward function, which is the infrastructure
+needed to create a button that lets the user roll forward.
+
+
+Changed MoveTransition to preserve the timebases of the thing being moved
+in all circumstances.
+
+
+Ren'Py is now built using SDL-1.2.13. On Linux systems with pulseaudio
+support, it will use pulseaudio for audio output.
+
+
+Fixed a bug with archive files that could cause crashing in some 
+circumstances.
+
+Fixed a bug that prevented {w=1} from working.
+
+Fixed a bug that prevented style.rebuild from working.
+
+Fixed a potential segfault bug with certain transforms, zooms, and
+rotations.
+
+
 New in Ren'Py 6.9.3
 -------------------

@@ -41,6 +333,10 @@ Allow config.layer_clipping to specify layers that are larger than the
 screen.


+The various layouts now change the mouse to the gamemenu or mainmenu
+mouse, as appropriate.
+
+
 This distribution include a new NVL-mode tutorial, teaching people how
 to make NVL-mode games.

@@ -5,6 +5,8 @@ if [ "x$1" = "x" ]; then
    exit
 fi

+rsync -av updates tom@onegeek.org:/home/tom/WWW.update/renpy/
+
 mkdir ~/ab/website/renpy/dl/$1
 cp dists/renpy-$1-* ~/ab/website/renpy/dl/$1
 cp CHANGELOG.txt ~/ab/website/renpy/dl/$1
@@ -1,21 +1,39 @@
 #!/usr/bin/env python

+import modulefinder
+import shutil
 from distutils.core import setup
 import py2exe
 import sys
 import zipfile
 import traceback
+import os

 # The pythonpath on my system.
-sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\bin')
-sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\python')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\bin')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\python')
+
+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.)
+    """
+
+    if os.path.isdir(fn):
+        shutil.rmtree(fn)
+    elif os.path.exists(fn):
+        os.unlink(fn)
+
+    os.rename("dist/" + fn, fn)
+
+import renpy
+renpy.setup_modulefinder(modulefinder)

 def main():

-    sys.argv[1:] = [ 'py2exe', '--bundle', '2', '-a', '--dll-excludes', 'w9xpopen.exe', ]
-    # sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
+    sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]

-    setup(name="RenPy",
+    setup(name="Ren'Py",
          windows=[ dict(script="renpy.py",
                         dest_base="renpy",
                         icon_resources=[ (1, "newicon.ico") ],
@@ -24,7 +42,7 @@ def main():

          console=[ dict(script="renpy.py", dest_base="console") ],

-          zipfile='renpy.code',
+          zipfile='lib/windows-x86/renpy.code',

          options={ 'py2exe' : { 'excludes' : [ 'doctest',
                                                'pygame.macosx',
@@ -48,14 +66,18 @@ def main():
          )


-    zfold = zipfile.ZipFile("dist/renpy.code")
-    zfnew = zipfile.ZipFile("renpy.code", "w", zipfile.ZIP_STORED)
+    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/"):
-            continue
+
+            # 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
@@ -70,11 +92,21 @@ def main():
    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")
+
+    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("python26.dll")
+    move_from_dist("renpy.exe")
+    
+    
 try:
    main()
 except:
    traceback.print_exc()

-print
-print "Press return to quit."
-raw_input()
+    
@@ -1,84 +0,0 @@
-1#!/usr/bin/env python
-
-import collections
-import glob
-import re
-import sys
-import time
-
-# 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("launcher2/*.rpy")
-    files += glob.glob("common/*.rpy")
-    files += glob.glob("common/_layout/*.rpym")
-    files += glob.glob("common/_compat/*.rpym")
-        
-    for fn in files:
-        process(fn)
-
-
-    converse = [ ]
-        
-    for k, v in strings.iteritems():
-        v = " ".join(sorted(v))
-        converse.append((v, k))
-
-    converse.sort()
-
-    print """\
-# Ren'Py Visual Novel Engine
-# Copyright (C) 2009 PyTom <pytom@bishoujo.us>
-# This file is distributed under the same license as the Ren'Py package.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: mainline\\n"
-"Report-Msgid-Bugs-To: PyTom <pytom@bishoujo.us>\\n"
-"POT-Creation-Date: %s\\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=UTF-8\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-""" % time.strftime("%Y-%m-%d %H:%M%z")
-    
-    for v, k in converse:
-        print
-        print "#:", v
-        print "#, python-format"
-        print "msgid \"%s\"" % k
-        print "msgstr \"\""
-        
-        
-        
@@ -1,4 +1,4 @@
-1#!/usr/bin/env python
+#!/usr/bin/env python

 import collections
 import glob
@@ -40,6 +40,7 @@ if __name__ == "__main__":

    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")

@@ -73,7 +74,7 @@ init python:
        # print "#:", v
        # print "#, python-format"

-        print >>f, "        %r," % unicode(k)
+        print >>f, "        u\"%s\"," % unicode(k)

    print >>f, """\
    ]
@@ -0,0 +1,35 @@
+# Copyright 2004-2011 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
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init -1210 python:

    # This is called when script_version is set, to immediately
@@ -15,7 +18,39 @@ init -1210 python:

        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_ids = False
+            
+            
+          
 init 1210 python hide::

    # This returns true if the script_version is <= the
@@ -1,27 +1,51 @@
+# Copyright 2004-2011 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
+        
+    # 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
+
+    python:
+        config.default_transform = default
+        
+
 init -1110 python:

    _define = define = object()
        
-    # Positions ##############################################################
-
-    # These are positions that can be used inside at clauses. We set
-    # them up here so that they can be used throughout the program.
-    left = Position(xalign=0.0)
-    center = Position(xalign=0.5)
-    truecenter = Position(xalign=0.5, yalign=0.5)
-    right = Position(xalign=1.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.    
-    offscreenleft = Position(xpos=0.0, xanchor=1.0)
-    offscreenright = Position(xpos=1.0, xanchor=0.0)
-
    # Transitions ############################################################

    # Simple transitions.
@@ -140,8 +164,6 @@ init -1110 python:
    zoomin = MoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0))
    zoomout = MoveTransition(0.5, leave_factory=ZoomInOut(1.0, 0.01))
    zoominout = MoveTransition(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.
@@ -165,3 +187,7 @@ init 1110 python:

    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()
@@ -0,0 +1,188 @@
+# Copyright 2004-2011 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:
+    screen _gl_test:
+        frame:
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            has vbox
+
+            label _(u"Graphics Acceleration")
+
+            null height 10
+            
+            textbutton _(u"Automatically Choose"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "auto")
+            textbutton _(u"Prefer Software Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "sw")
+            textbutton _(u"Prefer OpenGL Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "gl")
+
+            null height 10
+
+            textbutton _(u"Continue"):
+                size_group "gl"
+                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
+            
+        def render(self, width, height, st, at):
+            self.times.append(st)
+
+            renpy.redraw(self, 0)
+
+            renpy.renpy.log.info("Frame drawn at %f seconds." % st)
+            
+            if len(self.times) >= self.frames:
+                frames_timing = self.times[-1] - self.times[-self.frames]
+
+                renpy.renpy.log.info("It took %f seconds to render %d frames.", frames_timing, self.frames)
+
+                if frames_timing <= self.target:
+                    self.success = True
+                    renpy.timeout(0)
+                    
+            rv = renpy.Render(width, height)
+            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)
+
+
+    def __gl_prefer_renderers(renderers):
+        """
+         Forces the current renderer to be renderer, one of gl or sw.
+         """
+
+        if renpy.display.prefer_renderers == renderers:
+            return
+
+        renpy.display.prefer_renderers = renderers        
+        renpy.display_reset()
+                    
+    def __gl_prompt():
+        """
+         Decides if we want to prompt the user to enable OpenGL mode.
+         If so, shows a screen that allows the user to alter the
+         OpenGL setting.
+         """
+
+        if not renpy.display.interface.safe_mode:
+            return 
+
+        __gl_prefer_renderers("sw")
+        
+        renpy.call_screen("_gl_test")
+
+        renpy.display.interface.safe_mode = False
+        
+    def __gl_test():
+        """
+         Makes the decision as to if we should use GL or SW mode.
+         """
+
+        import os
+        if "RENPY_RENDERER" in os.environ:
+            return
+
+        # Our decision survives a restart.
+        if _restart:
+            return
+
+        renpy.renpy.log.info("GL test mode: %s", persistent._gl_test)
+
+        # If GL is disabled, don't bother.
+        if not config.gl_enable:
+            return
+        
+        __gl_prompt()
+
+        if persistent._gl_test == "gl":
+            __gl_prefer_renderers("gl,sw")
+            return
+
+        if persistent._gl_test == "sw":
+            __gl_prefer_renderers("sw")
+            return
+
+        __gl_prefer_renderers("gl,sw")
+
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+        # If GL is able to render FRAMES frames at FPS fps in less
+        # than DELAY seconds, we consider it to be operational, and
+        # continue in GL mode. Otherwise, we rever to software
+        # rendering mode.
+        FRAMES = 5
+        FPS = 15
+        DELAY = 1
+        
+        renpy.transition(Dissolve(DELAY), always=True, force=True)
+        ui.add(__GLTest(FRAMES, FPS, DELAY))
+        result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+
+        if result:
+            __gl_prefer_renderers("gl,sw")
+        else:
+            __gl_prefer_renderers("sw")
+
+    # Init-time code:
+    # Make a guess as to what modes we should be in.
+    if persistent._gl_test is None:
+        persistent._gl_test = "auto"
+
+    if persistent._gl_test == "sw":
+        renpy.display.prefer_renderers = "sw"
+        
+            
+label _gl_test:
+
+    # Show the test image.
+    scene
+    show expression config.gl_test_image
+    
+    $ __gl_test()
+                
+    # Hide the test image.
+    scene
+
+    return
+
@@ -1,7 +1,5 @@
-# Copyright 2004-2007 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.

 init -1105 python:

@@ -16,17 +14,6 @@ init -1105 python:
    layout.compat_funcs = [ ]
    layout.provided = set()
    
-    # This takes care of actually displaying button menus.
-    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)
-
 init -1105 python hide:

    # Called to indicate that the given kind of layout has been
@@ -58,6 +45,21 @@ init -1105 python hide:
            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()
@@ -198,7 +200,7 @@ init -1105 python hide:
    @layout
    def button_menu():

-        store.menu = _display_button_menu
+        config.narrator_menu = True

        style.menu.box_spacing = 2
        style.menu_window.set_parent(style.default)
@@ -288,13 +290,14 @@ init -1105 python hide:


    @layout
-    def imagemap_main_menu(ground, selected, hotspots):
+    def imagemap_main_menu(ground, selected, hotspots, idle=None, variant=None):
        renpy.load_module("_layout/imagemap_main_menu")

-        config.main_menu_ground = ground
-        config.main_menu_selected = selected
-        config.main_menu_hotspots = hotspots
-
+        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):
@@ -322,7 +325,7 @@ init -1105 python hide:
        config.preferences_hotspots = hotspots

    @layout
-    def imagemap_yesno_prompt(ground, idle, hover, hotspots):
+    def imagemap_yesno_prompt(ground, idle, hover, hotspots, prompt_images={ }):

        renpy.load_module("_layout/imagemap_yesno_prompt")
        
@@ -330,16 +333,91 @@ init -1105 python hide:
        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):
+                           hotspots, variant=None):

        renpy.load_module("_layout/imagemap_load_save")
        
-        config.load_save_ground = ground
-        config.load_save_idle = idle
-        config.load_save_hover = hover
-        config.load_save_selected_idle = selected_idle
-        config.load_save_selected_hover = selected_hover
-        config.load_save_hotspots = hotspots
+        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 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.yesno_prompt, None, message):
+            if yes is not None:
+                yes()
+        else:
+            if no is not None:
+                no()
+                
@@ -1,7 +1,5 @@
-# Copyright 2004-2007 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 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
@@ -49,6 +47,31 @@ init -1180 python:
    # 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 = ''
@@ -71,8 +94,20 @@ init -1180 python:


    def _default_empty_window():
-        store.narrator("", interact=False)

+        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.')
@@ -86,7 +121,6 @@ init -1180 python:

    _intra_jumps = renpy.curry(_intra_jumps_core)

-
    # The function that's used to translate strings in the game menu.
    def _(s):
        """
@@ -101,11 +135,33 @@ init -1180 python:

        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

-init -1180 python:
-
    def toggle_skipping():

        if not config.skipping:
@@ -120,27 +176,29 @@ init -1180 python:

    config.help = None
            
-    def _help():
-        if not config.help:
+    def _help(help=None):
+
+        if help is None:
+            help = config.help
+
+        if help is None:
            return

-        if renpy.has_label(config.help):
-            renpy.call_in_new_context(config.help)
+        if renpy.has_label(help):
+            renpy.call_in_new_context(help)
            return

        _preferences.fullscreen = False

        try:
            import webbrowser
-            webbrowser.open_new("file:///" + config.basedir + "/" + config.help)
+            webbrowser.open_new("file:///" + config.basedir + "/" + help)
        except:
            pass
-            
-    
-init -1180 python hide:

+        
    # Called to make a screenshot happen.
-    def screenshot():
+    def _screenshot():
        import os.path
        import os
        import __main__
@@ -171,17 +229,36 @@ init -1180 python hide:
        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
        
-            
+    
+init -1180 python hide:
+
    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:
-            renpy.jump("_noisy_return")
+            if renpy.context()._main_menu:
+                return
+            else:
+                renpy.jump("_noisy_return")
        else:
-            renpy.call_in_new_context('_game_menu')
+            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:
@@ -213,7 +290,7 @@ init -1180 python hide:
    # the launcher.
    km = renpy.Keymap(
        rollback = renpy.rollback,
-        screenshot = screenshot,
+        screenshot = _screenshot,
        toggle_fullscreen = renpy.toggle_fullscreen,
        toggle_music = renpy.toggle_music,
        toggle_skip = keymap_toggle_skipping,
@@ -272,32 +349,36 @@ init -1180 python hide:

    config.hyperlink_styler = hyperlink_styler
    config.hyperlink_callback = hyperlink_function
+
+    # Prediction of screens.    
+    def predict():
+        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.extend_interjection = "{fast}"
-    
-init -1180 python:
-    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
+    config.imagemap_auto_function = imagemap_auto_function


 label _hide_windows:
@@ -322,15 +403,15 @@ label _hide_windows:
 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", "reload save game")

-        persistent._reload_save = "reload"
+        renpy.save("_reload-1", "reload save game")
        
        ui.add(Solid((0, 0, 0, 255)))
        ui.text("Reloading script...",
@@ -341,13 +422,12 @@ label _save_reload_game:
        renpy.utter_restart()

 label _load_reload_game:
-
-    if not persistent._reload_save:
-        return
+    
+    if not renpy.can_load("_reload-1"):
+        return 

    python hide:
-        save = persistent._reload_save
-        persistent._reload_save = 0
+        renpy.rename_save("_reload-1", "_reload-2")

        ui.add(Solid((0, 0, 0, 255)))
        ui.text("Reloading game...",
@@ -356,7 +436,7 @@ label _load_reload_game:
        ui.pausebehavior(0)
        ui.interact(suppress_underlay=True, suppress_overlay=True)
        
-        renpy.load(save)
+        renpy.load("_reload-2")

    return

@@ -379,6 +459,17 @@ init 1180 python:
        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
+    
+
    if config.developer:

        def _inspector(l):
@@ -390,7 +481,6 @@ init 1180 python:
            ui.text("Style Inspector")
            ui.text("")

-
            if not l:
                ui.text("Nothing to inspect.")
            
@@ -520,10 +610,13 @@ label _enter_menu:
        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
        
        # This may be changed, if we are already in the main menu.
-        renpy.context().main_menu = False
+        renpy.context()._main_menu = False
        renpy.context_dynamic("main_menu")
        renpy.context_dynamic("_window_subtitle")
        renpy.context_dynamic("_window")
@@ -563,9 +656,14 @@ label _game_menu(_game_menu_screen=_game_menu_screen):
    $ 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

@@ -607,7 +705,7 @@ label _noisy_return:
 # Return to the game.
 label _return:

-    if renpy.context().main_menu:
+    if renpy.context()._main_menu:
        $ renpy.transition(config.game_main_transition)
        jump _main_menu_screen

@@ -616,7 +714,6 @@ label _return:
    return

 label _confirm_quit:
-    call _enter_menu from _call__enter_menu_3

    if renpy.has_label("confirm_quit"):
        jump expression "confirm_quit"
@@ -642,6 +739,7 @@ init -1180 python hide:
 # 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)
@@ -658,15 +756,25 @@ label _start:

    python hide:
        renpy.context()._menu = False
+        renpy.context()._main_menu = False
        
        for i in config.start_callbacks:
            i()
-    
-    # call _check_module from _call__check_module_1
+
+    $ renpy.block_rollback()
+
+    call _gl_test
+            
    call _load_reload_game from _call__load_reload_game_1

-    scene black
+    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)
@@ -690,20 +798,29 @@ label _start:
        $ renpy.music.stop()
        
    # Clean out any residual scene from the splashscreen.
-    scene black
-
-    if _restart is None:
-        $ renpy.transition(config.end_splash_transition)
+    if config.start_scene_black:
+        scene black
    else:
-        $ renpy.transition(_restart[0])
-        jump expression _restart[1]
+        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:

-    if _restart:
-        $ renpy.call_in_new_context(_restart[2])
-    else:
-        $ renpy.call_in_new_context("_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.
@@ -719,7 +836,7 @@ label _main_menu(_main_menu_screen="_main_menu_screen"):
        renpy.dynamic("_load_prompt")
        _load_prompt = False

-        renpy.context().main_menu = True
+        renpy.context()._main_menu = True
        store.main_menu = True

    jump expression _main_menu_screen
@@ -733,11 +850,77 @@ label _main_menu_screen:
        jump expression "main_menu"

    # New name.
-    if renpy.has_label("main_menu_screen"):
+    elif renpy.has_label("main_menu_screen"):
        jump expression "main_menu_screen"

    # Compatibility name.
-    if renpy.has_label("_library_main_menu"):
+    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.exports.images:
+                continue
+
+            renpy.image(name, fn)
+
+    if config.automatic_images:
+        create_automatic_images()
+
+
+# Load the developer screen, if necessary.
+init 1180 python hide:
+
+    if config.developer:
+        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
+
+    call _enter_menu from _call__enter_menu_4
+
+    jump expression "_developer_screen"
@@ -1,7 +1,5 @@
-# Copyright 2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 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
@@ -31,13 +29,15 @@ init -1150 python:
 label _quit_prompt:
    $ renpy.loadsave.force_autosave()

-    if layout.yesno_prompt(None, u"Are you sure you want to quit?"):
+    if layout.yesno_prompt(None, layout.QUIT):
        jump _quit
    else:
        return

 label _main_menu_prompt:
-    if layout.yesno_prompt(None, u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."):
+    $ renpy.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.MAIN_MENU):
        $ renpy.full_restart(transition=config.game_main_transition)
    else:
        return
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 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.

@@ -18,7 +21,7 @@ init -1130 python hide:
    for i in xrange(0, 8):
        renpy.music.register_channel(i)

-    renpy.music.register_channel("movie", "music", False, stop_on_mute=False)
+    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")
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 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
@@ -76,8 +79,56 @@ init -1100 python:
            return s[nvl_variant]
        else:
            return s
-    
-    def nvl_show_core():
+
+    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']
@@ -191,16 +242,19 @@ init -1100 python:
            else:
                checkpoint = True
                
-            renpy.display_say(nvl_show_core,
-                              checkpoint=checkpoint,
-                              **display_args)
+            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.
@@ -210,6 +264,7 @@ init -1100 python:
        what_style='nvl_dialogue',
        window_style='nvl_entry',
        type='nvl',
+        mode='nvl',
        clear=False,
        kind=adv)
                
@@ -218,16 +273,45 @@ init -1100 python:

    # 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))

@@ -255,32 +339,28 @@ init -1100 python:

        return rv

+    NVLSpeaker = NVLCharacter
+    
    config.nvl_adv_transition = None
    config.adv_nvl_transition = None

-init 1140 python:

-    if config.nvl_adv_transition or config.adv_nvl_transition:
+    # This is used to execute the nvl and adv mode transitions.
+    def _nvl_adv_callback(mode, old_modes):

-        def _nvl_adv_callback(event, interact, type, **kwargs):
-        
-            if event != "begin" or not interact or renpy.get_transition():
-                return 
-            
-            old_type = renpy.last_interact_type()
-
-            if old_type == "say" and type == "nvl":
-                # We have an extra line in the nvl_list as we do this. So
-                # take it out for the duration of the nvl_show.
-                old_nvl_list = store.nvl_list
-                store.nvl_list = old_nvl_list[:-1]
-                nvl_show(config.adv_nvl_transition)
-                store.nvl_list = old_nvl_list
-            elif old_type == "nvl" and type == "say":
-                nvl_hide(config.nvl_adv_transition)
-
-        config.all_character_callbacks.insert(0, _nvl_adv_callback)
+        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:

@@ -63,15 +63,19 @@ init -1080 python:
   
        def init_values(self, sizes):
            def to_abs_(value, size):
-                if isinstance(value, float):
+                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])
@@ -122,8 +126,8 @@ init -1080 python:
                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 ( int(result[0]), int(result[1]), 0, 0 )
+
+            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)
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 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.
 #
@@ -67,6 +70,8 @@ python early hide:
        fadeout = "None"
        fadein = "0"
        channel = None
+        loop = None
+        if_changed = False
        
        while True:

@@ -93,42 +98,63 @@ python early hide:
                    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)
+                    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 = 7
+            channel = "music"
        
        renpy.music.play(eval(p["file"]),
                         fadeout=eval(p["fadeout"]),
                         fadein=eval(p["fadein"]),
-                         channel=channel)
+                         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):
+    def lint_play_music(p, channel="music"):

        file = _try_eval(p["file"], 'filename')
-        if p["channel"] is not None:
-            _try_eval(p["channel"], 'channel')

+        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) and not renpy.loadable(fn):
-                renpy.error("%r is not loadable" % fn)
-    
+            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,
@@ -145,24 +171,38 @@ python early hide:
            renpy.error("queue requires a file")

        channel = None
-            
-        if l.keyword('channel'):
-            channel = l.simple_expression()
-            if channel is None:
-                renpy.error('expected simple expression')
+        loop = None
+        
+        while not l.eol():
+        
+            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 l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue

-        return dict(file=file, channel=channel)
+            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 = 7
+            channel = "music"
        
-        renpy.music.queue(eval(p["file"]), channel=channel)
+        renpy.music.queue(
+            eval(p["file"]),
+            channel=channel,
+            loop=p.get("loop", None))
+

    renpy.statements.register('queue music',
                              parse=parse_queue_music,
@@ -194,7 +234,7 @@ python early hide:
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
-            channel = 7
+            channel = "music"
        
        renpy.music.stop(fadeout=eval(p["fadeout"]), channel=channel)

@@ -211,7 +251,7 @@ python early hide:
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
-            channel = 0
+            channel = "sound"

        fadeout = eval(p["fadeout"]) or 0
            
@@ -219,17 +259,20 @@ python early hide:
                         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_music)
+                              lint=lint_play_sound)

    def execute_queue_sound(p):
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
-            channel = 0
+            channel = "sound"

        renpy.sound.queue(eval(p["file"]), channel=channel)

@@ -243,7 +286,7 @@ python early hide:
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
-            channel = 0
+            channel = "sound"

        fadeout = eval(p["fadeout"]) or 0

@@ -299,7 +342,7 @@ python early hide:
        if not renpy.music.channel_defined(channel):
            renpy.error("channel %r is not defined" % channel)

-        lint_play_music(p)
+        lint_play_music(p, channel)

    def lint_stop_generic(p):
        channel = eval(p["channel"])
@@ -324,7 +367,9 @@ python early hide:
                              lint=lint_stop_generic)


-    # The "window show" and "window hide" statements.
+    ##########################################################################
+    # "window show" and "window hide" statements.
+
    def parse_window(l):
        p = l.simple_expression()
        if not l.eol():
@@ -371,7 +416,38 @@ python early 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:

@@ -384,3 +460,102 @@ init -1200 python:
        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)
+
+            
+    
@@ -1,7 +1,5 @@
-# Copyright 2004-2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 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.
@@ -24,10 +22,14 @@ 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')
@@ -52,7 +54,8 @@ init -1200 python hide:
    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_text = Style(style.default, help='text of an input box')
+    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')

@@ -60,8 +63,10 @@ init -1200 python hide:
    style.centered_text = Style(style.default, help='centered text')

    style.imagemap = Style(style.image_placement, help='default style of imagemaps')
-    style.imagemap_button = Style(style.default, help='default style of buttons inside 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')

@@ -78,6 +83,8 @@ init -1200 python hide:
    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.')
@@ -203,6 +210,8 @@ init -1090 python:
    # 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))
@@ -213,16 +222,9 @@ init -1090 python:
    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

-    # Image placement.
-    style.image_placement.xpos = 0.5
-    style.image_placement.ypos = 1.0
-    style.image_placement.xanchor = 0.5
-    style.image_placement.yanchor = 1.0
-
    # Dialogue
    style.say_label.bold = True
    style.say_vbox.spacing = 8
@@ -238,7 +240,7 @@ init -1090 python:
    # Menus.
    style.menu_choice.idle_color = "#0ff"
    style.menu_choice.hover_color = "#ff0"
-    style.input_text.color = "#ff0"
+    style.input.color = "#ff0"

    # Styles used by centered.
    style.centered_window.xalign = 0.5
@@ -295,7 +297,10 @@ init -1090 python:
    style.list_text.color = "#000"
    style.list_text.size = 14
    style.list_spacer.xminimum = 15
-       
+
+    # Tile
+    style.tile.clipping = True
+    
    
    ######################################################################

@@ -1,7 +1,5 @@
-# Copyright 2004-2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.

 init -1110 python:

@@ -73,9 +71,7 @@ init -1110 python hide:
        style.vscrollbar.bar_vertical = True
        style.vscrollbar.bar_invert = True

-        
-        
-        
+
    # This recolors the given image using one or two colors.
    @theme
    def OneOrTwoColor(image, color):
@@ -84,250 +80,68 @@ init -1110 python hide:
        else:
            return im.Twocolor(image, color, color)

-    @theme
-    def roundrect_frames(
-        less_rounded,
-        frame):
+    def roundrect_based_theme(name, file_prefix, Box=None, frame_png=None):

-        theme.clear_frames()
-        
-        style.frame.background = RoundRect(frame, less_rounded)
+        if Box is None:
+            def Box(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + "_box.png", color), 12, 12)

-        style.frame.xpadding = 6
-        style.frame.ypadding = 6
-        
+        if frame_png is not None:
+            def FrameBox(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + frame_png, color), 12, 12)
+        else:
+            FrameBox = Box
            
-    @theme
-    def roundrect_buttons(text_size,
-                          less_rounded,
-                          widget,
-                          widget_hover,
-                          widget_text,
-                          widget_selected,
-                          disabled,
-                          disabled_text):
-
-        theme.clear_buttons()
-        
-        style.button.background = RoundRect(widget, less_rounded)
-        style.button.hover_background = RoundRect(widget_hover, less_rounded)
-        style.button.insensitive_background = RoundRect(disabled, less_rounded)
-
-        style.button_text.size = text_size
-        style.button_text.color = widget_text
-        style.button_text.selected_color = widget_selected
-        style.button_text.insensitive_color = disabled_text
-
-        if less_rounded:
-            style.button.xpadding = 6
-        else:
-            style.button.xpadding = 12
-
-        style.button.ypadding = 1
-        style.button.xmargin = 1
-        style.button.ymargin = 1
-
-        style.button_text.xalign = 0.5
-        style.button_text.yalign = 0.5
-        style.button_text.text_align = 0.5
-
-    @theme
-    def roundrect_large_buttons(
-        text_size,
-        less_rounded,
-        widget,
-        widget_hover,
-        widget_text,
-        widget_selected,
-        disabled,
-        disabled_text):
-
-        theme.clear_large_buttons()
-
-        if less_rounded:
-            style.large_button.xpadding = 6
-        else:
-            style.large_button.xpadding = 12
-
-        style.large_button.ypadding = 1
-        style.large_button.xmargin = 1
-        style.large_button.ymargin = 1
-        
-        style.large_button.background = RoundRect(widget, less_rounded)
-        style.large_button.hover_background = RoundRect(widget_hover, less_rounded)
-        style.large_button.insensitive_background = RoundRect(disabled, less_rounded)
-
-        style.large_button_text.size = text_size
-        style.large_button_text.color = widget_text
-        style.large_button_text.selected_color = widget_selected
-        style.large_button_text.insensitive_color = disabled_text
-
-        style.large_button_text.xalign = 0
-        style.large_button_text.yalign = 0
-
-    @theme
-    def roundrect_labels(
-        text_size,
-        label):
-
-        theme.clear_labels()
-        
-        style.label_text.size = text_size
-        style.label_text.color = label
-
-    @theme
-    def roundrect_prompts(
-        text_size,
-        label):
-
-        theme.clear_prompts()
-
-        style.prompt_text.size = text_size
-        style.prompt_text.color = label
-        
-        style.prompt.xalign = 0.5
-        style.prompt_text.text_align = 0.5
-        style.prompt_text.layout = "subtitle"
-        
-    @theme
-    def roundrect_bars(
-        widget,
-        widget_hover):
-
-        theme.clear_bars()
-        
-        def img(name, color, x, y):
-            rv = theme.OneOrTwoColor("_roundrect/" + name + ".png", color)
-            if x is not None:
-                rv = Frame(rv, x, y)
-            return rv
-
-        # Bars.
-        style.bar.ymaximum = 24
-        style.bar.left_gutter = 6
-        style.bar.right_gutter = 6
-        style.bar.thumb_offset = 6
-
-        style.bar.left_bar = img("rrslider_full", widget, 12, 0)
-        style.bar.right_bar = img("rrslider_empty", widget, 12, 0)
-        style.bar.thumb = img("rrslider_thumb", widget, None, None)
-        style.bar.hover_left_bar = img("rrslider_full", widget_hover, 12, 0)
-        style.bar.hover_right_bar = img("rrslider_empty", widget_hover, 12, 0)
-        style.bar.hover_thumb = img("rrslider_thumb", widget_hover, None, None)
-
-        style.vbar.xmaximum = 24
-        style.vbar.top_gutter = 6
-        style.vbar.bottom_gutter = 6
-        style.vbar.thumb_offset = 6
-
-        style.vbar.bottom_bar = img("rrvslider_full", widget, 0, 12)
-        style.vbar.top_bar = img("rrvslider_empty", widget, 0, 12)
-        style.vbar.thumb = img("rrvslider_thumb", widget, None, None)
-        style.vbar.hover_bottom_bar = img("rrvslider_full", widget_hover, 0, 12)
-        style.vbar.hover_top_bar = img("rrvslider_empty", widget_hover, 0, 12)
-        style.vbar.hover_thumb = img("rrvslider_thumb", widget_hover, None, None)
-
-        # Sliders.
-        style.slider.ymaximum = 24
-        style.slider.left_gutter = 6
-        style.slider.right_gutter = 6
-        style.slider.thumb_offset = 6
-
-        style.slider.left_bar = img("rrslider_full", widget, 12, 0)
-        style.slider.right_bar = img("rrslider_empty", widget, 12, 0)
-        style.slider.thumb = img("rrslider_thumb", widget, None, None)
-        style.slider.hover_left_bar = img("rrslider_full", widget_hover, 12, 0)
-        style.slider.hover_right_bar = img("rrslider_empty", widget_hover, 12, 0)
-        style.slider.hover_thumb = img("rrslider_thumb", widget_hover, None, None)
-
-        style.vslider.xmaximum = 24
-        style.vslider.top_gutter = 6
-        style.vslider.bottom_gutter = 6
-        style.vslider.thumb_offset = 6
-
-        style.vslider.bottom_bar = img("rrvslider_full", widget, 0, 12)
-        style.vslider.top_bar = img("rrvslider_empty", widget, 0, 12)
-        style.vslider.thumb = img("rrvslider_thumb", widget, None, None)
-        style.vslider.hover_bottom_bar = img("rrvslider_full", widget_hover, 0, 12)
-        style.vslider.hover_top_bar = img("rrvslider_empty", widget_hover, 0, 12)
-        style.vslider.hover_thumb = img("rrvslider_thumb", widget_hover, None, None)
-
-        
-        # Scrollbars.
-        style.scrollbar.left_gutter = 6
-        style.scrollbar.right_gutter = 6
-        style.scrollbar.thumb_offset = 6
-        style.scrollbar.ymaximum = 12
-
-        style.scrollbar.left_bar = img("rrscrollbar", widget, 12, 0)
-        style.scrollbar.right_bar = img("rrscrollbar", widget, 12, 0)
-        style.scrollbar.thumb = img("rrscrollbar_thumb", widget, None, None)
-        style.scrollbar.hover_left_bar = img("rrscrollbar", widget_hover, 12, 0)
-        style.scrollbar.hover_right_bar = img("rrscrollbar", widget_hover, 12, 0)
-        style.scrollbar.hover_thumb = img("rrscrollbar_thumb", widget_hover, None, None)
-        
-        style.vscrollbar.top_gutter = 6
-        style.vscrollbar.bottom_gutter = 6
-        style.vscrollbar.thumb_offset = 6
-        style.vscrollbar.xmaximum = 12
-
-        style.vscrollbar.left_bar = img("rrvscrollbar", widget, 0, 12)
-        style.vscrollbar.right_bar = img("rrvscrollbar", widget, 0, 12)
-        style.vscrollbar.thumb = img("rrvscrollbar_thumb", widget, None, None)
-        style.vscrollbar.hover_left_bar = img("rrvscrollbar", widget_hover, 0, 12)
-        style.vscrollbar.hover_right_bar = img("rrvscrollbar", widget_hover, 0, 12)
-        style.vscrollbar.hover_thumb = img("rrvscrollbar_thumb", widget_hover, None, None)
-
-    @theme
-    def 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)),
-        
-        text_size=None,
-        small_text_size=None,
-        less_rounded = False,        
-        
-        # Compat for the old roundrect theme.
-        window = None,
-        button_menu = None,
-        rounded_window = True,
-        outline_bars = False,
-
-        mm_root = None,
-        gm_root = None):
-
-        if button_menu is None:
-            if (config.script_version is not None) and (config.script_version < (6, 9, 0)):
-                button_menu = True
-            else:
-                button_menu = False
-        
-        layout.defaults()
-        
-        if config.screen_width <= 640:
-            text_size = text_size or 18
-            small_text_size = small_text_size or 12
-            less_rounded = True
-            
-        else:
-            text_size = text_size or 22
-            small_text_size = small_text_size or 16
-            radius = 12
-
-        theme.roundrect_frames(
+        def frames(
            less_rounded,
-            frame)
+            frame):

-        theme.roundrect_buttons(
+            theme.clear_frames()
+
+            style.frame.background = Box(frame, less_rounded)
+
+            style.frame.xpadding = 6
+            style.frame.ypadding = 6
+        
+        setattr(theme, name + "_frames", frames)
+
+            
+        def buttons(text_size,
+                    less_rounded,
+                    widget,
+                    widget_hover,
+                    widget_text,
+                    widget_selected,
+                    disabled,
+                    disabled_text):
+
+            theme.clear_buttons()
+
+            style.button.background = Box(widget, less_rounded)
+            style.button.hover_background = Box(widget_hover, less_rounded)
+            style.button.insensitive_background = Box(disabled, less_rounded)
+
+            style.button_text.size = text_size
+            style.button_text.color = widget_text
+            style.button_text.selected_color = widget_selected
+            style.button_text.insensitive_color = disabled_text
+
+            if less_rounded:
+                style.button.xpadding = 6
+            else:
+                style.button.xpadding = 12
+
+            style.button.ypadding = 1
+            style.button.xmargin = 1
+            style.button.ymargin = 1
+
+            style.button_text.xalign = 0.5
+            style.button_text.yalign = 0.5
+            style.button_text.text_align = 0.5
+
+        setattr(theme, name + "_buttons", buttons)
+            
+        def large_buttons(
            text_size,
            less_rounded,
            widget,
@@ -335,55 +149,260 @@ init -1110 python hide:
            widget_text,
            widget_selected,
            disabled,
-            disabled_text)
+            disabled_text):

-        theme.roundrect_large_buttons(
-            small_text_size,
-            less_rounded,
-            widget,
-            widget_hover,
-            widget_text,
-            widget_selected,
-            disabled,
-            disabled_text)
+            theme.clear_large_buttons()

-        theme.roundrect_labels(
-            text_size,
-            label)
-
-        theme.roundrect_prompts(
-            text_size,
-            label)
-
-        theme.roundrect_bars(
-            widget,
-            widget_hover)
-            
-        if mm_root is not None:
-            style.mm_root.background = mm_root
-
-        if gm_root is not None:
-            style.gm_root.background = gm_root
-            
-        if window is not None:
-
-            if rounded_window:
-                style.window.background = RoundRect(window, less_rounded)
-                style.window.xpadding = 6
-                style.window.xmargin = 6
-                style.window.ypadding = 6
-                style.window.ymargin = 6
+            if less_rounded:
+                style.large_button.xpadding = 6
            else:
-                style.window.background = Solid(window)
-                style.window.xpadding = 6
-                style.window.xmargin = 0
-                style.window.ypadding = 6
-                style.window.ymargin = 0
+                style.large_button.xpadding = 12
+
+            style.large_button.ypadding = 1
+            style.large_button.xmargin = 1
+            style.large_button.ymargin = 1
+
+            style.large_button.background = Box(widget, less_rounded)
+            style.large_button.hover_background = Box(widget_hover, less_rounded)
+            style.large_button.insensitive_background = Box(disabled, less_rounded)
+
+            style.large_button_text.size = text_size
+            style.large_button_text.color = widget_text
+            style.large_button_text.selected_color = widget_selected
+            style.large_button_text.insensitive_color = disabled_text
+
+            style.large_button_text.xalign = 0
+            style.large_button_text.yalign = 0
+
+        setattr(theme, name + "_large_buttons", large_buttons)
+            
+        def labels(
+            text_size,
+            label):
+
+            theme.clear_labels()
+
+            style.label_text.size = text_size
+            style.label_text.color = label
+
+        setattr(theme, name + "_labels", labels)
+            
+        def prompts(
+            text_size,
+            label):
+
+            theme.clear_prompts()
+
+            style.prompt_text.size = text_size
+            style.prompt_text.color = label
+
+            style.prompt.xalign = 0.5
+            style.prompt_text.text_align = 0.5
+            style.prompt_text.layout = "subtitle"
+ 
+        setattr(theme, name + "_prompts", prompts)
+       
+            
+        def bars(
+            widget,
+            widget_hover):
+
+            theme.clear_bars()
+
+            def img(name, color, x, y):
+                rv = theme.OneOrTwoColor(file_prefix + name + ".png", color)
+                if x is not None:
+                    rv = Frame(rv, x, y, tile=True)
+                return rv
+
+            # Bars.
+            style.bar.ymaximum = 24
+            style.bar.left_gutter = 6
+            style.bar.right_gutter = 6
+            style.bar.thumb_offset = 6
+
+            style.bar.left_bar = img("slider_full", widget, 12, 0)
+            style.bar.right_bar = img("slider_empty", widget, 12, 0)
+            style.bar.thumb = img("slider_thumb", widget, None, None)
+            style.bar.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.bar.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.bar.hover_thumb = img("slider_thumb", widget_hover, None, None)
+
+            style.vbar.xmaximum = 24
+            style.vbar.top_gutter = 6
+            style.vbar.bottom_gutter = 6
+            style.vbar.thumb_offset = 6
+
+            style.vbar.bottom_bar = img("vslider_full", widget, 0, 12)
+            style.vbar.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vbar.thumb = img("vslider_thumb", widget, None, None)
+            style.vbar.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vbar.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vbar.hover_thumb = img("vslider_thumb", widget_hover, None, None)
+
+            # Sliders.
+            style.slider.ymaximum = 24
+            style.slider.left_gutter = 6
+            style.slider.right_gutter = 6
+            style.slider.thumb_offset = 6
+
+            style.slider.left_bar = img("slider_full", widget, 12, 0)
+            style.slider.right_bar = img("slider_empty", widget, 12, 0)
+            style.slider.thumb = img("slider_thumb", widget, None, None)
+            style.slider.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.slider.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.slider.hover_thumb = img("slider_thumb", widget_hover, None, None)
+
+            style.vslider.xmaximum = 24
+            style.vslider.top_gutter = 6
+            style.vslider.bottom_gutter = 6
+            style.vslider.thumb_offset = 6
+
+            style.vslider.bottom_bar = img("vslider_full", widget, 0, 12)
+            style.vslider.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vslider.thumb = img("vslider_thumb", widget, None, None)
+            style.vslider.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vslider.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vslider.hover_thumb = img("vslider_thumb", widget_hover, None, None)


-        if button_menu:
-            layout.button_menu()
+            # Scrollbars.
+            style.scrollbar.left_gutter = 6
+            style.scrollbar.right_gutter = 6
+            style.scrollbar.thumb_offset = 6
+            style.scrollbar.ymaximum = 12

+            style.scrollbar.left_bar = img("scrollbar", widget, 12, 0)
+            style.scrollbar.right_bar = img("scrollbar", widget, 12, 0)
+            style.scrollbar.thumb = img("scrollbar_thumb", widget, None, None)
+            style.scrollbar.hover_left_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_right_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_thumb = img("scrollbar_thumb", widget_hover, None, None)
+
+            style.vscrollbar.top_gutter = 6
+            style.vscrollbar.bottom_gutter = 6
+            style.vscrollbar.thumb_offset = 6
+            style.vscrollbar.xmaximum = 12
+
+            style.vscrollbar.left_bar = img("vscrollbar", widget, 0, 12)
+            style.vscrollbar.right_bar = img("vscrollbar", widget, 0, 12)
+            style.vscrollbar.thumb = img("vscrollbar_thumb", widget, None, None)
+            style.vscrollbar.hover_left_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_right_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_thumb = img("vscrollbar_thumb", widget_hover, None, None)
+
+        setattr(theme, name + "_bars", bars)
+        
+        def main(
+            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),
+
+            text_size=None,
+            small_text_size=None,
+            less_rounded = False,        
+
+            # Compat for the old roundrect theme.
+            window = None,
+            button_menu = None,
+            rounded_window = True,
+            outline_bars = False,
+            mm_root = None,
+            gm_root = None):
+
+            if button_menu is None:
+                if (config.script_version is not None) and (config.script_version < (6, 9, 0)):
+                    button_menu = True
+                else:
+                    button_menu = False
+
+            layout.defaults()
+
+            if config.screen_width <= 640:
+                text_size = text_size or 18
+                small_text_size = small_text_size or 12
+                less_rounded = True
+
+            else:
+                text_size = text_size or 22
+                small_text_size = small_text_size or 16
+                radius = 12
+
+            frames(
+                less_rounded,
+                frame)
+
+            buttons(
+                text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            large_buttons(
+                small_text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            labels(
+                text_size,
+                label)
+
+            prompts(
+                text_size,
+                label)
+
+            bars(
+                widget,
+                widget_hover)
+
+            if mm_root is not None:
+                style.mm_root.background = mm_root
+
+            if gm_root is not None:
+                style.gm_root.background = gm_root
+
+            if window is not None:
+
+                if rounded_window:
+                    style.window.background = RoundRect(window, less_rounded)
+                    style.window.xpadding = 6
+                    style.window.xmargin = 6
+                    style.window.ypadding = 6
+                    style.window.ymargin = 6
+                else:
+                    style.window.background = Solid(window)
+                    style.window.xpadding = 6
+                    style.window.xmargin = 0
+                    style.window.ypadding = 6
+                    style.window.ymargin = 0
+
+
+            if button_menu:
+                layout.button_menu()
+
+        setattr(theme, name, main)
+
+    roundrect_based_theme("roundrect", "_roundrect/rr", RoundRect)
+    roundrect_based_theme("bordered", "_theme_bordered/br")
+    roundrect_based_theme("diamond", "_theme_diamond/d")
+    roundrect_based_theme("tv", "_theme_tv/t")
+    roundrect_based_theme("glow", "_theme_glow/g", None, "_outline.png")
+
+        
    @theme
    def ancient():

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 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
@@ -27,15 +30,17 @@ init -1120:
        _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):
@@ -44,6 +49,14 @@ init -1120:
            
            _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.
@@ -57,9 +70,11 @@ init -1120:
                return
            
            if _voice.play and not config.skipping:
-                renpy.sound.play(_voice.play, channel=2)
+                renpy.sound.play(_voice.play, channel="voice")
+                store._last_voice_play = _voice.play        
            elif not _voice.sustain:
-                renpy.sound.stop(channel=2)
+                renpy.sound.stop(channel="voice")
+                store._last_voice_play = _voice.play        

            _voice.play = None
            _voice.sustain = False
@@ -68,7 +83,7 @@ init -1120:
        config.say_sustain_callbacks.append(voice_sustain)

        def voice_afm_callback():
-            return not renpy.sound.is_playing(channel=2)
+            return not renpy.sound.is_playing(channel="voice")

        config.afm_callback = voice_afm_callback
                       
@@ -1,4 +1,5 @@
-Fonts are (c) Bitstream (see below). DejaVu changes are in public domain. Glyphs imported from Arev fonts are (c) Tavmjung Bah (see below)
+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
 ------------------------------
@@ -95,4 +96,4 @@ dealings in this Font Software without prior written authorization
 from Tavmjong Bah. For further information, contact: tavmjong @ free
 . fr.

-$Id: LICENSE 778 2006-04-20 18:14:24Z moyogo $
+$Id: LICENSE 2133 2007-11-28 02:46:28Z lechimp $
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    ######################################################################
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init:
    python:

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init -1170 python hide:

    config.old_names['Quit'] = 'Quit Game'
@@ -1,4 +1,7 @@
-# Copyright 2004-2006 PyTom
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2011 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 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.')
@@ -1,4 +1,7 @@
-# Copyright 2004-2007 PyTom
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2011 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.
@@ -1,32 +1,34 @@
-# Entry point for the developer console.
-label _developer:
+# This file contains code that helps support the development of Ren'Py
+# games.

-    if not config.developer:
-        return
+screen _developer:
+    window style "gm_root"

-    call _enter_menu from _call__enter_menu_4
+    frame:
+        style_group "_developer"

+        align (.025, .05)
+
+        has vbox:
+            first_spacing 10
+
+        label "Developer Menu"
+
+        textbutton _(u"Return") action Return()
+        textbutton _(u"Reload Game (Shift + R)") action ui.callsinnewcontext("_save_reload_game")
+        textbutton _(u"Variable Viewer") action Jump("_debugger_screen")
+        textbutton _(u"Theme Test") action Jump("_theme_test")
+        textbutton _(u"Style Hierarchy") action Jump("_style_hierarchy")
+        textbutton _(u"Image Location Picker") action Jump("_image_location_picker")
+        textbutton _(u"Filename List") action Jump("_filename_list")
+        
+init python hide:
+    style._developer_button = Style(style.button)
+    style._developer_button.size_group = "_developer"
+        
 label _developer_screen:

-    python hide:
-
-        ui.window(style=style.gm_root)
-        ui.null()
-        
-        ui.frame(xpos=10, ypos=10, style=style.menu_frame)
-        ui.vbox(box_first_spacing=10)
-        layout.label(u"Developer Menu", None)
-
-        sg = "developer_menu"
-
-        layout.button("Return", None, clicked=ui.returns(True), size_group=sg)
-        layout.button("Reload Game (Shift+R)", None, clicked=ui.callsinnewcontext("_save_reload_game"), size_group=sg)
-        layout.button("Variable Viewer", None, clicked=ui.jumps("_debugger_screen"), size_group=sg)
-        layout.button("Theme Test", None, clicked=ui.jumps("_theme_test"), size_group=sg)
-        layout.button("Style Hierarchy", None, clicked=ui.jumps("_style_hierarchy"), size_group=sg)
-        
-        ui.close()
-        ui.interact()
+    call screen _developer
        
    return 
        
@@ -95,7 +97,7 @@ label _theme_test:
                return ""
        
        toggle_var = True
-        adj = ui.adjustment(100, 25, page=25)
+        adj = ui.adjustment(100, 25, page=25, adjustable=True)
        
        while True:

@@ -287,3 +289,213 @@ init 1050 python:
        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, 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
+                print fn
+                
+        f.close()
+        
+        renpy.launch_editor(["files.txt"], transient=1)
+        
+    
+    jump _developer_screen
+        
+
+init python:
+    config.underlay.append(im.Tile("_transparent_tile.png"))
+    
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('joystick_preferences')
@@ -75,7 +78,7 @@ init python:
                ui.close()

                _joystick_get_binding()
-                binding = ui.interact()
+                binding = ui.interact(mouse="gamemenu")
                _joystick_take_binding(binding, key)
                
                return True
@@ -100,7 +103,7 @@ label joystick_preferences_screen:
        python:
            layout.navigation("joystick_preferences")
            _joystick_preferences()
-            ui.interact()
+            ui.interact(mouse="gamemenu")

            
        
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('load_save')
@@ -73,7 +76,9 @@ init python:
        
        ui.button(style=style.file_picker_entry[index],
                  clicked=clicked,
-                  role=("selected_" if newest else ""))
+                  role=("selected_" if newest else ""),
+                  keymap={ "save_delete" : ui.returns(("unlink", name)) }
+                  )

        ui.hbox(style=style.file_picker_entry_box[index])

@@ -183,8 +188,11 @@ init python:
            else:
                base += 1

-        return base + int((int(filename) - 1) / per_page)
-
+        try:
+            return base + int((int(filename) - 1) / per_page)
+        except:
+            return base
+        
    # Processes a screenshot.
    def _file_picker_process_screenshot(s):
        return s
@@ -193,36 +201,45 @@ init python:
    # the list of save files.
    def _file_picker(screen, 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
-
-        # 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")
-
-
+        # 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

@@ -291,9 +308,14 @@ init python:
            ui.close() # slots
            ui.close() # whole thing

-            result = ui.interact()
+            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

@@ -311,7 +333,7 @@ label save_screen:
            fn = _file_picker("save", True)

            if renpy.can_load(fn):
-                if not layout.yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
                    continue

            renpy.save(fn, extra_info=store.save_name)
@@ -325,7 +347,7 @@ label load_screen:
            fn = _file_picker("load", False)
            
            if _load_prompt:
-                if not layout.yesno_prompt("load",  u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                if not layout.yesno_prompt("load", layout.LOADING):
                    continue

            renpy.load(fn)
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('main_menu')
@@ -50,7 +53,7 @@ label main_menu_screen:

        ui.close()

-        ui.interact()
+        ui.interact(mouse="mainmenu")
        
    return
            
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('navigation')
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('preferences')
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
    
    # Styles
@@ -54,7 +57,7 @@ init python:

        ui.close()

-        ui.interact()
+        ui.interact(mouse="gamemenu")

    class _Preference(object):
        """
@@ -130,7 +133,7 @@ init python:
        a channel.
        """

-        def __init__(self, name, mixer, enable='True', sound='None', channel=0):
+        def __init__(self, name, mixer, enable='True', sound='None', channel="sound"):
            """
            @param name: The name of this preference, as shown to the user.

@@ -357,15 +360,18 @@ init python hide:
    _VolumePreference(u"Music Volume",
                      'music',
                      'config.has_music')
+
    _VolumePreference(u"Sound Volume",
                      'sfx',
                      'config.has_sound',
-                      'config.sample_sound')
+                      'config.sample_sound',
+                      'sound')
+
    _VolumePreference(u'Voice Volume',
                      'voice',
                      'config.has_voice',
                      'config.sample_voice',
-                      2)
+                      'voice')

    _JumpPreference(u'Joystick...',
                    'joystick_preferences_screen',
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:

    layout.provides('yesno_prompt')
@@ -49,7 +52,7 @@ init python hide:
        ui.close()
        ui.close()

-        rv = ui.interact()
+        rv = ui.interact(mouse="gamemenu")
        renpy.transition(config.intra_transition)
        return rv

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('main_menu')
@@ -62,7 +65,7 @@ label main_menu_screen:
            
        ui.close() # outer box

-        ui.interact()
+        ui.interact(mouse="mainmenu")
        
    return
            
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('navigation')
@@ -1,46 +1,69 @@
+# Copyright 2004-2011 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):
+        def __init__(self, screen, ground, idle, hover, selected_idle, selected_hover, hotspots, navigation=True, variant=None):

-            self.idle = idle
-            self.hover = hover
-            self.selected_idle = selected_idle
-            self.selected_hover = selected_hover
+            # 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 hotspots:
+            for (x1, y1, x2, y2, name) in maybe_variant(hotspots):
                self.hotspots[name] = (x1, y1, x2, y2)

-            # 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)
+            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]
+                # 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
+                    if not eval(enable):
+                        continue

-                self.button(name, act, screen == screen_)
+                    self.button(name, act, screen == screen_)
                
-        def button(self, name, clicked, selected):
+        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:
@@ -63,6 +86,7 @@ init python:
                clicked=clicked,
                focus_mask=True,
                style='imagemap_button',
+                keymap=keymap,
                )

            return (x1, y1, x2, y2)
@@ -73,6 +97,8 @@ init python:
            if name not in self.hotspots:
                return

+            self.remaining_hotspots.discard(name)
+
            x1, y1, x2, y2 = self.hotspots[name]

            ui.bar(
@@ -93,6 +119,9 @@ init python:
                thumb=None,
                thumb_shadow=None,
                thumb_offset=0)
+
+        def nothing(self, name):
+            self.remaining_hotspots.discard(name)
            
        def close(self):
            ui.close()
@@ -1,22 +1,25 @@
+# Copyright 2004-2011 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 = None
+    config.load_save_ground = { }

    # The idle image.
-    config.load_save_idle = None
+    config.load_save_idle = { }

    # The hover image.
-    config.load_save_hover = None
+    config.load_save_hover = { }

    # The selected idle image.
-    config.load_save_selected_idle = None
+    config.load_save_selected_idle = { }

    # The selected hover image.
-    config.load_save_selected_hover = None
+    config.load_save_selected_hover = { }

    # The hotspots. Each hotspot is defined by a tuple giving:
    # - The x-coordinate of the left side.
@@ -24,7 +27,7 @@ init python:
    # - 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 = None
+    config.load_save_hotspots = { }
    
    # Define styles
    style.file_picker_text = Style(style.large_button_text, help="text inside a file picker entry")
@@ -61,7 +64,9 @@ init python:

        import time

-        (x1, y1, x2, y2) = ime.button("slot_%d" % index, clicked, newest)
+        (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)
        
@@ -146,8 +151,11 @@ init python:
            else:
                base += 1

-        return base + int((int(filename) - 1) / per_page)
-
+        try:
+            return base + int((int(filename) - 1) / per_page)
+        except:
+            return base
+        
    # Processes a screenshot.
    def _file_picker_process_screenshot(s):
        return s
@@ -157,8 +165,13 @@ init python:

        hotspots = set()

-        for (x1, y1, x2, y2, name) in config.load_save_hotspots:
-            hotspots.add(name)
+        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)
@@ -202,32 +215,39 @@ init python:
        # The number of slots in a page.
        file_page_length = __scratch.per_page

-        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")
-
+        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

@@ -240,7 +260,8 @@ init python:
                config.load_save_hover,
                config.load_save_selected_idle,
                config.load_save_selected_hover,
-                config.load_save_hotspots)
+                config.load_save_hotspots,
+                variant=screen)
                

            def tb(enabled, label, clicked, selected):
@@ -289,9 +310,14 @@ init python:

            ime.close()
                
-            result = ui.interact()
+            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

@@ -309,7 +335,7 @@ label save_screen:
            fn = _file_picker("save", True)

            if renpy.can_load(fn):
-                if not layout.yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
                    continue

            renpy.save(fn, extra_info=store.save_name)
@@ -322,7 +348,7 @@ label load_screen:
            fn = _file_picker("load", False)
            
            if _load_prompt:
-                if not layout.yesno_prompt("load",  u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                if not layout.yesno_prompt("load",  layout.LOADING):
                    continue

            renpy.load(fn)
@@ -1,13 +1,20 @@
+# Copyright 2004-2011 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 = None
+    config.main_menu_ground = { }

-    # The selected image.
-    config.main_menu_selected = None
+    # 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.
@@ -16,7 +23,10 @@ init python:
    # - 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 = [ ]
+    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:

@@ -28,27 +38,42 @@ label main_menu_screen:
        # Show the background.
        ui.window(style='mm_root')
        ui.null()
-        
-        rv = renpy.imagemap(
+
+        ime = _ImageMapper(
+            None,
            config.main_menu_ground,
+            config.main_menu_idle,
            config.main_menu_selected,
-            config.main_menu_hotspots)
-
-        for e in config.main_menu:
-            name = e[0]
-            act = e[1]
-            enable = e[2]
+            config.main_menu_idle,
+            config.main_menu_selected,
+            config.main_menu_hotspots,
+            navigation=False,
+            variant=_main_menu_variant)
            
-            if name == rv:
+        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 isinstance(act, basestring):
-                    act = ui.jumpsoutofcontext(act)
-                act()
+            if not eval(enabled):
+                act = None

-                break
-        else:
-            ui.jumpsoutofcontext(rv)()
+            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
            
            
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('navigation')
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('preferences')
@@ -74,12 +77,12 @@ init python:
            ime.button("Joystick", ui.jumps("joystick_preferences_screen"), False)

        def play_sound():
-            renpy.sound.play(config.sample_sound)
+            renpy.music.play(config.sample_sound, channel="sound")

        ime.button("Sound Test", play_sound, False)

        def play_voice():
-            renpy.sound.play(config.sample_sound, channel=2)
+            renpy.music.play(config.sample_sound, channel="voice")

        ime.button("Voice Test", play_voice, False)

@@ -121,13 +124,16 @@ init python:
            _preferences.set_volume('sfx', v / 128.0)
        def set_voice(v):
            _preferences.set_volume('voice', v / 128.0)
-            
-        ime.bar("Music Volume", 128, int(_preferences.get_volume('music') * 128), set_music)
-        ime.bar("Sound Volume", 128, int(_preferences.get_volume('sfx') * 128), set_sound)
-        ime.bar("Voice Volume", 128, int(_preferences.get_volume('voice') * 128), set_voice)

+        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()
+        ui.interact(mouse="gamemenu")
        
 label preferences_screen:

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:

    layout.provides('yesno_prompt')
@@ -8,15 +11,18 @@ init python hide:
    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)")

-    # Configuration variables
+    # 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_hotspots = None
+
+    config.yesno_prompt_message_images = { }
+
    
    def yesno_prompt(screen, message):
        renpy.transition(config.intra_transition)
-
+        
        ime = _ImageMapper(
            screen,
            config.yesno_prompt_ground,
@@ -31,9 +37,15 @@ init python hide:

        ime.close()
        
-        layout.prompt(message, "yesno")
+        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()
+        rv = ui.interact(mouse="gamemenu")
        renpy.transition(config.intra_transition)
        return rv

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('preferences')
@@ -0,0 +1,16 @@
+# Copyright 2004-2011 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
+    
+
+
@@ -0,0 +1,19 @@
+# Copyright 2004-2011 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
+
@@ -0,0 +1,14 @@
+# Copyright 2004-2011 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
+
@@ -0,0 +1,16 @@
+# Copyright 2004-2011 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
+    
+
+
@@ -0,0 +1,11 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+
+    def yesno_prompt(screen, message):
+        return renpy.call_screen('yesno_prompt', message=message, yes_action=Return(True), no_action=Return(False))
+    
+    layout.yesno_prompt = yesno_prompt
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('load_save')
@@ -69,125 +72,134 @@ init python:
            
    def _file_picker(screen):

-        @renpy.curry
-        def hovered(thumbnail):
-            if __session.thumbnail is not thumbnail:
-                __session.thumbnail = thumbnail
-                renpy.restart_interaction()
+        while True:

-        @renpy.curry
-        def unhovered(thumbnail):
-            if __session.thumbnail is thumbnail:
-                __session.thumbnail = None
-                renpy.restart_interaction()
+            @renpy.curry
+            def hovered(thumbnail):
+                if __session.thumbnail is not thumbnail:
+                    __session.thumbnail = thumbnail
+                    renpy.restart_interaction()

-        __session.thumbnail = None
-        
-        layout.navigation(screen)
-        
-        newest = None
-        newest_time = None
+            @renpy.curry
+            def unhovered(thumbnail):
+                if __session.thumbnail is thumbnail:
+                    __session.thumbnail = None
+                    renpy.restart_interaction()

-        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(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 "")
-                
-                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:
-            rv = ui.interact()
-        finally:
-            __session.scrollbar_position = adj.value
            __session.thumbnail = None

-        return rv
+            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:
@@ -197,7 +209,7 @@ label save_screen:
            fn = _file_picker("save")

            if renpy.can_load(fn):
-                if not layout.yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
                    continue

            renpy.save(fn, extra_info=store.save_name)
@@ -211,7 +223,7 @@ label load_screen:
            fn = _file_picker("load")
            
            if _load_prompt:
-                if not layout.yesno_prompt("load",  u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                if not layout.yesno_prompt("load",  layout.LOADING):
                    continue

            renpy.load(fn)
@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('preferences')
--- a/Show More
+++ b/Show More