Bump version.

Ignore attempts to play None as sound/music.
This is a minor behavior change. Before this, renpy.play would stop the playing sound if called with None - which is the default in a lot of circumstances.
2012-09-11 01:28:40 -04:00 · 2012-09-09 22:47:23 -04:00 · 2012-09-04 22:29:38 -04:00 · 2012-08-28 20:16:14 -04:00 · 2012-08-28 19:42:32 -04:00 · 2012-08-28 19:13:25 -04:00
637 changed files with 103202 additions and 21715 deletions
@@ -1,62 +0,0 @@
-build
-dist
-dists
-renpy.app
-**/*.rpyc
-**/*.rpyb
-**/*.rpymc
-_renpy.c
-nativemidi.c
-sound.c
-winmixer.c
-jedit
-lint.txt
-renpy.code
-traceback.txt
-doc/common.css
-doc/images
-doc/index.html
-doc/monobook.css
-doc/monobook2.css
-doc/reference
-doc/shared.css
-doc/tutorials
-doc/www.renpy.org
-testing
-translations.rpy
-launchertrans.rpy
-jcc
-scite/scite.zip
-screenshot*
-.ropeproject
-release_cardgame.sh
-cardgame
-dse.split
-empty
-empty-linux-x86.tar.bz2
-empty-mac.zip
-empty.zip
-errors.txt
-icons
-iliad-icon.png
-iliad-work
-kuroi
-lsprofcalltree.py
-manifest.xml
-mediatest
-musicroom
-nobmtest
-renpy-iliad.sh
-renpy.kcg
-renpy.stats
-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
@@ -0,0 +1,54 @@
+*.rpyc
+*.rpyb
+*.rpymc
+*.pyc
+*.pyo
+
+*~
+*.bak 
+
+saves
+tmp
+cache
+
+log.txt
+
+/build
+/dist
+/dists
+/renpy.app
+/jedit
+/lint.txt
+/renpy.code
+/traceback.txt
+/testing*
+/screenshot*
+/errors.txt
+/styles.txt
+/Microsoft.VC90.CRT.manifest
+/console.exe
+/msvcr90.dll
+/python27.dll
+/renpy.exe
+/lib/windows-x86
+/lib/linux-x86_64
+/lib/linux-i686
+/lib/python2.7
+/doc
+/.pydevproject
+/.pydevproject.bak
+/.project
+/.settings
+/LICENSE.txt
+/template/README.html
+/the_question/README.html
+/tutorial/README.html
+/renpy/angle/*.pyx
+/renpy/angle/*.pxd
+/renpy-ppc.zip
+/module/build
+/module/gen
+/editra
+
+dl
+renpy/vc_version.py
@@ -1,3 +1,138 @@
+
+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
 --------------------

@@ -1,761 +0,0 @@
-Ren'Py itself is covered by the terms of the following (MIT) license:
-
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation files
-(the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-Please see each individual source file for a list of copyright
-holders. The artwork in the demo is released by various copyright
-holders, under the same terms.
-
-
-The Ren'Py module, the Ren'Py windows binaries, and the various Ren'Py
-launchers may contain code taken from the following projects:
-
-    * Python (Python License)
-    * Pygame (LGPL)
-    * SDL (LGPL)
-    * SDL_image (LGPL)
-    * SDL_ttf (LGPL)
-    * SDL_mixer (LGPL)
-    * Freetype (LGPL)
-    * FFmpeg (LGPL)
-    * Fribidi (LGPL)
-    * jpeg (JPEG License)
-    * libpng (PNG license)
-    * zlib (Zlib License)
-    * bzip2 (Bzip2 License)
-    * pyobjc (MIT License)
-
-The Linux build may also include code from:
-
-    * directfb (LGPL)
-    * svgalib (LGPL)
-
-For the purpose of LGPL compliance, the source code to all LGPL
-software we depend on is either in the Ren'Py package (available from
-http://www.renpy.org/), or in the renpy-deps package
-(http://www.renpy.org/dl/lgpl/). We believe compliance can be achieved
-by including a copy of this license with every copy of Ren'Py you
-distribute, and referring to it in your project's README file.
-
-The default Ren'Py build distributes Ren'Py alongside jEdit, which is
-licensed under the GNU GPL. The source code to jEdit is distributed as
-part of the renpy-deps package (http://www.renpy.org/dl/lgpl/).
-
-
-GNU Lesser General Public License
-=================================
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-        51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations
-below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it
-becomes a de-facto standard.  To achieve this, non-free programs must
-be allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control
-compilation and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at least
-    three years, to give the same user the materials specified in
-    Subsection 6a, above, for a charge no more than the cost of
-    performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply, and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License
-may add an explicit geographical distribution limitation excluding those
-countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms
-of the ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.
-It is safest to attach them to the start of each source file to most
-effectively convey the exclusion of warranty; and each file should
-have at least the "copyright" line and a pointer to where the full
-notice is found.
-
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or
-your school, if any, to sign a "copyright disclaimer" for the library,
-if necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James
-  Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
-Python License
-==============
-
-1. This LICENSE AGREEMENT is between the Python Software Foundation
-("PSF"), and the Individual or Organization ("Licensee") accessing and
-otherwise using Python 2.3 software in source or binary form and its
-associated documentation.
-
-2. Subject to the terms and conditions of this License Agreement, PSF
-hereby grants Licensee a nonexclusive, royalty-free, world-wide
-license to reproduce, analyze, test, perform and/or display publicly,
-prepare derivative works, distribute, and otherwise use Python 2.3
-alone or in any derivative version, provided, however, that PSF's
-License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
-2001, 2002 Python Software Foundation; All Rights Reserved" are
-retained in Python 2.3 alone or in any derivative version prepared by
-Licensee.
-
-3. In the event Licensee prepares a derivative work that is based on
-or incorporates Python 2.3 or any part thereof, and wants to make
-the derivative work available to others as provided herein, then
-Licensee hereby agrees to include in any such work a brief summary of
-the changes made to Python 2.3.
-
-4. PSF is making Python 2.3 available to Licensee on an "AS IS"
-basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
-IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
-DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
-FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.3 WILL NOT
-INFRINGE ANY THIRD PARTY RIGHTS.
-
-5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
-2.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
-A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.3,
-OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-
-6. This License Agreement will automatically terminate upon a material
-breach of its terms and conditions.
-
-7. Nothing in this License Agreement shall be deemed to create any
-relationship of agency, partnership, or joint venture between PSF and
-Licensee.  This License Agreement does not grant permission to use PSF
-trademarks or trade name in a trademark sense to endorse or promote
-products or services of Licensee, or any third party.
-
-8. By copying, installing or otherwise using Python 2.3, Licensee
-agrees to be bound by the terms and conditions of this License
-Agreement.
-
-
-Jpeg License
-============
-
-In plain English:
-
-1. We don't promise that this software works.  (But if you find any bugs,
-   please let us know!)
-2. You can use this software for whatever you want.  You don't have to pay us.
-3. You may not pretend that you wrote this software.  If you use it in a
-   program, you must acknowledge somewhere in your documentation that
-   you've used the IJG code.
-
-In legalese:
-
-The authors make NO WARRANTY or representation, either express or implied,
-with respect to this software, its quality, accuracy, merchantability, or
-fitness for a particular purpose.  This software is provided "AS IS", and you,
-its user, assume the entire risk as to its quality and accuracy.
-
-This software is copyright (C) 1991-1998, Thomas G. Lane.
-All Rights Reserved except as specified below.
-
-Permission is hereby granted to use, copy, modify, and distribute this
-software (or portions thereof) for any purpose, without fee, subject to these
-conditions:
-(1) If any part of the source code for this software is distributed, then this
-README file must be included, with this copyright and no-warranty notice
-unaltered; and any additions, deletions, or changes to the original files
-must be clearly indicated in accompanying documentation.
-(2) If only executable code is distributed, then the accompanying
-documentation must state that "this software is based in part on the work of
-the Independent JPEG Group".
-(3) Permission for use of this software is granted only if the user accepts
-full responsibility for any undesirable consequences; the authors accept
-NO LIABILITY for damages of any kind.
-
-These conditions apply to any software derived from or based on the IJG code,
-not just to the unmodified library.  If you use our work, you ought to
-acknowledge us.
-
-Permission is NOT granted for the use of any IJG author's name or company name
-in advertising or publicity relating to this software or products derived from
-it.  This software may be referred to only as "the Independent JPEG Group's
-software".
-
-We specifically permit and encourage the use of this software as the basis of
-commercial products, provided that all warranty or liability claims are
-assumed by the product vendor.
-
-
-PNG License
-===========
-
-The PNG Reference Library is supplied "AS IS".  The Contributing Authors
-and Group 42, Inc. disclaim all warranties, expressed or implied,
-including, without limitation, the warranties of merchantability and of
-fitness for any purpose.  The Contributing Authors and Group 42, Inc.
-assume no liability for direct, indirect, incidental, special, exemplary,
-or consequential damages, which may result from the use of the PNG
-Reference Library, even if advised of the possibility of such damage.
-
-Permission is hereby granted to use, copy, modify, and distribute this
-source code, or portions hereof, for any purpose, without fee, subject
-to the following restrictions:
-
-1. The origin of this source code must not be misrepresented.
-
-2. Altered versions must be plainly marked as such and must not
-   be misrepresented as being the original source.
-
-3. This Copyright notice may not be removed or altered from any
-   source or altered source distribution.
-
-The Contributing Authors and Group 42, Inc. specifically permit, without
-fee, and encourage the use of this source code as a component to
-supporting the PNG file format in commercial products.  If you use this
-source code in a product, acknowledgment is not required but would be
-appreciated.
-
-Zlib License
-============
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-
-Bzip2 License
-=============
-
-This program, "bzip2", the associated library "libbzip2", and all
-documentation, are copyright (C) 1996-2005 Julian R Seward.  All
-rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. The origin of this software must not be misrepresented; you must 
-   not claim that you wrote the original software.  If you use this 
-   software in a product, an acknowledgment in the product 
-   documentation would be appreciated but is not required.
-
-3. Altered source versions must be plainly marked as such, and must
-   not be misrepresented as being the original software.
-
-4. The name of the author may not be used to endorse or promote 
-   products derived from this software without specific prior written 
-   permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -1,13 +1,4 @@
 #!/bin/sh

-if [ "x$1" = "x" ]; then
-    echo need version
-    exit
-fi
-
-mkdir ~/ab/website/renpy/dl/$1
-cp dists/renpy-$1-* ~/ab/website/renpy/dl/$1
-cp CHANGELOG.txt ~/ab/website/renpy/dl/$1
-
 cd ~/ab/website
 ./upload.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+ln -s ../help.html tutorial/README.html
+ln -s ../help.html the_question/README.html
+ln -s ../help.html template/README.html
+
+ln -s sphinx/source/license.rst LICENSE.txt
+ln -s sphinx/build/html doc
@@ -0,0 +1,10 @@
+# This file sets up the normal python modules. It's used to help eclipse 
+# do type detection, by providing an importable version of the cython code.
+
+from distutils.core import setup
+
+setup(
+    packages=['renpy', 'renpy.gl', 'renpy.angle', 'renpy.display', 'renpy.audio', 'renpy.text', 'pysdlsound'],
+    package_dir={ 'pysdlsound' : 'module' },
+    )
+
@@ -1,21 +1,39 @@
 #!/usr/bin/env python

+import modulefinder
+import shutil
 from distutils.core import setup
-import py2exe
+import py2exe #@UnresolvedImport @UnusedImport
 import sys
 import zipfile
 import traceback
+import os

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

 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,38 +42,40 @@ 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',
                                                'pygame.surfarray',
                                                'pygame.mixer',
                                                'pygame.mixer_music',
-                                                'pygame.font',
                                                '_ssl',
                                                '_hashlib',
                                                'win32con',
                                                'win32api',
                                                'Numeric',
-                                                'locale',
-                                                'gettext',
                                                'os2emxpath',
                                                'macpath',
-                                                'posixpath',
+                                                'multiprocessing',
+                                                '_multiprocessing',
                                                ],
                                 'optimize' : 2,
                                 } },
          )


-    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 +90,22 @@ 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")
+
+    # Take these files from the old python.
+    shutil.copy("c:/Python26/Microsoft.VC90.CRT.manifest", "Microsoft.VC90.CRT.manifest")
+    shutil.copy("c:/Python26/msvcr90.dll", "msvcr90.dll")
+
+    move_from_dist("lib/windows-x86")
+    move_from_dist("console.exe")
+    move_from_dist("python27.dll")
+    move_from_dist("renpy.exe")
+
+
 try:
    main()
 except:
    traceback.print_exc()

-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 \"\""
-        
-        
-        
@@ -3,8 +3,6 @@
 import collections
 import glob
 import re
-import sys
-import time
 import os

 # A map from string to filename, line number where the string is found.
@@ -40,6 +38,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")

@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains warpers that are used by ATL. They need to be defined
 # early, so Ren'Py knows about them when parsing other files.

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

    # This is called when script_version is set, to immediately
@@ -26,8 +29,46 @@ init -1210 python:
            store.offscreenleft = Position(xpos=0.0, xanchor=1.0)
            store.offscreenright = Position(xpos=1.0, xanchor=0.0)

+        if version <= (6, 10, 2):
+            # Before 6.11, we used the image placement to handle
+            # the location of things on the screen.            
+            style.image_placement.xpos = 0.5
+            style.image_placement.ypos = 1.0
+            style.image_placement.xanchor = 0.5
+            style.image_placement.yanchor = 1.0
+
+            config.transform_uses_child_position = False
+            config.default_transform = None
+            config.start_scene_black = True
            
+        if version <= (6, 11, 0):
+            config.movetransition_respects_offsets = False
+
+        if version <= (6, 11, 2):
+            config.imagereference_respects_position = True
+            config.predict_screens = False
+            config.choice_screen_chosen = False
+
+        if version <= (6, 12, 0):
+            config.keep_running_transform = False
+            config.image_attributes = False
+            config.new_character_image_argument = False
+            config.save_physical_size = False
            
+        if version <= (6, 12, 2):
+            style.default.language = "western"
+            style.default.layout = "greedy"
+            config.new_substitutions = False
+            config.broken_line_spacing = True
+    
+        if (6, 12, 2) < version <= (6, 13, 8):
+            config.old_substitutions = False
+    
+        if version <= (6, 13, 12):
+            global MoveTransition
+            MoveTransition = OldMoveTransition
+
+
 init 1210 python hide::

    # This returns true if the script_version is <= the
@@ -80,3 +121,8 @@ init 1210 python hide::
            
    for i in layout.compat_funcs:
        i()
+
+    if config.hyperlink_styler or config.hyperlink_callback or config.hyperlink_focus:
+        style.default.hyperlink_functions = (config.hyperlink_styler, config.hyperlink_callback, config.hyperlink_focus)
+        
+        
@@ -1,9 +1,16 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains a number of definitions of standard
 # locations and transitions. We've moved them into the common
 # directory so that it's easy for an updated version of all of these
 # definitions.

 init -1110:
+
+    transform reset:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+   
    # These are positions that can be used inside at clauses. We set
    # them up here so that they can be used throughout the program.
    transform left:
@@ -17,6 +24,15 @@ init -1110:

    transform truecenter:
        xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+
+    transform topleft:
+        xpos 0.0 xanchor 0.0 ypos 0.0 yanchor 0.0
+        
+    transform topright:
+        xpos 1.0 xanchor 1.0 ypos 0.0 yanchor 0.0
+        
+    transform top:
+        xpos 0.5 xanchor 0.5 ypos 0.0 yanchor 0.0
        
    # Offscreen positions for use with the move transition. Images at
    # these positions are still shown (and consume
@@ -27,14 +43,32 @@ init -1110:
    transform offscreenright:
        xpos 1.0 xanchor 0.0 ypos 1.0 yanchor 1.0

+    transform default:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    # These are used by the transitions to move things offscreen. We don't
+    # expect them to be used by user code.
+    transform _moveleft:
+        xpos 0.0 xanchor 1.0
+        
+    transform _moveright:
+        xpos 1.0 xanchor 0.0
+        
+    transform _movetop:
+        ypos 0.0 yanchor 1.0
+        
+    transform _movebottom:
+        ypos 1.0 yanchor 0.0
+
+    python:
+        config.default_transform = default
+        

 init -1110 python:

    _define = define = object()
        
-    # Positions ##############################################################
-
-
    # Transitions ############################################################

    # Simple transitions.
@@ -63,6 +97,7 @@ init -1110 python:

    # Ease images around. These are basically cosine-warped moves.
    def _ease_out_time_warp(x):
+        print "ZZZ"
        import math
        return 1.0 - math.cos(x * math.pi / 2.0)

@@ -74,70 +109,136 @@ init -1110 python:
        import math
        return .5 - math.cos(math.pi * x) / 2.0

-    # This defines a family of move transitions.
+
+    # Back up the move transition, so that if MoveTransition gets replaced by
+    # renpy.compat, this still works.
+    __MoveTransition = MoveTransition
+
+    # This defines a family of move transitions, using the old-style methods.
    def move_transitions(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[ 'master' ], **kwargs):
+        """
+        :doc: transition_family
+
+        This defines a family of move transitions, similar to the move and ease
+        transitions. For a given `prefix`, this defines the transitions:
+
+        * *prefix*- A transition that takes `delay` seconds to move images that
+          changed positions to their new locations.
+
+        * *prefix*\ inleft, *prefix*\ inright, *prefix*\ intop, *prefix*\ inbottom - Transitions
+          that take `delay` seconds to move images that changed positions to their
+          new locations, with newly shown images coming in from the appropriate
+          side.
+
+        * *prefix*\ outleft, *prefix*\ outright, *prefix*\ outtop, *prefix*\ outbottom -
+          Transitions that take `delay` seconds to move images that changed
+          positions to their new locations, with newly hidden images leaving via
+          the appropriate side.
+
+        `time_warp`, `in_time_warp`, `out_time_warp`        
+            Time warp functions that are given a time from 0.0 to 1.0 representing
+            the fraction of the move complete, and return a value in the same 
+            range giving the fraction of a linear move that is complete.
+            
+            This can be used to define functions that ease the images around,
+            rather than moving them at a constant speed.
+            
+            The three argument are used for images remaining on the screen,
+            newly shown images, and newly hidden images, respectively.
+
+        `old`
+            If true, the transitions to move the old displayables, rather than the new ones.
+
+        `layers`        
+            The layers the transition will apply to.
+
+        ::
+
+            # This defines all of the pre-defined transitions beginning
+            # with "move".
+            init python:
+                define.move_transitions("move", 0.5)
+        
+        """
+        
        moves = {
            "" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs)),
+                time_warp=time_warp),

            "inright" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                enter_factory=MoveIn((1.0, None, 0.0, None), time_warp=in_time_warp, **kwargs)),
+                enter=_moveright,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),

            "inleft" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                enter_factory=MoveIn((0.0, None, 1.0, None), time_warp=in_time_warp, **kwargs)),
-
+                enter=_moveleft,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+                
            "intop" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                enter_factory=MoveIn((None, 0.0, None, 1.0), time_warp=in_time_warp, **kwargs)),
-
+                enter=_movetop,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),
+                
            "inbottom" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs),
-                enter_factory=MoveIn((None, 1.0, None, 0.0), time_warp=in_time_warp, **kwargs)),
+                enter=_movebottom,
+                time_warp=time_warp,
+                enter_time_warp=in_time_warp,
+                ),

            "outright" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                leave_factory=MoveOut((1.0, None, 0.0, None), time_warp=out_time_warp, **kwargs)),
+                leave=_moveright,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),

            "outleft" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                leave_factory=MoveOut((0.0, None, 1.0, None), time_warp=out_time_warp, **kwargs)),
+                leave=_moveleft,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),

            "outtop" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                leave_factory=MoveOut((None, 0.0, None, 1.0), time_warp=out_time_warp, **kwargs)),
+                leave=_movetop,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),

            "outbottom" : MoveTransition(
                delay,
                old=old,
                layers=layers,
-                factory=MoveFactory(time_warp=time_warp, **kwargs), 
-                leave_factory=MoveOut((None, 1.0, None, 0.0), time_warp=time_warp, **kwargs)),
+                leave=_movebottom,
+                time_warp=time_warp,
+                leave_time_warp=out_time_warp,
+                ),
            }

        for k, v in moves.iteritems():
@@ -149,10 +250,10 @@ init -1110 python:
    define.move_transitions("move", 0.5)
    define.move_transitions("ease", 0.5, _ease_time_warp, _ease_in_time_warp, _ease_out_time_warp) 

-    # Zoom-based transitions.
-    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))
+    # Zoom-based transitions. Legacy - nowadays, these are probably best done with ATL.
+    zoomin = OldMoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0))
+    zoomout = OldMoveTransition(0.5, leave_factory=ZoomInOut(1.0, 0.01))
+    zoominout = OldMoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0), leave_factory=ZoomInOut(1.0, 0.01))
    
    # These shake the screen up and down for a quarter second.
    # The delay needs to be an integer multiple of the period.
@@ -176,3 +277,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,329 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1135 python:
+
+    class __GalleryAllPriorCondition(object):
+
+        def check(self, all_prior):
+            return all_prior
+
+    
+    class __GalleryArbitraryCondition(object):
+        def __init__(self, condition):
+            self.condition = condition
+
+        def check(self, all_prior):
+            return eval(self.condition)
+
+                    
+    class __GalleryUnlockCondition(object):
+        def __init__(self, images):
+            self.images = images
+            
+        def check(self, all_prior):
+            for i in self.images:
+                if not renpy.seen_image(i):
+                    return False
+
+            return True
+            
+            
+    class __GalleryImage(object):
+        def __init__(self, gallery, displayables):
+            
+            # The gallery object we belong to.
+            self.gallery = gallery
+            
+            # A list of conditions for this image to be displayed.
+            self.conditions = [ ]
+            
+            # A list of displayables to show.
+            self.displayables = displayables
+            
+            # A list of transforms to apply to those displayables, or None
+            # to not apply a transform.
+            self.transforms = [ None ] * len(displayables)
+
+
+        def check_unlock(self, all_prior):
+            """
+            Returns True if the image is unlocked.
+            """
+        
+            for i in self.conditions:
+                if not i.check(all_prior):
+                    return False
+
+            return True
+        
+        def show(self, locked, index, count):
+            """
+            Shows this image when it's unlocked.
+            """
+
+            renpy.transition(self.gallery.transition)
+            ui.saybehavior()
+
+            displayables = [ ]
+
+            for d, transform in zip(self.displayables, self.transforms):
+
+                if transform is not None:
+                    d = transform(d)
+                else:
+                    d = config.default_transform(d)
+
+                displayables.append(d)
+                
+            renpy.show_screen("_gallery", locked=locked, index=index + 1, count=count, displayables=displayables, gallery=self.gallery)
+            ui.interact()
+
+    class __GalleryButton(object):
+        def __init__(self, gallery):
+            self.gallery = gallery
+            self.images = [ ]
+            self.conditions = [ ]            
+            
+        def check_unlock(self):
+            for i in self.conditions:
+                if not i.check(True):
+                    return False
+            
+            for i in self.images:
+                if i.check_unlock(False):
+                    return True
+
+            return False
+
+        def show(self):
+
+            all_prior = True
+
+            for i, img in enumerate(self.images):
+                locked = not img.check_unlock(all_prior)
+                img.show(locked, i, len(self.images))
+
+            renpy.transition(self.gallery.transition)
+            
+    class Gallery(object):
+        """
+        :doc: gallery class
+        
+        This class supports the creation of an image gallery by handling the 
+        locking of images, providing an action that can show one or more images, 
+        and a providing method that creates buttons that use that action. 
+
+        .. attribute:: transition
+
+            The transition that is used when changing images.
+
+        .. attribute:: locked_button
+        
+            The default displayable used by make_button for a locked button.
+            
+        .. attribute:: hover_border
+
+            The default hover border used by make_button.
+            
+        .. attribute:: idle_border
+        
+            The default idle border used by make_button.
+        """
+
+        transition = None
+        
+        hover_border = None
+        idle_border = None
+
+        locked_button = None
+
+        def __init__(self):
+    
+            # A map from button name (or image) to __GalleryButton object.
+            self.buttons = { }
+
+            self.button_ = None
+            self.image_ = None
+            self.unlockable = None
+            
+        def button(self, name):
+            """
+            :doc: gallery method
+            
+            Creates a new button, named `name`. 
+            
+            `name`
+                The name of the button being created.
+            """
+                
+            self.button_ = __GalleryButton(self)
+            self.unlockable = self.button_
+            self.buttons[name] = self.button_
+            
+        def image(self, *displayables):
+            """
+            :doc: gallery method
+            
+            Adds a new image to the current button, where an image consists 
+            of one or more displayables.
+            """
+        
+            self.image_ = __GalleryImage(self, displayables)
+            self.button_.images.append(self.image_)
+            self.unlockable = self.image_
+
+        display = image
+
+        def transform(self, *transforms):
+            """
+            :doc: gallery method
+            
+            Applies transforms to the last image registered. This should be
+            called with the same number of transforms as the image has 
+            displayables. The transforms are applied to the corresponding 
+            displayables. 
+            
+            If a transform is None, the default transform is used.
+            """
+
+            self.image_.transforms = transforms
+
+        def unlock(self, *images):
+            """
+            :doc: gallery method
+            
+            A condition that takes one or more image names as argument, and 
+            is satisfied when all the named images have been seen by the 
+            player. The image names should be given as strings.            
+            """            
+
+            self.unlockable.conditions.append(__GalleryUnlockCondition(images))
+
+        def condition(self, expression):
+            """
+            :doc: gallery method
+            
+            A condition that is satisfied when an expression evaluates to true.
+            
+            `expression`
+                A string giving a python expression.
+            """
+
+            if not isinstance(expression, basestring):
+                raise Exception("Gallery condition must be a string containing an expression.")
+
+            self.unlockable.conditions.append(__GalleryArbitraryCondition(expression))
+
+        def allprior(self):
+            """
+            :doc: gallery method
+            
+            A condition that is true if all prior images associated with the 
+            current button have been unlocked.
+            """
+
+            self.unlockable.conditions.append(__GalleryAllPriorCondition())
+    
+        def unlock_image(self, *images):
+            """
+            :doc: gallery method
+                
+            A convenience method that is equivalent to calling image and unlock
+            with the same parameters. This will cause an image to be displayed 
+            if it has been seen before.
+            
+            The images should be specified as strings giving image names.            
+            """
+
+            self.image(*images)
+            self.unlock(*images)
+
+        def Action(self, name):
+            """
+            :doc: gallery method
+            
+            An action that displays the images associated with the given button
+            name.
+            """
+        
+            if name not in self.buttons:
+                raise Exception("{0!r} is not a button defined in this gallery.".format(name))
+                
+            b = self.buttons[name]
+                
+            if b.check_unlock():
+                return ui.invokesinnewcontext(b.show)
+            else:
+                return None
+                
+        def make_button(self, name, unlocked, locked=None, hover_border=None, idle_border=None, **properties):
+            """
+            :doc: gallery method
+            
+            This creates a button that displays the images associated with the given 
+            button name. 
+            
+            `name`
+                The name of the button that will be created.
+                
+            `unlocked`
+                A displayable that is displayed for this button when it is 
+                unlocked.
+                
+            `locked`
+                A displayable that is displayed for this button when it is 
+                locked. If None, the locked_button field of the gallery 
+                object is used instead.
+                
+            `hover_border`
+                A displayable that is used to overlay this button when when 
+                it is unlocked and has focus. If None, the hover_border
+                field of the gallery object is used. 
+ 
+            `idle_border`
+                A displayable that is used to overlay this button when when 
+                it is unlocked but unfocused. If None, the idle_border
+                field of the gallery object is used. 
+            
+            Additional keyword arguments become style properties of the 
+            created button object.
+            """
+            
+            action = self.Action(name)
+            
+            if locked is None:
+                locked = self.locked_button
+                
+            if hover_border is None:
+                hover_border = self.hover_border
+                
+            if idle_border is None:
+                idle_border = self.idle_border
+                
+            return Button(action=action, child=unlocked, insensitive_child=locked, hover_foreground=hover_border, idle_foreground=idle_border, **properties)
+
+
+init -1135:
+
+    # Displays a set of images in the gallery, or indicates that the images 
+    # are locked. This is given the following arguments:
+    #
+    # locked
+    #     True if the image is locked.
+    # displayables
+    #     A list of transformed displayables that should be shown to the user.
+    # index
+    #     A 1-based index of the image being shown.
+    # count
+    #     The number of images attached to the current button.
+    # gallery
+    #     The image gallery object.
+    screen _gallery:
+        if locked:
+            add "#000"            
+            text "Image [index] of [count] locked." align (0.5, 0.5)          
+        else:
+            for d in displayables:
+                add d
+                        
@@ -0,0 +1,377 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This contains code to choose between OpenGL and Software rendering, when
+# a system supports both.
+
+init -1024:
+
+    python hide:
+        import os
+        store.__dxwebsetup = os.path.join(config.renpy_base, "lib", "dxwebsetup.exe")
+
+    python:
+        class _SetRenderer(Action):
+            """
+            Sets the preferred renderer to one of "auto", "angle", "gl", or 
+            "sw". 
+            """
+            
+            def __init__(self, renderer):
+                self.renderer = renderer
+                
+            def __call__(self):
+                _preferences.renderer = self.renderer
+                renpy.restart_interaction()
+                
+            def get_selected(self):
+                return _preferences.renderer == self.renderer
+
+    # This is displayed to ask the user to choose the renderer he or she
+    # wants to use. It takes no parameters, doesn't return anything, and 
+    # is expected to call _SetRenderer actions and quit when done.
+    #
+    # This screen can be customized by the creator, provided the actions 
+    # remain available.    
+    screen _choose_renderer:
+
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+            xpadding 20
+            ypadding 20
+    
+            xmaximum 400
+
+            has vbox
+
+            label _("Graphics Acceleration")
+
+            null height 10
+            
+            textbutton _("Automatically Choose"):
+                action _SetRenderer("auto")
+                xfill True
+                
+            if renpy.renpy.windows:
+                textbutton _("Force Angle/DirectX Renderer"):
+                    action _SetRenderer("angle")
+                    xfill True
+                
+            textbutton _("Force OpenGL Renderer"):
+                action _SetRenderer("gl")
+                xfill True
+
+            textbutton _("Force Software Renderer"):
+                action _SetRenderer("sw")
+                xfill True
+
+            null height 10
+
+            text _("Changes will take effect the next time this program is run.") substitute True
+ 
+            null height 10
+
+            textbutton _(u"Quit"):
+                action Quit(confirm=False)
+                xfill True
+
+            if not renpy.display.interface.safe_mode:
+                textbutton _("Return"): 
+                    action Return(0)
+                    xfill True
+
+
+    # This is displayed when a display performance problem occurs. 
+    # 
+    # `problem` is the kind of problem that is occuring. It can be:
+    # - "sw" if the software renderer was selected.
+    # - "slow" if the performance test failed.
+    # - "fixed" if we're operating w/o shaders.
+    # - other things, added in the future.
+    #
+    # `url` is the url of a web page on renpy.org that will include
+    # info on troubleshooting display problems.
+    screen _performance_warning:
+    
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            xmaximum 400
+
+            has vbox
+
+            label _("Performance Warning")
+            
+            null height 10
+            
+            if problem == "sw":
+                text _("This computer is using software rendering.")
+            elif problem == "fixed":
+                text _("This computer is not using shaders.")
+            elif problem == "slow":
+                text _("This computer is displaying graphics slowly.")
+            else:
+                text _("This computer has a problem displaying graphics: [problem].") substitute True     
+                
+            null height 10
+
+            if directx_update:
+                text _("Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem.")
+            else:            
+                text _("Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display.")
+
+            if directx_update:
+                null height 10
+                
+                textbutton _("Update DirectX"):
+                    action directx_update
+                    xfill True
+            
+            null height 10
+            
+            textbutton _("Continue, Show this warning again"): 
+                action Return(True)
+                xfill True
+                
+            textbutton _("Continue, Don't show warning again"):
+                action Return(False)
+                xfill True
+            
+            null height 10
+        
+            textbutton _("Quit"): 
+                action Quit(confirm=False)
+                xfill True
+
+    # Used while a directx update is ongoing.
+    screen _directx_update:
+        
+        frame:
+            style_group ""
+            
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            xmaximum 400
+
+            has vbox
+                    
+            label _("Updating DirectX.")
+
+            null height 10
+
+            text _("DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX.")
+            
+            null height 10
+        
+            text _("{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box.")
+
+            null height 10      
+                    
+            text _("When setup finishes, please click below to restart this program.")
+
+            textbutton _("Restart") action Return(True)
+
+
+
+init -1024 python:
+    # The image that we fill the screen with in GL-test mode.
+    config.gl_test_image = "black"
+
+    class __GLTest(renpy.Displayable):
+        """
+         This counts the number of times it's been rendered, and
+         the number of seconds it's been displayed, and uses them
+         to make the decisions as to if OpenGL is working or not.
+         """
+        
+        def __init__(self, frames, fps, timeout):
+            super(__GLTest, self).__init__()
+
+            self.target = 1.0 * frames / fps
+            self.frames = frames
+            self.timeout = timeout
+
+            self.times = [ ]
+            self.success = False
+            
+            renpy.renpy.display.log.write("- Target is {0} frames in {1} seconds.".format(frames, self.target))
+            
+        def render(self, width, height, st, at):
+            rv = renpy.Render(width, height)
+
+            if self.success:
+                return rv
+
+            self.times.append(st)
+
+            renpy.redraw(self, 0)
+
+            renpy.renpy.display.log.write("- Frame drawn at %f seconds." % st)
+            
+            if len(self.times) >= self.frames:
+                frames_timing = self.times[-1] - self.times[-self.frames]
+
+                renpy.renpy.display.log.write("- %f seconds to render %d frames.", frames_timing, self.frames)
+
+                if frames_timing <= self.target:
+                    self.success = True
+                    renpy.timeout(0)
+
+            return rv                    
+                            
+        def event(self, ev, x, y, st):
+
+            if self.success:
+                return True
+
+            if st > self.timeout:
+                return False
+
+            renpy.timeout(self.timeout - st)
+   
+    config.performance_test = True
+        
+    def __gl_test():
+
+        import os
+
+        # If we've entered safe mode, display the renderer choice screen.
+        # This screen will cause us to quit.
+
+        if _restart:
+            return
+
+        if not config.gl_enable:
+            return
+    
+        if renpy.display.interface.safe_mode:
+            renpy.call_in_new_context("_choose_renderer")
+
+        if not config.performance_test:
+            return
+
+        _gl_performance_test()
+
+    def _gl_performance_test():
+    
+        import os
+
+        if not _preferences.performance_test and "RENPY_PERFORMANCE_TEST" not in os.environ:
+            return
+
+        # Don't bother on androuid - there's nothing the user can do.
+        if renpy.renpy.android:
+            return
+
+        renpy.renpy.display.log.write("Performance test:")
+            
+        # This will cause the screen to start displaying.
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+        # The problem we have.
+        problem = None
+
+        renderer_info = renpy.get_renderer_info()
+
+        # Software renderer check.
+        if config.renderer != "sw" and renderer_info["renderer"] == "sw":
+            problem = "sw"
+        
+        # Speed check.
+        if problem is None:
+            
+            # The parameters of the performance test. If we do not hit FPS fps
+            # over FRAMES frames before DELAY seconds are up, we fail. 
+            FRAMES = 5
+            FPS = 15
+            DELAY = 1.5
+            
+            renpy.transition(Dissolve(DELAY), always=True, force=True)
+            ui.add(__GLTest(FRAMES, FPS, DELAY))
+            result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+    
+            if not result:
+                problem = "slow"
+
+        # Lack of shaders check.
+        if problem is None:
+            if not "RENPY_GL_ENVIRON" in os.environ:    
+                if renderer_info["renderer"] == "gl" and renderer_info["environ"] == "fixed":
+                    problem = "fixed"
+         
+        if problem is None:
+            return
+
+        if renpy.renpy.windows and os.path.exists(__dxwebsetup):
+            directx_update = Jump("_directx_update")
+        else:
+            directx_update = None
+    
+        # Give the warning message to the user.            
+        renpy.show_screen("_performance_warning", problem=problem, directx_update=directx_update, _transient=True)
+        result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+        
+
+        # Store the user's choice, and continue.        
+        _preferences.performance_test = result
+        return
+        
+            
+label _gl_test:
+
+    # Show the test image.
+    scene
+    show expression config.gl_test_image
+    
+    $ __gl_test()
+                
+    # Hide the test image.
+    scene
+
+    return
+
+# We can assume we're on windows here. We're also always restart once we 
+# make it here.
+label _directx_update:
+
+    if renpy.has_label("directx_update"):
+        jump expression "directx_update"
+
+label _directx_update_main:
+
+    python hide:
+        import subprocess
+        import sys
+        
+        # Start dxsetup. We have to go through startfile to ensure that UAC
+        # doesn't cause problems.
+        os.startfile(__dxwebsetup)
+
+        renpy.show_screen("_directx_update")
+        ui.interact(suppress_overlay=True, suppress_underlay=True)
+        
+        # Restart the current program.
+        subprocess.Popen(sys.argv)
+        renpy.quit()
+    
+label _choose_renderer:    
+    scene expression "#000"
+
+    $ renpy.call_screen("_choose_renderer")    
+    return
+    
+
@@ -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-2012 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):
@@ -334,21 +337,98 @@ init -1105 python hide:
        
    @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 invoke_yesno_prompt(*args):
+        _enter_menu()
+        return layout.yesno_prompt(*args)
+
+    @layout
+    def yesno_screen(message, yes=None, no=None):
+        """
+         :doc: other
+
+         This causes the a yes/no prompt screen with the given message
+         to be displayed. The screen will be hidden when the user hits
+         yes or no.
+
+         `message`
+             The message that will be displayed.
+
+         `yes`
+             An action that is run when the user chooses yes.
+
+         `no`
+             An action that is run when the user chooses no.
+         """
+
+        if renpy.has_screen("yesno_prompt"):
+
+            yes_action = [ Hide("yesno_prompt") ]
+            no_action = [ Hide("yesno_prompt") ]
+
+            if yes is not None:
+                yes_action.append(yes)
+            if no is not None:
+                no_action.append(no)
+            
+            renpy.show_screen(
+                "yesno_prompt", 
+                message=message,
+                yes_action=yes_action,
+                no_action=no_action)
+
+            renpy.restart_interaction()
+            
+            return
+            
+        if renpy.invoke_in_new_context(layout.invoke_yesno_prompt, None, message):
+            if yes is not None:
+                yes()
+        else:
+            if no is not None:
+                no()
+    
+    
+    def __auto_save_extra_info():
+        return save_name
+    
+    config.auto_save_extra_info = __auto_save_extra_info
+                
@@ -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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.

 # This file consists of renpy functions that aren't expected to be
 # touched by the user too much. We reserve the _ prefix for names
@@ -49,11 +47,30 @@ 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.
@@ -77,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.')
@@ -92,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):
        """
@@ -107,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:
@@ -126,33 +176,32 @@ 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__
        
-        pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
-
        # Pick the directory to save into.
        dest = config.renpy_base.rstrip("/")
        
@@ -163,11 +212,11 @@ init -1180 python hide:
            dest = os.path.dirname(dest)
            dest = os.path.dirname(dest)
            dest = os.path.dirname(dest)
-
+            
        # Try to pick a filename.
        i = 1
        while True:
-            fn = dest + "/" + pattern % i
+            fn = os.path.join(dest, config.screenshot_pattern % i)
            if not os.path.exists(fn):
                break
            i += 1
@@ -177,17 +226,40 @@ 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
        
-            
+    _predict_screens = [ ]
+        
+init -1180 python hide:
+    
+    import os
+    config.screenshot_pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
+
    def dump_styles():
        if config.developer:
            renpy.style.write_text("styles.txt")

+    # This is run when entering the game menu.
+    config.game_menu_action = None
+            
    def invoke_game_menu():
        if renpy.context()._menu:
-            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:
@@ -219,7 +291,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,
@@ -233,6 +305,7 @@ init -1180 python hide:
        quit = renpy.quit_event,
        iconify = renpy.iconify,
        help = _help,
+        choose_renderer = renpy.curried_call_in_new_context("_choose_renderer"),
        )

    config.underlay = [ km ]
@@ -262,7 +335,7 @@ init -1180 python hide:

    config.overlay_functions.append(skip_indicator)

-
+    # Hyperlink functions. Duplicated in _errorhandling.rpym.
    def hyperlink_styler(target):
        return style.hyperlink_text

@@ -276,34 +349,43 @@ init -1180 python hide:
        else:
            renpy.call_in_new_context(target)

-    config.hyperlink_styler = hyperlink_styler
-    config.hyperlink_callback = hyperlink_function
+    style.default.hyperlink_functions = (hyperlink_styler, hyperlink_function, None)
+
+    # Prediction of screens.    
+    def predict():
+
+        for s in _predict_screens:
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+
+        s = _game_menu_screen
+
+        if s is None:
+            return
+
+        if renpy.has_screen(s):
+            renpy.predict_screen(s)
+            return
+
+        if s.endswith("_screen"):
+            s = s[:-7]
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+                return
+
+            
+    config.predict_callbacks.append(predict)
+            
+    def imagemap_auto_function(auto_param, variant):
+        rv = auto_param % variant
+
+        if renpy.loadable(rv):
+            return rv
+        else:
+            return None
        
-
-    config.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:
@@ -328,17 +410,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")

-        renpy.music.stop()
-        
-        persistent._reload_save = "reload"
+        renpy.save("_reload-1", "reload save game")
        
        ui.add(Solid((0, 0, 0, 255)))
        ui.text("Reloading script...",
@@ -349,13 +429,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...",
@@ -364,7 +443,7 @@ label _load_reload_game:
        ui.pausebehavior(0)
        ui.interact(suppress_underlay=True, suppress_overlay=True)
        
-        renpy.load(save)
+        renpy.load("_reload-2")

    return

@@ -387,48 +466,17 @@ init 1180 python:
        if config.default_text_cps is not None:
            _preferences.text_cps = config.default_text_cps

-    if config.developer:
-
-        def _inspector(l):
-
-            ui.add("#000")
-            ui.window(xmargin=20, ymargin=20, style='default')
-            ui.vbox()
-
-            ui.text("Style Inspector")
-            ui.text("")
-
-
-            if not l:
-                ui.text("Nothing to inspect.")
+        if config.default_afm_time is not None:
+            _preferences.afm_time = config.default_afm_time
            
-            for depth, width, height, d in l:
+    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
+    

-                s = d.style
-
-                while s:
-                    if s.name:
-                        break
-                    
-                    if s.parent:
-                        s = style.get(s.parent)
-                    else:
-                        break
-                        
-                name = s.name[0] + "".join([ "[%r]" % i for i in s.name[1:] ]) 
-
-                ui.text("  " * depth + u" \u2022 " + d.__class__.__name__ + " : " + name + " (%dx%d)" % (width, height))
-
-            ui.text("")
-            ui.text("(click to continue)")
-                
-            ui.close()
-            ui.saybehavior()
-            ui.interact(suppress_overlay=True, suppress_underlay=True)
-            
-            return
-
-        config.inspector = _inspector
        
 ##############################################################################
 # Code that originated in 00gamemenu.rpy
@@ -513,25 +561,17 @@ init -1180 python:

        ui.interact()

+    def _enter_menu():
+        config.skipping = None
        
-# Run at the end of init, to set up autosaving based on the user's
-# choices.
-init 1180 python:
-
-    if config.has_autosave:
-        config.autosave_slots = 10
-    else:
-        config.autosave_frequency = None
-            
-label _enter_menu:
-    python hide:
        renpy.movie_stop(only_fullscreen=True)
        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))

-        renpy.context()._menu = True
+        for i in config.menu_clear_layers:
+            renpy.scene(layer=i)
        
-        # This may be changed, if we are already in the main menu.
-        renpy.context().main_menu = False
+        renpy.context()._menu = True        
+        renpy.context()._main_menu = False
        renpy.context_dynamic("main_menu")
        renpy.context_dynamic("_window_subtitle")
        renpy.context_dynamic("_window")
@@ -547,11 +587,18 @@ label _enter_menu:
        for i in config.clear_layers:
            renpy.scene(layer=i)
        
-    return
+# Run at the end of init, to set up autosaving based on the user's
+# choices.
+init 1180 python:
+
+    if config.has_autosave:
+        config.autosave_slots = 10
+    else:
+        config.autosave_frequency = None
    
 # Factored this all into one place, to make our lives a bit easier.
 label _enter_game_menu:
-    call _enter_menu from _call__enter_menu_2
+    $ _enter_menu()

    $ renpy.transition(config.enter_transition)

@@ -571,9 +618,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

@@ -615,7 +667,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

@@ -624,7 +676,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"
@@ -650,6 +701,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)
@@ -666,17 +718,25 @@ label _start:

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

    if not _restart and config.auto_load and renpy.can_load(config.auto_load):
        $ renpy.load(config.auto_load)
-    
-    scene black

+    if config.start_scene_black:        
+        scene black
+    else:
+        scene
+        
    if not _restart:
        $ ui.pausebehavior(0)
        $ ui.interact(suppress_underlay=True, suppress_overlay=True)
@@ -684,7 +744,9 @@ label _start:
    $ renpy.block_rollback()

    $ _old_game_menu_screen = _game_menu_screen
+    $ _old_predict_screens = _predict_screens
    $ _game_menu_screen = None
+    $ _predict_screens = [ 'main_menu' ]
    
    if renpy.has_label("splashscreen") and not _restart:
        call expression "splashscreen" from _call_splashscreen_1
@@ -700,20 +762,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.
@@ -723,13 +794,13 @@ label _invoke_main_menu:
 # initialize it.
 label _main_menu(_main_menu_screen="_main_menu_screen"):

-    call _enter_menu from _call__enter_menu_1
+    $ _enter_menu()

    python:
        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
@@ -743,11 +814,11 @@ 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
@@ -777,13 +848,22 @@ init 1180 python hide:
            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:
+            if name in renpy.display.image.images:
                continue

            renpy.image(name, fn)
@@ -792,12 +872,17 @@ init 1180 python hide:
        create_automatic_images()


-# Load the developer screen, if necessary.
+# After init, make some changes based on if config.developer is True.
 init 1180 python hide:

    if config.developer:
+        if config.debug_sound is None:
+            config.debug_sound = True
+        
        renpy.load_module("_developer")

+
+
 # Entry point for the developer screen. The rest of it is loaded from
 # _developer.rpym
 label _developer:
@@ -805,6 +890,25 @@ label _developer:
    if not config.developer:
        return

-    call _enter_menu from _call__enter_menu_4
+    $ _enter_menu()

    jump expression "_developer_screen"
+
+
+# Translations.
+init -1180 python:
+
+    def _language_activate():
+
+        if persistent._language:
+            language = persistent._language 
+        else:
+            language = "translations"
+    
+        if renpy.loadable(language + ".rpt"):
+            config.translator = renpy.Translator(language)
+        else:
+            config.translator = None
+            
+    _language_activate()
+            
@@ -1,7 +1,5 @@
-# Copyright 2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.

 # Common stuff that's used by the various Ren'Py menus. This includes
 # the default definitions of config.main_menu and config.game_menu, as
@@ -37,6 +35,8 @@ label _quit_prompt:
        return

 label _main_menu_prompt:
+    $ renpy.loadsave.force_autosave()
+
    if layout.yesno_prompt(None, layout.MAIN_MENU):
        $ renpy.full_restart(transition=config.game_main_transition)
    else:
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains code that sets up the various mixers, based on how
 # the user sets config.has_music, .has_sound, and .has_voice.

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

        def do_add(self, who, what):
+        
            if store.nvl_list is None:
                store.nvl_list = [ ]
                
@@ -191,16 +244,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 +266,7 @@ init -1100 python:
        what_style='nvl_dialogue',
        window_style='nvl_entry',
        type='nvl',
+        mode='nvl',
        clear=False,
        kind=adv)
                
@@ -218,16 +275,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))

@@ -260,29 +346,23 @@ init -1100 python:
    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:

@@ -1,4 +1,4 @@
-# This file contains the spline motion code contributed by Aenakume, at
+# This file contains the spline motion code contributed by Aenakume, at
 # http://lemmasoft.renai.us/forums/viewtopic.php?f=8&t=3977

 init -1080 python:
@@ -1,10 +1,14 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains code that creates a few new statements. We'll
 # also describe here the API for defining your own statements.
 #
 # Statements can be defined by calling renpy.statements.register. This
 # function takes a string giving the keywords at the start of the
 # statement, and then up to 4 functions defining the behavior of the
-# statement: parse, execute, predict, and lint
+# statement: parse, execute, predict, and lint. If given the keyword
+# argument block=True, the statement will take a block.
 #
 # The parse function takes a lexer object as an argument, and is
 # expected to return some parser data. The lexer has the following
@@ -28,6 +32,13 @@
 # l.revert(o) - Given the object returned by l.checkpoint(), returns
 # there.
 #
+# l.subblock_lexer() - Return a lexer that gives a sub-block for the 
+# block associated with the current statement.
+# l.advance() - In a subblock lexer, advance to the next line. This needs
+# to be called before the above functions can be called on the first line. 
+# 
+#
+#
 # The parse function is expected to return an object, which is passed
 # to the other functions. Parse should call renpy.error with the error
 # message to report an error.
@@ -122,7 +133,7 @@ python early hide:
        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"]),
@@ -134,19 +145,24 @@ python early hide:
    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,
@@ -188,7 +204,7 @@ python early hide:
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
-            channel = 7
+            channel = "music"
        
        renpy.music.queue(
            eval(p["file"]),
@@ -226,7 +242,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)

@@ -243,7 +259,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
            
@@ -251,17 +267,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)

@@ -275,7 +294,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

@@ -331,7 +350,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"])
@@ -436,7 +455,6 @@ python early hide:
                              parse=parse_pause,
                              lint=lint_pause,
                              execute=execute_pause)
-            
    
                              
 init -1200 python:
@@ -450,3 +468,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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.

 # This file is responsible for creating and defining the default styles
 # used by the system.
@@ -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,13 +63,16 @@ 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')

    style.hyperlink = Style(style.default, help=None) # ignored
    style.hyperlink_text = Style(style.default, help='hyperlinked text')
+    style.ruby_text = Style(style.default, help='ruby text')

    style.viewport = Style(style.default, help='default style of viewports')
    style.transform = Style(style.motion, help='default style of transforms')
@@ -78,6 +84,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.')
@@ -123,7 +131,7 @@ init -1090 python:

    # Text properties.
    style.default.font = "DejaVuSans.ttf"
-    style.default.language = "western"
+    style.default.language = "unicode"
    style.default.antialias = True
    style.default.size = 22
    style.default.color = (255, 255, 255, 255)
@@ -132,6 +140,7 @@ init -1090 python:
    style.default.italic = False
    style.default.underline = False
    style.default.strikethrough = False
+    style.default.kerning = 0.0
    style.default.drop_shadow = None
    style.default.drop_shadow_color = (0, 0, 0, 255)
    style.default.outlines = [ ]
@@ -142,11 +151,14 @@ init -1090 python:
    style.default.first_indent = 0
    style.default.rest_indent = 0
    style.default.line_spacing = 0
-    style.default.layout = "greedy"
+    style.default.line_leading = 0
+    style.default.line_overlap_split = 0
+    style.default.layout = "tex"
    style.default.subtitle_width = 0.9
    style.default.slow_cps = None
    style.default.slow_cps_multiplier = 1.0
    style.default.slow_abortable = False
+    # style.default.hyperlink_functions (set in 00library.rpy)
    
    # Window properties.
    style.default.background = None
@@ -177,6 +189,7 @@ init -1090 python:
    style.default.spacing = 0
    style.default.first_spacing = None
    style.default.box_layout = None
+    style.default.box_wrap = False

    # Focus properties.
    style.default.focus_mask = None
@@ -215,16 +228,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
@@ -240,7 +246,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
@@ -259,6 +265,11 @@ init -1090 python:
    style.hyperlink_text.hover_color = "#0ff"
    style.hyperlink_text.idle_color = "#08f"
    
+    # Ruby.
+    style.ruby_text.size = 22
+    style.ruby_text.xoffset = 0
+    style.default.ruby_style = style.ruby_text
+    
    # Bars.
    style.default.bar_invert = False
    style.default.bar_resizing = False
@@ -297,7 +308,10 @@ init -1090 python:
    style.list_text.color = "#000"
    style.list_text.size = 14
    style.list_spacer.xminimum = 15
-       
+
+    # Tile
+    style.tile.clipping = True
+    
    
    ######################################################################

@@ -311,3 +325,4 @@ init -1090 python:
    style.error_title.color = (255, 128, 128, 255)
    style.error_body.color = (128, 128, 255, 255)

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

    ######################################################################
@@ -7,11 +10,11 @@ init python:
    # The contents of the game menu choices.
    config.game_menu = [
            ( "return", u"Return", ui.jumps("_return"), 'True'),
-            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context().main_menu'),
+            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context()._main_menu'),
            ( "prefs", u"Preferences", _intra_jumps("_prefs_screen", "intra_transition"), 'True' ),
-            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context().main_menu' ),
+            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context()._main_menu' ),
            ( "load", u"Load Game", _intra_jumps("_load_screen", "intra_transition"), 'True'),
-            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context().main_menu' ),
+            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context()._main_menu' ),
            ( "quit", u"Quit", lambda : _quit_prompt("quit"), 'True' ),
            ]

@@ -460,7 +463,7 @@ label _load_screen:

        fn, exists = _file_picker("load", False )

-        if not renpy.context().main_menu and _load_prompt:
+        if not renpy.context()._main_menu and _load_prompt:
            if _yesno_prompt("load", u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
                renpy.load(fn)
        else:                        
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init:
    python:

@@ -1,3 +1,6 @@
+# Copyright 2004-2012 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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2012 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:

    style.menu_button = Style(style.button, heavy=True, help='Buttons that are part of the main or game menus.')
@@ -1,4 +1,7 @@
-# Copyright 2004-2007 PyTom
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2012 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.
@@ -1,30 +1,45 @@
+# This file contains code that helps support the development of Ren'Py
+# games.

-# This file contains the developer screen, which contains tools that might
-# be of interest to people making Ren'Py games.
+screen _developer:

+    frame:
+        style_group ""
+
+        align (.025, .05)
+
+        has vbox
+
+        label "Developer Menu"
+
+        textbutton _(u"Reload Game (Shift+R)"): 
+            action ui.callsinnewcontext("_save_reload_game")
+            size_group "developer"
+        textbutton _(u"Variable Viewer"):
+            action Jump("_debugger_screen")
+            size_group "developer"
+        textbutton _(u"Theme Test"): 
+            action Jump("_theme_test")
+            size_group "developer"
+        textbutton _(u"Style Hierarchy"): 
+            action Jump("_style_hierarchy")
+            size_group "developer"
+        textbutton _(u"Image Location Picker"): 
+            action Jump("_image_location_picker")
+            size_group "developer"
+        textbutton _(u"Filename List"): 
+            action Jump("_filename_list")
+            size_group "developer"
+
+        null height 15
+
+        textbutton _(u"Return"):
+            action Return()
+            size_group "developer"
+         
 label _developer_screen:

-    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(u"Return", None, clicked=ui.returns(True), size_group=sg)
-        layout.button(u"Reload Game (Shift+R)", None, clicked=ui.callsinnewcontext("_save_reload_game"), size_group=sg)
-        layout.button(u"Variable Viewer", None, clicked=ui.jumps("_debugger_screen"), size_group=sg)
-        layout.button(u"Theme Test", None, clicked=ui.jumps("_theme_test"), size_group=sg)
-        layout.button(u"Style Hierarchy", None, clicked=ui.jumps("_style_hierarchy"), size_group=sg)
-        layout.button(u"FPS Meter", None, clicked=ui.jumps("_fps_meter"), size_group=sg)
-        layout.button(u"Image Location Picker", None, clicked=ui.jumps("_image_location_picker"), size_group=sg)
-        
-        ui.close()
-        ui.interact()
+    call screen _developer
        
    return 
        
@@ -42,7 +57,7 @@ label _debugger_screen:

        entries = [ ]
        
-        ebc = renpy.game.log.ever_been_changed
+        ebc = store.__dict__.ever_been_changed
        ebc = list(ebc)
        ebc.sort()

@@ -63,7 +78,10 @@ label _debugger_screen:
                continue

            val = aRepr.repr(getattr(store, var))
-            entries.append((0, (var + " = " + val).replace("{", "{{")))
+            s = (var + " = " + val)
+            s = s.replace("{", "{{")
+            s = s.replace("[", "[[")
+            entries.append((0, s))

        if entries:
            vp = ui.viewport(mousewheel=True)
@@ -93,7 +111,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:

@@ -146,7 +164,7 @@ label _theme_test:
            
            ui.frame(style='menu_frame', xmaximum=0.95)
            ui.vbox(box_spacing=20)
-            layout.prompt("This a prompt. Hopefully, we've made this long enough to wrap around at least once.", None)
+            layout.prompt("This is a prompt. We've made this text long enough to wrap around so it fills multiple lines.", None)
            ui.close()

            ui.close() # hbox
@@ -192,29 +210,11 @@ label _style_hierarchy:
        ui.interact()
        
    jump _developer_screen
-    

 init -1050 python:
    config.missing_background = "black"
    
 init 1050 python:
-    
-    if renpy.game.options.remote:
-            
-        config.window_title = "Preview: " + config.window_title
-        
-        class Remote(renpy.Displayable):
-            
-            def render(self, width, height, st, at):
-                return renpy.Render(0, 0)
-                            
-            def event(self, ev, x, y, st):
-                renpy.remote.remote()
-                renpy.timeout(.05)
-                
-        config.underlay.append(Remote())
-        del Remote
-        

    if config.developer:

@@ -242,7 +242,7 @@ init 1050 python:
                renpy.show(name, what=config.missing_background)
            __missing_scene = False
                
-            what = " ".join(what).replace("{", "{{")
+            what = " ".join(what).replace("{", "{{").replace("[", "[[")
            __missing()[name[0]] = what
            return True

@@ -370,8 +370,8 @@ init python:
                    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("Cropping rectangle: %r" % ((minx, miny, w, h),))
+                    # text.append("Imagemap rectangle: %r" % ((minx, miny, maxx, maxy),))
+                    text.append("Rectangle: %r" % ((minx, miny, w, h),))
                
            if self.mouse:
                mx, my = self.mouse
@@ -440,7 +440,7 @@ label _image_location_picker:

            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.text(fn.replace("{", "{{").replace("[", "[["), style="button_text", xalign=0.0)
                
            ui.close()

@@ -466,4 +466,119 @@ label _image_location_picker:
        # ...

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

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

    layout.provides('load_save')
@@ -185,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
@@ -345,11 +351,3 @@ label load_screen:
                    continue

            renpy.load(fn)
-            
-            
-            
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

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

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

    layout.provides('preferences')
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
    
    # Styles
@@ -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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:

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

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

    layout.provides('navigation')
@@ -1,46 +1,69 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
    
    class _ImageMapper(object):

-        def __init__(self, screen, ground, idle, hover, selected_idle, selected_hover, hotspots):
+        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, 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:
@@ -74,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(
@@ -94,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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('load_save')
    renpy.load_module("_layout/imagemap_common")
    
    # The ground image.
-    config.load_save_ground = 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")
@@ -148,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
@@ -159,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)
@@ -249,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):
@@ -340,9 +352,3 @@ label load_screen:
                    continue

            renpy.load(fn)
-                        
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    
@@ -1,13 +1,20 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('main_menu')
-    
+    renpy.load_module("_layout/imagemap_common")
+
    # The ground image.
-    config.main_menu_ground = 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,28 +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_idle,
            config.main_menu_selected,
            config.main_menu_hotspots,
-            mouse="mainmenu")
-
-        for e in config.main_menu:
-            name = e[0]
-            act = e[1]
-            enable = e[2]
+            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-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('navigation')
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 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,11 +124,14 @@ 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(mouse="gamemenu")
        
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:

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

    layout.provides('preferences')
@@ -0,0 +1,16 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('joystick_preferences')
+
+label joystick_preferences_screen:
+
+    $ renpy.show_screen('joystick_preferences')
+    $ ui.interact()
+
+    jump _noisy_return
+    
+
+
@@ -0,0 +1,19 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+
+label load_screen:
+
+    $ renpy.show_screen('load')
+    $ ui.interact()
+    jump _noisy_return
+
+label save_screen:
+
+    $ renpy.show_screen('save')
+    $ ui.interact()
+    jump _noisy_return
+
@@ -0,0 +1,14 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+label main_menu_screen:
+    
+    $ renpy.show_screen("main_menu")
+    $ ui.interact()
+    
+    return
+
@@ -0,0 +1,16 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+
+label preferences_screen:
+
+    $ renpy.show_screen('preferences')
+    $ ui.interact()
+    
+    jump _noisy_return
+    
+
+
@@ -0,0 +1,12 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+
+    def yesno_prompt(screen, message):
+        rv = renpy.call_screen('yesno_prompt', message=message, yes_action=Return(True), no_action=Return(False))
+        return rv
+    
+    layout.yesno_prompt = yesno_prompt
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('load_save')
@@ -224,10 +227,3 @@ label load_screen:
                    continue

            renpy.load(fn)
-            
-            
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    
@@ -1,3 +1,6 @@
+# Copyright 2004-2012 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:

    layout.provides('preferences')
@@ -0,0 +1,94 @@
+Copyright (c) 2011, Andrew Paglinawan (www.andrewpaglinawan.com), 
+with Reserved Font Name "Quicksand".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/Show More
+++ b/Show More