6.11.2a

specified with alpha=True whether or not alpha=True was set.

.bzrignore

@@ -0,0 +1,69 @@
+build
+dist
+dists
+renpy.app
+**/*.rpyc
+**/*.rpyb
+**/*.rpymc
+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
+Lucy Sprites.zip
+translate
+close_bugs.py
+.logplayer
+scite-6.10.zip
+scite-renpy-20090803.zip
+module/cython.sh
+old_demo
+opengl.txt
+Microsoft.VC90.CRT.manifest
+console.exe
+msvcr90.dll
+python26.dll
+renpy.exe
+lib/windows-x86
+sphinx/source/inc/*
+doc/*
+updates/prerelease

LICENSE.txt

@@ -1,52 +1,803 @@
-Copyright 2004-2005 PyTom <pytom@bishoujo.us>
+=======
+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:
+Most of Ren'Py is covered by the terms of the following (MIT) license:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+    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 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.
+    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.
+
+Portions of Ren'Py are derived from code that is copyright using the
+Lesser GNU Public License, so Ren'Py games must be distributed in a
+manner that satisfies the LGPL.
+
+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.
+
+Ren'Py binaries include code 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)
+* py2exe (MIT License)
+* GLEW (Modified BSD, MIT)
+* tegl (Modified BSD)
+
+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
+=================================
 
-Please note that the above license only applies to Ren'Py
-proper. A binary distribution of Ren'Py contains a number of other
-packages, each with their own licenses, which you may be bound to
-comply with when distributing a Ren'Py game. 
+::
 
-These packages may include:
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                        Version 2.1, February 1999
 
-Python (Python License)
-http://www.python.org
+  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.
 
-Pygame (GNU LGPL)
-http://www.pygame.org
+ [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.]
 
-SDL (GNU LGPL)
-http://www.libsdl.org
+                             Preamble
 
-SDL_mixer (GNU LGPL)
-http://www.libsdl.org/projects/SDL_mixer
+   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.
 
-SDL_ttf (GNU LGPL)
-http://www.libsdl.org/projects/SDL_ttf
+   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.
 
-ctypes (MIT)
-http://starship.python.net/crew/theller/ctypes/
+   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.
 
 
-The character images in the demo game (game/9a_*.png) are under their
-own copyright. I allow them to be used as part of the demo game, but
-not as part of other games.
+     <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.
+
+
+Modified BSD License
+====================
+
+::
+
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, 
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, 
+   this list of conditions and the following disclaimer in the documentation 
+   and/or other materials provided with the distribution.
+ * The name of the author may be used to endorse or promote products 
+   derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.

README_RENPY.txt

@@ -1,55 +0,0 @@
-This file contains boilerplate information about running Ren'Py that
-can be included into the README for your game. It may be necessary to
-change some of the filenames in this document, to make it specific to
-your game.
-
-Feel free to use this in your projects.
-
-
-
-Running the Game
-================
-
-(Windows)
-
-If this game was installed on Windows using an installer, then you can
-run it by choosing the shortcut left by the installer. If this game
-was installed on Windows using the cross-platform zip file, then it
-can be run by executing the run_game.exe file.
-
-(Macintosh)
-
-For information about running Ren'Py games on Mac OS 10.3 or higher,
-please go to http://www.bishoujo.us/renpy/mac.html .
-
-(Linux/Unix)
-
-For information about running Ren'Py games under Linux and Unix,
-please go to http://www.bishoujo.us/renpy/linux.html . At the very
-least, you will need to compile the _renpy module. Read
-module/README.txt for details.
-
-
-Playing the Game
-================
-
-By default, the game starts running in full screen mode. On some
-computers, especially some virtual machines, this can lead to mouse
-problems. To fix this, press 'f'.
-
-Some of the more interesting game actions can be performed as follows:
-
-- The left mouse button is used to advance to the next line of
-  dialogue, or to pick menu options.
-
-- The right mouse button brings you into a menu screen where you can
-  save the game, load the game, change preferences, return to the main
-  menu, or quit entirely.
-
-- Scrolling the mouse wheel up or pushing page up returns you to the
-  previous screen.
-
-- Holding down the CTRL key skips dialogue. By default, it only
-  skips read dialogue, but this can be changed by a preference. Tab
-  toggles skip mode.
-

TODO.txt

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

add.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+if [ "x$1" = "x" ]; then
+    echo need version
+    exit
+fi
+
+rsync -av updates tom@onegeek.org:/home/tom/WWW.update/renpy/
+
+mkdir ~/ab/website/renpy/dl/$1
+cp dists/renpy-$1-* ~/ab/website/renpy/dl/$1
+cp CHANGELOG.txt ~/ab/website/renpy/dl/$1
+
+cd ~/ab/website
+./upload.sh

archive_images.bat

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

archiver.py

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

build_exe.bat

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

build_exe.py

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

build_strings.py

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

common/00atl.rpy

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

common/00compat.rpy

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

common/00definitions.rpy

@@ -0,0 +1,193 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains a number of definitions of standard
+# locations and transitions. We've moved them into the common
+# directory so that it's easy for an updated version of all of these
+# definitions.
+
+init -1110:
+
+    transform reset:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+   
+    # These are positions that can be used inside at clauses. We set
+    # them up here so that they can be used throughout the program.
+    transform left:
+        xpos 0.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform right:
+        xpos 1.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform center:
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    transform truecenter:
+        xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+        
+    # Offscreen positions for use with the move transition. Images at
+    # these positions are still shown (and consume
+    # resources)... remember to hide the image after the transition.    
+    transform offscreenleft:
+        xpos 0.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform offscreenright:
+        xpos 1.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform default:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    python:
+        config.default_transform = default
+        
+
+init -1110 python:
+
+    _define = define = object()
+        
+    # Transitions ############################################################
+
+    # Simple transitions.
+    fade = Fade(.5, 0, .5) # Fade to black and back.
+    dissolve = Dissolve(0.5)
+    pixellate = Pixellate(1.0, 5)
+
+    # Various uses of CropMove.    
+    wiperight = CropMove(1.0, "wiperight")
+    wipeleft = CropMove(1.0, "wipeleft")
+    wipeup = CropMove(1.0, "wipeup")
+    wipedown = CropMove(1.0, "wipedown")
+
+    slideright = CropMove(1.0, "slideright")
+    slideleft = CropMove(1.0, "slideleft")
+    slideup = CropMove(1.0, "slideup")
+    slidedown = CropMove(1.0, "slidedown")
+
+    slideawayright = CropMove(1.0, "slideawayright")
+    slideawayleft = CropMove(1.0, "slideawayleft")
+    slideawayup = CropMove(1.0, "slideawayup")
+    slideawaydown = CropMove(1.0, "slideawaydown")
+
+    irisout = CropMove(1.0, "irisout")
+    irisin = CropMove(1.0, "irisin")
+
+    # Ease images around. These are basically cosine-warped moves.
+    def _ease_out_time_warp(x):
+        import math
+        return 1.0 - math.cos(x * math.pi / 2.0)
+
+    def _ease_in_time_warp(x):
+        import math
+        return math.cos((1.0 - x) * math.pi / 2.0)
+
+    def _ease_time_warp(x):
+        import math
+        return .5 - math.cos(math.pi * x) / 2.0
+
+    # This defines a family of move transitions.
+    def move_transitions(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[ 'master' ], **kwargs):
+        moves = {
+            "" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+
+            "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)),
+            }
+
+        for k, v in moves.iteritems():
+            setattr(store, prefix + k, v)
+
+    define.move_transitions = move_transitions
+    del move_transitions
+
+    define.move_transitions("move", 0.5)
+    define.move_transitions("ease", 0.5, _ease_time_warp, _ease_in_time_warp, _ease_out_time_warp) 
+
+    # Zoom-based transitions.
+    zoomin = MoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0))
+    zoomout = MoveTransition(0.5, leave_factory=ZoomInOut(1.0, 0.01))
+    zoominout = MoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0), leave_factory=ZoomInOut(1.0, 0.01))
+    
+    # These shake the screen up and down for a quarter second.
+    # The delay needs to be an integer multiple of the period.
+    vpunch = Move((0, 10), (0, -10), .10, bounce=True, repeat=True, delay=.275)
+    hpunch = Move((15, 0), (-15, 0), .10, bounce=True, repeat=True, delay=.275)
+
+    # These use the ImageDissolve to do some nifty effects.
+    blinds = ImageDissolve(im.Tile("blindstile.png"), 1.0, 8)
+    squares = ImageDissolve(im.Tile("squarestile.png"), 1.0, 256)
+
+
+init -1110:
+    image black = Solid("#000")
+
+init 1110 python:
+    if not hasattr(store, 'narrator'):
+        narrator = Character(None, kind=adv, what_style='say_thought')
+
+    if not hasattr(store, 'name_only'):
+        name_only = adv
+
+    if not hasattr(store, 'centered'):
+        centered = Character(None, what_style="centered_text", window_style="centered_window")
+
+    # This is necessary to ensure that config.default_transform works.
+    if config.default_transform:
+        config.default_transform._show()

common/00gltest.rpy

@@ -0,0 +1,180 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This contains code to choose between OpenGL and Software rendering, when
+# a system supports both.
+
+init -1024:
+    screen _gl_test:
+        frame:
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            has vbox
+
+            label _(u"Graphics Acceleration")
+
+            null height 10
+            
+            textbutton _(u"Automatically Choose"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "auto")
+            textbutton _(u"Prefer Software Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "sw")
+            textbutton _(u"Prefer OpenGL Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "gl")
+
+            null height 10
+
+            textbutton _(u"Continue"):
+                size_group "gl"
+                action Return(True)
+
+init -1024 python:
+    # The image that we fill the screen with in GL-test mode.
+    config.gl_test_image = "black"
+
+    class __GLTest(renpy.Displayable):
+        """
+         This counts the number of times it's been rendered, and
+         the number of seconds it's been displayed, and uses them
+         to make the decisions as to if OpenGL is working or not.
+         """
+        
+        def __init__(self, frames, fps, timeout):
+            super(__GLTest, self).__init__()
+
+            self.target = 1.0 * frames / fps
+            self.frames = frames
+            self.timeout = timeout
+
+            self.times = [ ]
+            self.success = False
+            
+        def render(self, width, height, st, at):
+            self.times.append(st)
+
+            renpy.redraw(self, 0)
+
+            if len(self.times) >= self.frames:
+                if (self.times[-1] - self.times[-self.frames]) < self.target:
+                    self.success = True
+                    renpy.timeout(0)
+                    
+            rv = renpy.Render(width, height)
+            return rv
+                            
+        def event(self, ev, x, y, st):
+
+            if self.success:
+                return True
+
+            if st > self.timeout:
+                return False
+
+            renpy.timeout(self.timeout - st)
+
+
+    def __gl_prefer_renderers(renderers):
+        """
+         Forces the current renderer to be renderer, one of gl or sw.
+         """
+
+        if renpy.display.prefer_renderers == renderers:
+            return
+
+        renpy.display.prefer_renderers = renderers        
+        renpy.display_reset()
+                    
+    def __gl_prompt():
+        """
+         Decides if we want to prompt the user to enable OpenGL mode.
+         If so, shows a screen that allows the user to alter the
+         OpenGL setting.
+         """
+
+        if not renpy.display.interface.safe_mode:
+            return 
+
+        __gl_prefer_renderers("sw")
+        
+        renpy.call_screen("_gl_test")
+
+        renpy.display.interface.safe_mode = False
+        
+    def __gl_test():
+        """
+         Makes the decision as to if we should use GL or SW mode.
+         """
+
+        import os
+        if "RENPY_RENDERER" in os.environ:
+            return
+
+        # Our decision survives a restart.
+        if _restart:
+            return
+
+        # If GL is disabled, don't bother.
+        if not config.gl_enable:
+            return
+        
+        __gl_prompt()
+
+        if persistent._gl_test == "gl":
+            __gl_prefer_renderers("gl,sw")
+            return
+
+        if persistent._gl_test == "sw":
+            __gl_prefer_renderers("sw")
+            return
+
+        __gl_prefer_renderers("gl,sw")
+
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+        # If GL is able to render FRAMES frames at FPS fps in less
+        # than DELAY seconds, we consider it to be operational, and
+        # continue in GL mode. Otherwise, we rever to software
+        # rendering mode.
+        FRAMES = 5
+        FPS = 15
+        DELAY = 1
+        
+        renpy.transition(Dissolve(DELAY), always=True, force=True)
+        ui.add(__GLTest(FRAMES, FPS, DELAY))
+        result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+
+        if result:
+            __gl_prefer_renderers("gl,sw")
+        else:
+            __gl_prefer_renderers("sw")
+
+    # Init-time code:
+    # Make a guess as to what modes we should be in.
+    if persistent._gl_test is None:
+        persistent._gl_test = "auto"
+
+    if persistent._gl_test == "sw":
+        renpy.display.prefer_renderers = "sw"
+        
+            
+label _gl_test:
+
+    # Show the test image.
+    scene
+    show expression config.gl_test_image
+    
+    $ __gl_test()
+                
+    # Hide the test image.
+    scene
+
+    return
+

common/00layout.rpy

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

common/00library.rpy

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

common/00menus.rpy

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

common/00mixers.rpy

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

common/00nvl_mode.rpy

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

common/00splines.rpy

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

common/00statements.rpy

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

common/00style.rpy

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

common/00themes.rpy

@@ -0,0 +1,731 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1110 python:
+
+    class _Theme(object):
+
+        # Using theme as a decorator is what we do to create a new theme.
+        def __call__(self, func):
+            setattr(self, func.func_name, func)
+            return func
+        
+    _theme = theme = _Theme()
+    del _Theme
+
+    # Public only for compatiblity purposes.
+    def RoundRect(color, small=False):
+        if small:
+            size = 6
+        else:
+            if config.screen_width <= 640:
+                size = 6
+            else:
+                size = 12
+
+        return Frame(theme.OneOrTwoColor("_roundrect/rr%dg.png" % size, color), size, size)
+
+init -1110 python hide:
+
+    @theme
+    def clear_frames():
+        style.frame.clear()
+    
+    @theme
+    def clear_buttons():
+        style.button.clear()
+        style.button_text.clear()
+        style.radio_button.clear()
+        style.radio_button_text.clear()
+        style.check_button.clear()
+        style.check_button_text.clear()
+        style.small_button.clear()
+        style.small_button_text.clear()
+
+    @theme
+    def clear_large_buttons():
+        style.large_button.clear()
+        style.large_button_text.clear()
+
+    @theme
+    def clear_labels():
+        style.label.clear()
+        style.label_text.clear()
+
+    @theme
+    def clear_prompts():
+        style.prompt.clear()
+        style.prompt_text.clear()
+
+    @theme
+    def clear_bars():
+        style.bar.clear()
+        style.vbar.clear()
+        style.scrollbar.clear()
+        style.vscrollbar.clear()
+        style.slider.clear()
+        style.vslider.clear()
+        
+        style.vbar.bar_vertical = True
+        style.vslider.bar_vertical = True
+        style.vscrollbar.bar_vertical = True
+        style.vscrollbar.bar_invert = True
+
+
+    # This recolors the given image using one or two colors.
+    @theme
+    def OneOrTwoColor(image, color):
+        if len(color) == 2:
+            return im.Twocolor(image, color[0], color[1])
+        else:
+            return im.Twocolor(image, color, color)
+
+    def roundrect_based_theme(name, file_prefix, Box=None, frame_png=None):
+
+        if Box is None:
+            def Box(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + "_box.png", color), 12, 12)
+
+        if frame_png is not None:
+            def FrameBox(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + frame_png, color), 12, 12)
+        else:
+            FrameBox = Box
+            
+        def frames(
+            less_rounded,
+            frame):
+
+            theme.clear_frames()
+
+            style.frame.background = Box(frame, less_rounded)
+
+            style.frame.xpadding = 6
+            style.frame.ypadding = 6
+        
+        setattr(theme, name + "_frames", frames)
+
+            
+        def buttons(text_size,
+                    less_rounded,
+                    widget,
+                    widget_hover,
+                    widget_text,
+                    widget_selected,
+                    disabled,
+                    disabled_text):
+
+            theme.clear_buttons()
+
+            style.button.background = Box(widget, less_rounded)
+            style.button.hover_background = Box(widget_hover, less_rounded)
+            style.button.insensitive_background = Box(disabled, less_rounded)
+
+            style.button_text.size = text_size
+            style.button_text.color = widget_text
+            style.button_text.selected_color = widget_selected
+            style.button_text.insensitive_color = disabled_text
+
+            if less_rounded:
+                style.button.xpadding = 6
+            else:
+                style.button.xpadding = 12
+
+            style.button.ypadding = 1
+            style.button.xmargin = 1
+            style.button.ymargin = 1
+
+            style.button_text.xalign = 0.5
+            style.button_text.yalign = 0.5
+            style.button_text.text_align = 0.5
+
+        setattr(theme, name + "_buttons", buttons)
+            
+        def large_buttons(
+            text_size,
+            less_rounded,
+            widget,
+            widget_hover,
+            widget_text,
+            widget_selected,
+            disabled,
+            disabled_text):
+
+            theme.clear_large_buttons()
+
+            if less_rounded:
+                style.large_button.xpadding = 6
+            else:
+                style.large_button.xpadding = 12
+
+            style.large_button.ypadding = 1
+            style.large_button.xmargin = 1
+            style.large_button.ymargin = 1
+
+            style.large_button.background = Box(widget, less_rounded)
+            style.large_button.hover_background = Box(widget_hover, less_rounded)
+            style.large_button.insensitive_background = Box(disabled, less_rounded)
+
+            style.large_button_text.size = text_size
+            style.large_button_text.color = widget_text
+            style.large_button_text.selected_color = widget_selected
+            style.large_button_text.insensitive_color = disabled_text
+
+            style.large_button_text.xalign = 0
+            style.large_button_text.yalign = 0
+
+        setattr(theme, name + "_large_buttons", large_buttons)
+            
+        def labels(
+            text_size,
+            label):
+
+            theme.clear_labels()
+
+            style.label_text.size = text_size
+            style.label_text.color = label
+
+        setattr(theme, name + "_labels", labels)
+            
+        def prompts(
+            text_size,
+            label):
+
+            theme.clear_prompts()
+
+            style.prompt_text.size = text_size
+            style.prompt_text.color = label
+
+            style.prompt.xalign = 0.5
+            style.prompt_text.text_align = 0.5
+            style.prompt_text.layout = "subtitle"
+ 
+        setattr(theme, name + "_prompts", prompts)
+       
+            
+        def bars(
+            widget,
+            widget_hover):
+
+            theme.clear_bars()
+
+            def img(name, color, x, y):
+                rv = theme.OneOrTwoColor(file_prefix + name + ".png", color)
+                if x is not None:
+                    rv = Frame(rv, x, y, tile=True)
+                return rv
+
+            # Bars.
+            style.bar.ymaximum = 24
+            style.bar.left_gutter = 6
+            style.bar.right_gutter = 6
+            style.bar.thumb_offset = 6
+
+            style.bar.left_bar = img("slider_full", widget, 12, 0)
+            style.bar.right_bar = img("slider_empty", widget, 12, 0)
+            style.bar.thumb = img("slider_thumb", widget, None, None)
+            style.bar.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.bar.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.bar.hover_thumb = img("slider_thumb", widget_hover, None, None)
+
+            style.vbar.xmaximum = 24
+            style.vbar.top_gutter = 6
+            style.vbar.bottom_gutter = 6
+            style.vbar.thumb_offset = 6
+
+            style.vbar.bottom_bar = img("vslider_full", widget, 0, 12)
+            style.vbar.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vbar.thumb = img("vslider_thumb", widget, None, None)
+            style.vbar.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vbar.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vbar.hover_thumb = img("vslider_thumb", widget_hover, None, None)
+
+            # Sliders.
+            style.slider.ymaximum = 24
+            style.slider.left_gutter = 6
+            style.slider.right_gutter = 6
+            style.slider.thumb_offset = 6
+
+            style.slider.left_bar = img("slider_full", widget, 12, 0)
+            style.slider.right_bar = img("slider_empty", widget, 12, 0)
+            style.slider.thumb = img("slider_thumb", widget, None, None)
+            style.slider.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.slider.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.slider.hover_thumb = img("slider_thumb", widget_hover, None, None)
+
+            style.vslider.xmaximum = 24
+            style.vslider.top_gutter = 6
+            style.vslider.bottom_gutter = 6
+            style.vslider.thumb_offset = 6
+
+            style.vslider.bottom_bar = img("vslider_full", widget, 0, 12)
+            style.vslider.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vslider.thumb = img("vslider_thumb", widget, None, None)
+            style.vslider.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vslider.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vslider.hover_thumb = img("vslider_thumb", widget_hover, None, None)
+
+
+            # Scrollbars.
+            style.scrollbar.left_gutter = 6
+            style.scrollbar.right_gutter = 6
+            style.scrollbar.thumb_offset = 6
+            style.scrollbar.ymaximum = 12
+
+            style.scrollbar.left_bar = img("scrollbar", widget, 12, 0)
+            style.scrollbar.right_bar = img("scrollbar", widget, 12, 0)
+            style.scrollbar.thumb = img("scrollbar_thumb", widget, None, None)
+            style.scrollbar.hover_left_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_right_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_thumb = img("scrollbar_thumb", widget_hover, None, None)
+
+            style.vscrollbar.top_gutter = 6
+            style.vscrollbar.bottom_gutter = 6
+            style.vscrollbar.thumb_offset = 6
+            style.vscrollbar.xmaximum = 12
+
+            style.vscrollbar.left_bar = img("vscrollbar", widget, 0, 12)
+            style.vscrollbar.right_bar = img("vscrollbar", widget, 0, 12)
+            style.vscrollbar.thumb = img("vscrollbar_thumb", widget, None, None)
+            style.vscrollbar.hover_left_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_right_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_thumb = img("vscrollbar_thumb", widget_hover, None, None)
+
+        setattr(theme, name + "_bars", bars)
+        
+        def main(
+            widget = (0, 60, 120, 255),
+            widget_hover = (0, 80, 160, 255),
+            widget_text = (200, 225, 255, 255),
+            widget_selected = (255, 255, 200, 255),
+            disabled = (64, 64, 64, 255),
+            disabled_text = (200, 200, 200, 255),
+            label = (255, 255, 255, 255),
+            frame = (100, 150, 200, 255),
+
+            text_size=None,
+            small_text_size=None,
+            less_rounded = False,        
+
+            # Compat for the old roundrect theme.
+            window = None,
+            button_menu = None,
+            rounded_window = True,
+            outline_bars = False,
+            mm_root = None,
+            gm_root = None):
+
+            if button_menu is None:
+                if (config.script_version is not None) and (config.script_version < (6, 9, 0)):
+                    button_menu = True
+                else:
+                    button_menu = False
+
+            layout.defaults()
+
+            if config.screen_width <= 640:
+                text_size = text_size or 18
+                small_text_size = small_text_size or 12
+                less_rounded = True
+
+            else:
+                text_size = text_size or 22
+                small_text_size = small_text_size or 16
+                radius = 12
+
+            frames(
+                less_rounded,
+                frame)
+
+            buttons(
+                text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            large_buttons(
+                small_text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            labels(
+                text_size,
+                label)
+
+            prompts(
+                text_size,
+                label)
+
+            bars(
+                widget,
+                widget_hover)
+
+            if mm_root is not None:
+                style.mm_root.background = mm_root
+
+            if gm_root is not None:
+                style.gm_root.background = gm_root
+
+            if window is not None:
+
+                if rounded_window:
+                    style.window.background = RoundRect(window, less_rounded)
+                    style.window.xpadding = 6
+                    style.window.xmargin = 6
+                    style.window.ypadding = 6
+                    style.window.ymargin = 6
+                else:
+                    style.window.background = Solid(window)
+                    style.window.xpadding = 6
+                    style.window.xmargin = 0
+                    style.window.ypadding = 6
+                    style.window.ymargin = 0
+
+
+            if button_menu:
+                layout.button_menu()
+
+        setattr(theme, name, main)
+
+    roundrect_based_theme("roundrect", "_roundrect/rr", RoundRect)
+    roundrect_based_theme("bordered", "_theme_bordered/br")
+    roundrect_based_theme("diamond", "_theme_diamond/d")
+    roundrect_based_theme("tv", "_theme_tv/t")
+    roundrect_based_theme("glow", "_theme_glow/g", None, "_outline.png")
+
+        
+    @theme
+    def ancient():
+
+        layout.defaults()
+        
+        style.frame.background = Solid((0, 0, 128, 128))
+        style.frame.xpadding = 10
+        style.frame.ypadding = 10
+        style.frame.xmargin = 10
+        style.frame.ymargin = 5
+        
+        style.menu_frame.set_parent(style.default)
+        
+        dark_cyan = (0, 192, 255, 255)
+        bright_cyan = (0, 255, 255, 255)
+        dark_red = (255, 128, 128, 255)
+        bright_red = (255, 64, 64, 255)
+        green = (0, 128, 0, 255)
+        
+        style.button_text.color = dark_cyan
+        style.button_text.hover_color = bright_cyan
+        style.button_text.insensitive_color = (192, 192, 192, 255)
+        style.button_text.size = 24
+        style.button_text.drop_shadow = (2, 2)        
+        style.button_text.drop_shadow_color = "#000"
+        
+        style.button_text.selected_color = dark_red
+        style.button_text.selected_hover_color = bright_red
+        
+        style.button_text.xalign = 0.5
+        style.button_text.text_align = 0.5
+        
+        style.bar.ymaximum = 22
+        style.bar.left_bar = Solid(bright_cyan)
+        style.bar.right_bar = Solid((0, 0, 0, 128))
+        style.bar.thumb = None
+        style.bar.thumb_offset = 0
+        style.bar.thumb_shadow = None
+
+        style.vbar.xmaximum = 22
+        style.vbar.bottom_bar = Solid(bright_cyan)
+        style.vbar.top_bar = Solid((0, 0, 0, 128))
+        style.vbar.thumb = None
+        style.vbar.thumb_offset = 0
+        style.vbar.thumb_shadow = None
+
+        style.slider.ymaximum = 22
+        style.slider.left_bar = Solid(bright_cyan)
+        style.slider.right_bar = Solid((0, 0, 0, 128))
+        style.slider.thumb = None
+        style.slider.thumb_offset = 0
+        style.slider.thumb_shadow = None
+
+        style.vslider.xmaximum = 22
+        style.vslider.bottom_bar = Solid(bright_cyan)
+        style.vslider.top_bar = Solid((0, 0, 0, 128))
+        style.vslider.thumb = None
+        style.vslider.thumb_offset = 0
+        style.vslider.thumb_shadow = None
+
+        style.scrollbar.ymaximum = 22
+        style.scrollbar.left_bar = Solid("#0008")
+        style.scrollbar.right_bar = Solid("#0008")
+        style.scrollbar.thumb = Solid(bright_cyan)
+        style.scrollbar.thumb_offset = 0
+        style.scrollbar.thumb_shadow = None
+
+        style.vscrollbar.xmaximum = 22
+        style.vscrollbar.top_bar = Solid("#0008")
+        style.vscrollbar.bottom_bar = Solid("#0008")
+        style.vscrollbar.thumb = Solid(bright_cyan)
+        style.vscrollbar.thumb_offset = 0
+        style.vscrollbar.thumb_shadow = None
+
+        style.large_button.xpadding = 5
+        style.large_button.ypadding = 2
+        style.large_button.xmargin = 5
+        style.large_button.ymargin = 2
+        style.large_button.background = "#fff"
+        style.large_button.hover_background = "#ffc"
+
+        style.large_button_text.size = 16
+        style.large_button_text.drop_shadow = (1, 1)
+        style.large_button_text.xalign = 0
+        style.large_button_text.text_align = 0
+
+        style.label_text.size = 24
+        style.label_text.color = green
+        style.label_text.drop_shadow = (1, 1)
+        style.label_text.drop_shadow_color = "#000"
+
+        style.prompt_text.size = 24
+        style.prompt_text.color = green
+        style.prompt_text.layout = "subtitle"
+        style.prompt_text.text_align = 0.5
+        style.prompt_text.drop_shadow = (1, 1)
+        style.prompt_text.drop_shadow_color = "#000"
+
+        style.mm_root.background = "#e9d8bc"
+        style.gm_root.background = "#e9d8bc"
+
+
+    @theme
+    def outline_frames():
+        theme.clear_frames()
+
+    @theme
+    def outline_buttons(
+        inside,
+        idle,
+        hover,
+        selected,
+        insensitive,
+        text_size):
+
+        theme.clear_buttons()
+
+        style.button.xmargin = 4
+        
+        style.button_text.size = text_size
+        style.button_text.color = inside
+        style.button_text.outlines = [ (2, idle) ]
+        style.button_text.hover_outlines = [ (2, hover) ]
+        style.button_text.selected_outlines = [ (2, selected) ]
+        style.button_text.selected_hover_outlines = [ (2, hover) ]
+        style.button_text.insensitive_outlines = [ (2, insensitive) ]
+        
+
+    @theme
+    def outline_large_buttons(
+        inside,
+        idle,
+        hover,
+        selected,
+        insensitive,
+        text_size,
+        large_button):
+
+        theme.clear_large_buttons()
+
+        style.large_button.xmargin = 4
+        style.large_button.ymargin = 2
+
+        style.large_button.background = large_button
+        
+        style.large_button_text.size = text_size
+        style.large_button_text.color = inside
+
+        style.large_button_text.outlines = [ (2, idle) ]
+        style.large_button_text.hover_outlines = [ (2, hover) ]
+        style.large_button_text.selected_outlines = [ (2, selected) ]
+        style.large_button_text.selected_hover_outlines = [ (2, hover) ]
+        style.large_button_text.insensitive_outlines = [ (2, insensitive) ]
+        
+    @theme
+    def outline_prompts(
+        inside,
+        prompt,
+        text_size):
+
+        theme.clear_prompts()
+        
+        style.prompt_text.color = inside
+        style.prompt_text.outlines = [ (2, prompt) ]
+        style.prompt_text.size = text_size
+        
+    @theme
+    def outline_labels(
+        inside,
+        label,
+        text_size):
+
+        theme.clear_labels()
+        
+        style.label_text.color = inside
+        style.label_text.outlines = [ (2, label) ]
+        style.label_text.size = text_size
+        
+    @theme
+    def outline_bars(        
+        inside,
+        idle,
+        hover):
+
+        theme.clear_bars()
+        
+        def color(fn, c):
+            return im.Twocolor("_outline/" + fn + ".png", inside, c)
+
+        style.bar.ymaximum = 16
+        style.bar.left_bar = Frame(color("circle", idle), 7, 0)
+        style.bar.right_bar = Frame(color("bar", idle), 0, 0)
+        style.bar.left_gutter = 16
+        style.bar.bar_resizing = True
+        
+        style.slider.ymaximum = 16
+        style.slider.left_bar = Frame(color("bar", idle), 0, 0)
+        style.slider.right_bar = Frame(color("bar", idle), 0, 0)
+        style.slider.thumb = color("circle", idle)
+        style.slider.hover_left_bar = Frame(color("bar", hover), 0, 0)
+        style.slider.hover_right_bar = Frame(color("bar", hover), 0, 0)
+        style.slider.hover_thumb = color("circle", hover)
+
+        style.scrollbar.ymaximum = 16
+        style.scrollbar.left_bar = Frame(color("bar", idle), 0, 0)
+        style.scrollbar.right_bar = Frame(color("bar", idle), 0, 0)
+        style.scrollbar.thumb = Frame(color("circle", idle), 7, 0)
+        style.scrollbar.hover_left_bar = Frame(color("bar", hover), 0, 0)
+        style.scrollbar.hover_right_bar = Frame(color("bar", hover), 0, 0)
+        style.scrollbar.hover_thumb = Frame(color("circle", hover), 7, 0)
+        
+        style.vbar.xmaximum = 16
+        style.vbar.bottom_bar = Frame(color("circle", idle), 0, 7)
+        style.vbar.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vbar.bottom_gutter = 16
+        style.vbar.bar_resizing = True
+
+        style.vslider.xmaximum = 16
+        style.vslider.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vslider.bottom_bar = Frame(color("vbar", idle), 0, 0)
+        style.vslider.thumb = color("circle", idle)
+        style.vslider.hover_top_bar = Frame(color("vbar", hover), 0, 0)
+        style.vslider.hover_bottom_bar = Frame(color("vbar", hover), 0, 0)
+        style.vslider.hover_thumb = color("circle", hover)
+
+        style.vscrollbar.xmaximum = 16
+        style.vscrollbar.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vscrollbar.bottom_bar = Frame(color("vbar", idle), 0, 0)
+        style.vscrollbar.thumb = Frame(color("circle", idle), 0, 7)
+        style.vscrollbar.hover_top_bar = Frame(color("vbar", hover), 0, 0)
+        style.vscrollbar.hover_bottom_bar = Frame(color("vbar", hover), 0, 0)
+        style.vscrollbar.hover_thumb = Frame(color("circle", hover), 0, 7)
+
+    @theme
+    def outline(
+        inside="#fff",
+        idle="#e66",
+        hover="#48f",
+        selected="#84f",
+        insensitive="#ccc",
+        label="#484",
+        prompt="#484",
+        background="#fee",
+        large_button="#fff8f8",
+        text_size=22,
+        small_text_size=16,
+        ):
+
+        layout.defaults()
+
+        theme.outline_frames()
+        
+        theme.outline_buttons(
+            inside,
+            idle,
+            hover,
+            selected,
+            insensitive,
+            text_size)
+
+        theme.outline_large_buttons(
+            inside,
+            idle,
+            hover,
+            selected,
+            insensitive,
+            small_text_size,
+            large_button)
+
+        theme.outline_prompts(
+            inside,
+            prompt,
+            text_size)
+
+        theme.outline_labels(
+            inside,
+            label,
+            text_size)
+
+        theme.outline_bars(
+            inside,
+            idle,
+            hover)
+
+        style.mm_root.background = background
+        style.gm_root.background = background
+        
+    @theme
+    def image_buttons(d):
+        for k, (idle, hover, selected_idle, selected_hover, insensitive) in d.iteritems():
+            s = style.button[k]
+            s.xpadding = 0
+            s.ypadding = 0
+            s.background = None
+            s.foreground = None
+            s.idle_child = idle
+            s.hover_child = hover
+            s.selected_idle_child = selected_idle
+            s.selected_hover_child = selected_hover
+            s.insensitive_child = insensitive 
+            s.focus_mask = True
+            
+
+    @theme
+    def image_labels(d):
+        for k, l in d.iteritems():
+            s = style.label[k]
+            s.xpadding = 0
+            s.ypadding = 0
+            s.background = None
+            s.foreground = None
+            s.child = k
+
+            
+    config.image_buttons = { }
+    config.image_labels = { }
+
+init 1110 python:
+
+    if not "compat" in _layout.provided:
+        theme.image_buttons(config.image_buttons)
+        theme.image_labels(config.image_labels)
+        
+    
+    
+        

common/00voice.rpy

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

common/DejaVuSans.txt

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

common/Vera.txt

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

common/_compat/gamemenu.rpym

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

common/_compat/library.rpym

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

common/_compat/mainmenu.rpym

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

common/_compat/preferences.rpym

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

common/_compat/styles.rpym

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

common/_compat/themes.rpym

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

common/_developer.rpym

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

common/_layout/classic_joystick_preferences.rpym

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

common/_layout/classic_load_save.rpym

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

common/_layout/classic_main_menu.rpym

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

common/_layout/classic_navigation.rpym

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

common/_layout/classic_preferences.rpym

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

common/_layout/classic_preferences_common.rpym

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

common/_layout/classic_yesno_prompt.rpym

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

common/_layout/grouped_main_menu.rpym

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

common/_layout/grouped_navigation.rpym

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

common/_layout/imagemap_common.rpym

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

common/_layout/imagemap_load_save.rpym

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

common/_layout/imagemap_main_menu.rpym

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

common/_layout/imagemap_navigation.rpym

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

common/_layout/imagemap_preferences.rpym

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

common/_layout/imagemap_yesno_prompt.rpym

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

common/_layout/one_column_preferences.rpym

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

common/_layout/screen_joystick_preferences.rpym

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

common/_layout/screen_load_save.rpym

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

common/_layout/screen_main_menu.rpym

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

common/_layout/screen_preferences.rpym

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

common/_layout/screen_yesno_prompt.rpym

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

common/_layout/scrolling_load_save.rpym

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

common/_layout/two_column_preferences.rpym

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