StoreDict and StoreModule classes.

sides of Frames.

.bzrignore

@@ -18,7 +18,7 @@ doc/reference
 doc/shared.css
 doc/tutorials
 doc/www.renpy.org
-testing
+testing*
 translations.rpy
 launchertrans.rpy
 jcc
@@ -64,37 +64,30 @@ msvcr90.dll
 python26.dll
 renpy.exe
 lib/windows-x86
-sphinx/source/inc/*
 doc/*
 updates/prerelease
-module/render.c
-module/_renpy.c
-module/_renpy_pysdlgl.c
-module/_renpybidi.c
-module/sound.c
-module/winmixer.c
-module/accelerator.html
-module/gldraw.html
-module/glenviron_fixed.html
-module/glenviron.html
-module/glenviron_limited.html
-module/glenviron_shader.html
-module/glrtt_copy.html
-module/glshader.html
-module/gltexture.html
-module/render.html
-module/accelerator.c
-module/gldraw.c
-module/glenviron.c
-module/glenviron_fixed.c
-module/glenviron_limited.c
-module/glenviron_shader.c
-module/glrtt_copy.c
-module/glshader.c
-module/gltexture.c
+module/gen
 log.txt
 lib/linux-x86
 lib/python
 lib/update-version.txt
 sphinx/game/saves
 tutorial/game/saves
+doc
+unparse.py
+module/glrtt_fbo.c
+module/glrtt_fbo.html
+tutorial/game/cache
+renpy.exe.log
+renpy/vc_version.py
+.pydevproject
+.project
+.settings
+LICENSE.txt
+template/README.html
+the_question/README.html
+tutorial/README.html
+trace.txt
+renpy/angle/*.pyx
+renpy/angle/*.pxd
+renpy-ppc.zip

LICENSE.txt

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

add.sh

@@ -9,7 +9,7 @@ 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
+cp renpy-ppc.zip ~/ab/website/renpy/dl/$1
 
 cd ~/ab/website
 ./upload.sh

after_checkout.sh

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

build_exe.py

@@ -3,7 +3,7 @@
 import modulefinder
 import shutil
 from distutils.core import setup
-import py2exe
+import py2exe #@UnresolvedImport @UnusedImport
 import sys
 import zipfile
 import traceback
@@ -27,7 +27,7 @@ def move_from_dist(fn):
     os.rename("dist/" + fn, fn)
 
 import renpy
-renpy.setup_modulefinder(modulefinder)
+renpy.setup_modulefinder(modulefinder) #@UndefinedVariable
 
 def main():
 
@@ -49,7 +49,6 @@ def main():
                                                 'pygame.surfarray',
                                                 'pygame.mixer',
                                                 'pygame.mixer_music',
-                                                'pygame.font',
                                                 '_ssl',
                                                 '_hashlib',
                                                 'win32con',
@@ -59,7 +58,6 @@ def main():
                                                 'gettext',
                                                 'os2emxpath',
                                                 'macpath',
-                                                'posixpath',
                                                 ],
                                  'optimize' : 2,
                                  } },

build_strings.py

@@ -3,8 +3,6 @@
 import collections
 import glob
 import re
-import sys
-import time
 import os
 
 # A map from string to filename, line number where the string is found.

common/00compat.rpy

@@ -48,9 +48,21 @@ init -1210 python:
             config.imagereference_respects_position = True
             config.predict_screens = False
             config.choice_screen_chosen = False
+
+        if version <= (6, 12, 0):
+            config.keep_running_transform = False
+            config.image_attributes = False
+            config.new_character_image_argument = False
+            config.save_physical_size = False
+            
+        if version <= (6, 12, 2):
+            style.default.language = "western"
+            style.default.layout = "greedy"
+            config.old_substitutions = True
+            config.new_substitutions = False
+            config.broken_line_spacing = True
             
             
-          
 init 1210 python hide::
 
     # This returns true if the script_version is <= the
@@ -103,3 +115,8 @@ init 1210 python hide::
             
     for i in layout.compat_funcs:
         i()
+
+    if config.hyperlink_styler or config.hyperlink_callback or config.hyperlink_focus:
+        style.default.hyperlink_functions = (config.hyperlink_styler, config.hyperlink_callback, config.hyperlink_focus)
+        
+        

common/00definitions.rpy

@@ -24,6 +24,15 @@ init -1110:
 
     transform truecenter:
         xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+
+    transform topleft:
+        xpos 0.0 xanchor 0.0 ypos 0.0 yanchor 0.0
+        
+    transform topright:
+        xpos 1.0 xanchor 1.0 ypos 0.0 yanchor 0.0
+        
+    transform top:
+        xpos 0.5 xanchor 0.5 ypos 0.0 yanchor 0.0
         
     # Offscreen positions for use with the move transition. Images at
     # these positions are still shown (and consume
@@ -87,6 +96,55 @@ init -1110 python:
 
     # 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):
+        """
+        :doc: transition_family
+
+        This defines a family of move transitions, similar to the move and ease
+        transitions. For a given `prefix`, this defines the transitions:
+
+        * *prefix*- A transition that takes `delay` seconds to move images that
+          changed positions to their new locations.
+
+        * *prefix*\ inleft, *prefix*\ inright, *prefix*\ intop, *prefix*\ inbottom - Transitions
+          that take `delay` seconds to move images that changed positions to their
+          new locations, with newly shown images coming in from the appropriate
+          side.
+
+        * *prefix*\ outleft, *prefix*\ outright, *prefix*\ outtop, *prefix*\ outbottom -
+          Transitions that take `delay` seconds to move images that changed
+          positions to their new locations, with newly hidden images leaving via
+          the appropriate side.
+
+        `time_warp`, `in_time_warp`, `out_time_warp`        
+            Time warp functions that are given a time from 0.0 to 1.0 representing
+            the fraction of the move complete, and return a value in the same 
+            range giving the fraction of a linear move that is complete.
+            
+            This can be used to define functions that ease the images around,
+            rather than moving them at a constant speed.
+            
+            The three argument are used for images remaining on the screen,
+            newly shown images, and newly hidden images, respectively.
+
+        `old`
+            If true, the transitions to move the old displayables, rather than the new ones.
+
+        `layers`        
+            The layers the transition will apply to.
+
+        Additional keyword arguments are passed (indirectly) to the moves. The
+        most useful additional keyword argument is probably subpixel=True,
+        which causes a subpixel move to be used.
+
+        ::
+
+            # This defines all of the pre-defined transitions beginning
+            # with "move".
+            init python:
+                define.move_transitions("move", 0.5)
+        
+        """
+        
         moves = {
             "" : MoveTransition(
                 delay,

common/00gallery.rpy

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

common/00gltest.rpy

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

common/00layout.rpy

@@ -375,6 +375,11 @@ init -1105 python hide:
     layout.QUIT = u"Are you sure you want to quit?"
     layout.MAIN_MENU = u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
 
+    @layout
+    def invoke_yesno_prompt(*args):
+        _enter_menu()
+        return layout.yesno_prompt(*args)
+
     @layout
     def yesno_screen(message, yes=None, no=None):
         """
@@ -414,10 +419,16 @@ init -1105 python hide:
             
             return
             
-        if renpy.invoke_in_new_context(layout.yesno_prompt, None, message):
+        if renpy.invoke_in_new_context(layout.invoke_yesno_prompt, None, message):
             if yes is not None:
                 yes()
         else:
             if no is not None:
                 no()
+    
+    
+    def __auto_save_extra_info():
+        return save_name
+    
+    config.auto_save_extra_info = __auto_save_extra_info
                 

common/00library.rpy

@@ -94,7 +94,7 @@ init -1180 python:
 
 
     def _default_empty_window():
-
+        
         who = _last_say_who
 
         if who is not None:
@@ -238,7 +238,8 @@ init -1180 python:
 
     config.screenshot_callback = _screenshot_callback
         
-    
+    _predict_screens = [ ]
+        
 init -1180 python hide:
 
     def dump_styles():
@@ -304,6 +305,7 @@ init -1180 python hide:
         quit = renpy.quit_event,
         iconify = renpy.iconify,
         help = _help,
+        choose_renderer = renpy.curried_call_in_new_context("_choose_renderer"),
         )
 
     config.underlay = [ km ]
@@ -333,7 +335,7 @@ init -1180 python hide:
 
     config.overlay_functions.append(skip_indicator)
 
-
+    # Hyperlink functions. Duplicated in _errorhandling.rpym.
     def hyperlink_styler(target):
         return style.hyperlink_text
 
@@ -347,11 +349,15 @@ init -1180 python hide:
         else:
             renpy.call_in_new_context(target)
 
-    config.hyperlink_styler = hyperlink_styler
-    config.hyperlink_callback = hyperlink_function
+    style.default.hyperlink_functions = (hyperlink_styler, hyperlink_function, None)
 
     # Prediction of screens.    
     def predict():
+
+        for s in _predict_screens:
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+
         s = _game_menu_screen
 
         if s is None:
@@ -367,6 +373,7 @@ init -1180 python hide:
                 renpy.predict_screen(s)
                 return
 
+            
     config.predict_callbacks.append(predict)
             
     def imagemap_auto_function(auto_param, variant):
@@ -470,47 +477,6 @@ init 1180 python:
         _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
@@ -595,27 +561,14 @@ init -1180 python:
 
         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:
+    def _enter_menu():
         renpy.movie_stop(only_fullscreen=True)
         renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
 
         for i in config.menu_clear_layers:
             renpy.scene(layer=i)
         
-        renpy.context()._menu = True
-        
-        # This may be changed, if we are already in the main menu.
+        renpy.context()._menu = True        
         renpy.context()._main_menu = False
         renpy.context_dynamic("main_menu")
         renpy.context_dynamic("_window_subtitle")
@@ -632,11 +585,18 @@ label _enter_menu:
         for i in config.clear_layers:
             renpy.scene(layer=i)
         
-    return
+# Run at the end of init, to set up autosaving based on the user's
+# choices.
+init 1180 python:
+
+    if config.has_autosave:
+        config.autosave_slots = 10
+    else:
+        config.autosave_frequency = None
     
 # Factored this all into one place, to make our lives a bit easier.
 label _enter_game_menu:
-    call _enter_menu from _call__enter_menu_2
+    $ _enter_menu()
 
     $ renpy.transition(config.enter_transition)
 
@@ -782,7 +742,9 @@ label _start:
     $ renpy.block_rollback()
 
     $ _old_game_menu_screen = _game_menu_screen
+    $ _old_predict_screens = _predict_screens
     $ _game_menu_screen = None
+    $ _predict_screens = [ 'main_menu' ]
     
     if renpy.has_label("splashscreen") and not _restart:
         call expression "splashscreen" from _call_splashscreen_1
@@ -830,7 +792,7 @@ label _invoke_main_menu:
 # initialize it.
 label _main_menu(_main_menu_screen="_main_menu_screen"):
 
-    call _enter_menu from _call__enter_menu_1
+    $ _enter_menu()
 
     python:
         renpy.dynamic("_load_prompt")
@@ -899,7 +861,7 @@ init 1180 python hide:
                 continue
             
             # Reject if it already exists.
-            if name in renpy.exports.images:
+            if name in renpy.display.image.images:
                 continue
 
             renpy.image(name, fn)
@@ -921,6 +883,25 @@ label _developer:
     if not config.developer:
         return
 
-    call _enter_menu from _call__enter_menu_4
+    $ _enter_menu()
 
     jump expression "_developer_screen"
+
+
+# Translations.
+init -1180 python:
+
+    def _language_activate():
+
+        if persistent._language:
+            language = persistent._language 
+        else:
+            language = "translations"
+    
+        if renpy.loadable(language + ".rpt"):
+            config.translator = renpy.Translator(language)
+        else:
+            config.translator = None
+            
+    _language_activate()
+            

common/00musicroom.rpy

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

common/00nvl_mode.rpy

@@ -119,6 +119,7 @@ init -1100 python:
          """
 
         widget_properties, dialogue = __nvl_screen_dialogue()        
+
         renpy.show_screen(screen_name, _transient=True, _widget_properties=widget_properties, dialogue=dialogue, **scope) 
         renpy.shown_window()
 
@@ -126,7 +127,7 @@ init -1100 python:
         
     def nvl_show_core(who=None, what=None):
 
-        # Screen version.
+         # Screen version.
         if renpy.has_screen("nvl"):
             return __nvl_show_screen("nvl", items=[ ])
         
@@ -214,6 +215,7 @@ init -1100 python:
                 **properties)
 
         def do_add(self, who, what):
+        
             if store.nvl_list is None:
                 store.nvl_list = [ ]
                 

common/00screen.rpy

@@ -159,8 +159,6 @@ init -1140 python:
         def __call__(self):
             renpy.notify(self.message)
             
-            
-            
     class InvertSelected(Action):
         """
          :doc: other_action
@@ -186,6 +184,7 @@ init -1140 python:
 
         def predict(self):
             self.action.predict()
+
         
     def If(expression, true=None, false=None):
         """
@@ -201,6 +200,55 @@ init -1140 python:
             return true
         else:
             return false
+
+
+    class SelectedIf(Action):
+        """
+        :doc: other_action
+        
+        This allows an expression to control if a button should be marked
+        as selected. It should be used as part of a list with one or more
+        actions. For example::
+        
+            # The button is selected if mars_flag is True
+            textbutton "Marsopolis": 
+                action [ Jump("mars"), SelectedIf(mars_flag) ]
+        """
+        
+        def __init__(self, expression):
+            self.expression = expression
+            
+        def __call__(self):
+            return None
+            
+        def get_selected(self):
+            return self.expression
+
+
+    def Rollback():
+        """
+        :doc: other_action
+        
+        This action causes a rollback to occur, when a rollback is possible.
+        Otherwise, nothing happens.
+        """
+    
+        return renpy.rollback
+         
+    class RollForward(Action):
+        """
+        :doc: other_action
+        
+        This action causes a rollforward to occur, if a roll forward is 
+        possible. Otherwise, it is insensitive.
+        """
+        
+        def __call__(self):
+            return renpy.roll_forward_info()
+            
+        def get_sensitive(self):
+            return renpy.roll_forward_info() is not None
+         
          
     ##########################################################################
     # Menu-related actions.
@@ -459,6 +507,19 @@ init -1140 python:
         def get_selected(self):
             return self.dict[self.key] == self.value
 
+    def SetScreenVariable(name, value):
+        """
+        :doc: data_action
+
+        Causes the variable `name` associated with the current screen to 
+        be set to `value`.
+        """
+        
+        cs = renpy.current_screen()
+        if cs is not None:
+            return SetDict(cs.scope, name, value)
+        else:
+            return None
     
     class ToggleField(Action):
         """
@@ -564,6 +625,24 @@ init -1140 python:
 
             return rv
 
+    def ToggleScreenVariable(name, true_value=None, false_value=None):
+        """
+         :doc: data_action
+
+         Toggles the value of the variable `name` in the current screen.
+
+         `true_value`
+             If not None, then this is the true value we use.
+         `false_value`
+             If not None, then this is the false value we use. 
+         """
+    
+        cs = renpy.current_screen()
+
+        if cs is not None:
+            return ToggleDict(cs.scope, name, true_value=true_value, false_value=None)
+        else:
+            return None
 
     ##########################################################################
     # Audio actions.
@@ -648,8 +727,31 @@ init -1140 python:
             renpy.music.stop(channel=self.channel, **self.kwargs)
             renpy.restart_interaction()
 
+    class SetMixer(Action):
+        """
+        :doc: audio_action
         
+        Sets the volume of `mixer` to `value`. 
+        
+        `mixer`
+            The mixer to set the volume of. A string, usually one of 
+            "music", "sfx", or "voice".
+        `value`
+            The value to set the volume to. A number between 0.0 and 1.0, 
+            inclusive.
+        """
     
+        def __init__(self, mixer, volume):
+            self.mixer = mixer
+            self.volume = volume
+            
+        def __call__(self):
+            _preferences.set_volume(self.mixer, self.volume)
+            renpy.restart_interaction()
+            
+        def get_selected(self):
+            return _preferences.get_volume(self.mixer) == self.volume
+                
     ##########################################################################
     # BarValues
 
@@ -764,14 +866,19 @@ init -1140 python:
              This is used internally, for some preferences.
          `style`
              The styles of the bar created.
+         `offset`
+             An offset to add to the value.
          """
         
-        def __init__(self, object, field, range, max_is_zero=False, style="bar"):
+        offset = 0
+        
+        def __init__(self, object, field, range, max_is_zero=False, style="bar", offset=0):
             self.object = object
             self.field = field
             self.range = range
             self.max_is_zero = max_is_zero
             self.style = style
+            self.offset = offset
             
         def changed(self, value):
 
@@ -781,12 +888,16 @@ init -1140 python:
                 else:
                     value = value + 1
             
+            value += self.offset
+            
             setattr(self.object, self.field, value)
             
         def get_adjustment(self):
 
             value = getattr(self.object, self.field)
             
+            value -= self.offset
+            
             if self.max_is_zero:
                 if value == 0:
                     value = self.range
@@ -987,15 +1098,23 @@ init -1140 python:
 
          `newest`
              If true, then this file will be marked as the newest save
-             file when it's saved. (Set this to false for a quicksave,
-             for example.)
+             file when it's saved.
+
+         `page`
+             The name of the page that it will be saved to.
+
+         `cycle`
+             If true, then saves on the supplied page will be cycled before
+             being shown to the user.
          """
 
-        def __init__(self, name, confirm=True, newest=True, page=None):
+        def __init__(self, name, confirm=True, newest=True, page=None, cycle=False):
             self.name = name
             self.confirm = confirm
             self.page = page
             self.newest = newest
+            self.page = page
+            self.cycle = cycle
             
         def __call__(self):
 
@@ -1004,6 +1123,9 @@ init -1140 python:
             
             fn = __filename(self.name, self.page)
 
+            if self.cycle:
+                renpy.renpy.loadsave.cycle_saves(self.page + "-", 10)
+
             if renpy.scan_saved_game(fn):
                 if self.confirm:
                     layout.yesno_screen(layout.OVERWRITE_SAVE, FileSave(self.name, False, self.newest, self.page))
@@ -1013,6 +1135,9 @@ init -1140 python:
 
             if self.newest:
                 persistent._file_newest = fn
+
+                if self.page is not None:
+                    persistent._file_page = self.page
                 
             renpy.restart_interaction()
 
@@ -1025,6 +1150,9 @@ init -1140 python:
                 return True
 
         def get_selected(self):
+            if not self.confirm:
+                return False
+            
             return persistent._file_newest == __filename(self.name, self.page)
             
     class FileLoad(Action):
@@ -1035,12 +1163,16 @@ init -1140 python:
 
          `confirm`
              If true, prompt if loading the file will end the game.
+
+         `newest`
+             If true, the button is selected if this is the newest file.
          """
         
-        def __init__(self, name, confirm=True, page=None):
+        def __init__(self, name, confirm=True, page=None, newest=True):
             self.name = name
             self.confirm = confirm
             self.page = page
+            self.newest = newest
             
         def __call__(self):
 
@@ -1060,6 +1192,9 @@ init -1140 python:
             return renpy.scan_saved_game(__filename(self.name, self.page))
 
         def get_selected(self):
+            if not self.confirm or not self.newest:
+                return False
+
             return persistent._file_newest == __filename(self.name, self.page)
 
     class FileDelete(Action):
@@ -1128,19 +1263,74 @@ init -1140 python:
 
             persistent._file_page = self.page
             renpy.restart_interaction()
-
-        def get_sensitive(self):
-            if self.page == "auto" and not config.has_autosave:
-                return False
-            elif self.page == "quicksave" and not config.has_quicksave:
-                return False
-            else:
-                return True
-
+            
         def get_selected(self):
             return self.page == persistent._file_page
                 
-            
+    def FilePageName(auto="a", quick="q"):
+        """
+         :doc: file_action_function
+
+         Returns the name of the current file page, as a string. If a normal
+         page, this returns the page number. Otherwise, it returns
+         `auto` or `quick`.
+         """
+
+        page = persistent._file_page
+
+        if page == "quick":
+            return quick
+        elif page == "auto":
+            return auto
+        else:
+            return page
+
+    def FileSlotName(slot, slots_per_page, auto="a", quick="q", format="%s%d"):
+        """
+         :doc: file_action_function
+
+         Returns the name of the numbered slot. This assumes that slots on
+         normal pages are numbered in a linear order starting with 1, and
+         that page numbers start with 1. When slot is 2, and slots_per_page
+         is 10, and the other variables are the defauts:
+
+         * When the first page is slowing, this returns "2".
+         * When the second page is showing, this returns "12".
+         * When the auto page is showing, this returns "a2".
+         * When the quicksave page is showing, this returns "q2".
+
+         `slot`
+             The number of the slot to access.
+
+         `slots_per_page`
+             The number of slots per page.
+
+         `auto`
+             A prefix to use for the auto page.
+
+         `quick`
+             A prefix to use for the quick page.
+
+         `format`
+             The formatting code to use. This is given two arguments: A string
+             giving the page prefix, and an integer giving the slot number.
+         """
+
+        page = persistent._file_page
+
+        if page == "quick":
+            prefix = quick
+            page = 0
+        elif page == "auto":
+            prefix = auto
+            page = 0
+        else:
+            prefix = ""
+            page = int(page) - 1
+
+        return format % (prefix, page * slots_per_page + slot)
+         
+        
     class FilePageNext(Action):
         """
          :doc: file_action
@@ -1243,10 +1433,76 @@ init -1140 python:
         def __call__(self):
             renpy.take_screenshot()
         
-            
+    def QuickSave(message="Quick save complete."):
+        """
+        :doc: file_action
+        
+        Performs a quick save.
+        
+        `message`
+            A message to display to the user when the quick save finishes.
+        """
+    
+        return [ 
+            FileTakeScreenshot(),
+            FileSave(1, page="quick", confirm=False, cycle=True), 
+            Notify("Quick save complete.") ]
+        
+    def QuickLoad():
+        """
+        :doc: file_action
+    
+        Performs a quick load.
+        """
+    
+        return FileLoad(1, page="quick", confirm=True, newest=False)
+
+    
+    ##########################################################################
+    # Side Images
+    
+    def SideImage(tag="side"):
+        """
+        :doc: side_image_function
+    
+        Returns the side image associated with the currently speaking character, 
+        or a Null displayable if no such side image exists.
+        """
+        
+        name = renpy.get_side_image(tag)
+        if name is None:
+            return Null()
+        else:
+            return ImageReference(name)
+
+
     ##########################################################################
     # Preferences Constructor
 
+    class __DisplayAction(Action):
+        def __init__(self, factor):
+            self.width = int(factor * config.screen_width)
+            self.height = int(factor * config.screen_height)            
+
+        def __call__(self):
+            renpy.set_physical_size((self.width, self.height))
+            renpy.restart_interaction()
+            
+        def get_sensitive(self):
+            if self.width == config.screen_width and self.height == config.screen_height:
+                return True
+                
+            return renpy.get_renderer_info()["resizable"]
+            
+        def get_selected(self):
+            if _preferences.fullscreen:
+                return False
+
+            return (self.width, self.height) == renpy.get_physical_size()
+                    
+                    
+    config.always_has_joystick = False
+
     def Preference(name, value=None):
         """
          :doc: preference_action
@@ -1260,7 +1516,8 @@ init -1140 python:
          Actions that can be used with buttons and hotspots are:
 
          * Preference("display", "fullscreen") - displays in fullscreen mode.
-         * Preference("display", "window") - displays in windowed mode.
+         * Preference("display", "window") - displays in windowed mode at 1x normal size.
+         * Preference("display", 2.0) - displays in windowed mode at 2.0x normal size.
          * Preference("display", "toggle") - toggle display mode.
 
          * Preference("transitions", "all") - show all transitions.
@@ -1300,6 +1557,10 @@ init -1140 python:
          * Preference("voice mute", "enable") - Mute the voice mixer.
          * Preference("voice mute", "disable") - Un-mute the voice mixer.
          * Preference("voice mute", "toggle") - Toggle voice  mute.
+
+         * Preference("music volume", 0.5) - Set the music volume.
+         * Preference("sound volume", 0.5) - Set the sound volume.
+         * Preference("volice volume", 0.5) - Set the voice volume.
          
          Values that can be used with bars are:
 
@@ -1319,9 +1580,11 @@ init -1140 python:
             if value == "fullscreen":
                 return SetField(_preferences, "fullscreen", True)
             elif value == "window":
-                return SetField(_preferences, "fullscreen", False)
+                return __DisplayAction(1.0)
             elif value == "toggle":
                 return ToggleField(_preferences, "fullscreen")
+            elif isinstance(value, (int, float)):
+                return __DisplayAction(value)
 
         elif name == "transitions":
 
@@ -1343,7 +1606,10 @@ init -1140 python:
 
         elif name == "joystick" or name == "joystick...":
 
-            return ShowMenu("joystick_preferences")
+            if renpy.display.joystick.enabled or config.always_has_joystick:
+                return ShowMenu("joystick_preferences")
+            else:
+                return None
 
         elif name == "skip":
             
@@ -1379,7 +1645,12 @@ init -1140 python:
         elif name == "auto-forward time":
 
             if value is None:
-                return FieldValue(_preferences, "afm_time", range=40, max_is_zero=True, style="slider")
+                
+                if config.default_afm_enable is None:
+                    return FieldValue(_preferences, "afm_time", range=30.0, max_is_zero=True, style="slider")
+                else:
+                    return FieldValue(_preferences, "afm_time", range=29.9, style="slider", offset=.1)
+                    
             elif isinstance(value, int):
                 return SetField(_preferences, "afm_time", value)
 
@@ -1396,16 +1667,22 @@ init -1140 python:
 
             if value is None:
                 return MixerValue('music')
+            else:
+                return SetMixer('music', value)
 
         elif name == "sound volume":
 
             if value is None:
                 return MixerValue('sfx')
+            else:
+                return SetMixer('sfx', value)
 
         elif name == "voice volume":
 
             if value is None:
                 return MixerValue('voice')
+            else:
+                return SetMixer('voice', value)
 
         elif name == "music mute":
 
@@ -1441,7 +1718,84 @@ init -1140 python:
     # What we do on a quit, by default.
     config.quit_action = ui.gamemenus("_confirm_quit")
 
+    #########################################################################    
+
+    class __TooltipAction(object):
+
+        def __init__(self, tooltip, value):
+            self.tooltip = tooltip
+            self.value = value
+
+        def __call__(self):
+            if self.tooltip.value != self.value:
+                self.tooltip.value = self.value
+                renpy.restart_interaction()            
+
+        def unhovered(self):
+            if self.tooltip.value != self.tooltip.default:
+                self.tooltip.value = self.tooltip.default
+                renpy.restart_interaction()            
+
+    class Tooltip(object):
+        """
+        :doc: tooltips class
+        
+        A tooltip object can be used to define a portion of a screen that is 
+        updated when the mouse hovers an area. 
+        
+        A tooltip object has a ``value`` field, which is set to the `default`
+        value passed to the constructor when the tooltip is created. When 
+        a button using an action creadted by the tooltip is hovered, the 
+        value field changes to the value associated with the action. 
+        """
+                   
+        def __init__(self, default):
+            self.value = default
+            self.default = default
+
+        def Action(self, value):
+            """
+            :doc: tooltips method
+            :name: Action
+            
+            Returns an action that is generally used as the hovered property
+            of a button. When the button is hovered, the value field of this 
+            tooltip is set to `value`. When the buttton loses focus, the
+            value field of this tooltip reverts to the default.
+            """
+        
+            return __TooltipAction(self, value)
     
+        action = Action
+
+    #########################################################################    
+
+    class Language(Action):
+        """
+        :doc: other_action
+        
+        Changes the language of the game to `language`. A language change
+        causes the current statement to be restarted, and all contexts but 
+        the outermost being exited.
+        
+        `language`
+            A string giving the language to translate to, or None to use
+            the language given in the game script.
+        """
+
+        def __init__(self, language):
+            self.language = language
+            
+        def __call__(self):
+            persistent._language = self.language
+            _language_activate()
+            renpy.restart_interaction()
+            renpy.rollback(True, 0)
+            
+        def get_selected(self):
+            return persistent._language == self.language
+            
+            
 # This is used to ensure a fixed click-to-continue indicator is shown on
 # its own layer.
 screen _ctc:

common/00statements.rpy

@@ -7,7 +7,8 @@
 # Statements can be defined by calling renpy.statements.register. This
 # function takes a string giving the keywords at the start of the
 # statement, and then up to 4 functions defining the behavior of the
-# statement: parse, execute, predict, and lint
+# statement: parse, execute, predict, and lint. If given the keyword
+# argument block=True, the statement will take a block.
 #
 # The parse function takes a lexer object as an argument, and is
 # expected to return some parser data. The lexer has the following
@@ -31,6 +32,13 @@
 # l.revert(o) - Given the object returned by l.checkpoint(), returns
 # there.
 #
+# l.subblock_lexer() - Return a lexer that gives a sub-block for the 
+# block associated with the current statement.
+# l.advance() - In a subblock lexer, advance to the next line. This needs
+# to be called before the above functions can be called on the first line. 
+# 
+#
+#
 # The parse function is expected to return an object, which is passed
 # to the other functions. Parse should call renpy.error with the error
 # message to report an error.

common/00style.rpy

@@ -72,6 +72,7 @@ init -1200 python hide:
 
     style.hyperlink = Style(style.default, help=None) # ignored
     style.hyperlink_text = Style(style.default, help='hyperlinked text')
+    style.ruby_text = Style(style.default, help='ruby text')
 
     style.viewport = Style(style.default, help='default style of viewports')
     style.transform = Style(style.motion, help='default style of transforms')
@@ -130,7 +131,7 @@ init -1090 python:
 
     # Text properties.
     style.default.font = "DejaVuSans.ttf"
-    style.default.language = "western"
+    style.default.language = "unicode"
     style.default.antialias = True
     style.default.size = 22
     style.default.color = (255, 255, 255, 255)
@@ -139,6 +140,7 @@ init -1090 python:
     style.default.italic = False
     style.default.underline = False
     style.default.strikethrough = False
+    style.default.kerning = 0.0
     style.default.drop_shadow = None
     style.default.drop_shadow_color = (0, 0, 0, 255)
     style.default.outlines = [ ]
@@ -149,11 +151,14 @@ init -1090 python:
     style.default.first_indent = 0
     style.default.rest_indent = 0
     style.default.line_spacing = 0
-    style.default.layout = "greedy"
+    style.default.line_leading = 0
+    style.default.line_overlap_split = 0
+    style.default.layout = "tex"
     style.default.subtitle_width = 0.9
     style.default.slow_cps = None
     style.default.slow_cps_multiplier = 1.0
     style.default.slow_abortable = False
+    # style.default.hyperlink_functions (set in 00library.rpy)
     
     # Window properties.
     style.default.background = None
@@ -184,6 +189,7 @@ init -1090 python:
     style.default.spacing = 0
     style.default.first_spacing = None
     style.default.box_layout = None
+    style.default.box_wrap = False
 
     # Focus properties.
     style.default.focus_mask = None
@@ -259,6 +265,11 @@ init -1090 python:
     style.hyperlink_text.hover_color = "#0ff"
     style.hyperlink_text.idle_color = "#08f"
     
+    # Ruby.
+    style.ruby_text.size = 22
+    style.ruby_text.xoffset = 0
+    style.default.ruby_style = style.ruby_text
+    
     # Bars.
     style.default.bar_invert = False
     style.default.bar_resizing = False
@@ -314,3 +325,4 @@ init -1090 python:
     style.error_title.color = (255, 128, 128, 255)
     style.error_body.color = (128, 128, 255, 255)
 
+    

common/00stylepreferences.rpy

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

common/00themes.rpy

@@ -401,7 +401,11 @@ init -1110 python hide:
     roundrect_based_theme("diamond", "_theme_diamond/d")
     roundrect_based_theme("tv", "_theme_tv/t")
     roundrect_based_theme("glow", "_theme_glow/g", None, "_outline.png")
-
+    roundrect_based_theme("regal", "_theme_regal/re")
+    roundrect_based_theme("crayon", "_theme_crayon/cry")
+    roundrect_based_theme("threeD", "_theme_threeD/th")
+    roundrect_based_theme("marker", "_theme_marker/ink")
+    roundrect_based_theme("austen", "_theme_austen/au")
         
     @theme
     def ancient():

common/_compat/gamemenu.rpym

@@ -10,11 +10,11 @@ init python:
     # The contents of the game menu choices.
     config.game_menu = [
             ( "return", u"Return", ui.jumps("_return"), 'True'),
-            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context().main_menu'),
+            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context()._main_menu'),
             ( "prefs", u"Preferences", _intra_jumps("_prefs_screen", "intra_transition"), 'True' ),
-            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context().main_menu' ),
+            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context()._main_menu' ),
             ( "load", u"Load Game", _intra_jumps("_load_screen", "intra_transition"), 'True'),
-            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context().main_menu' ),
+            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context()._main_menu' ),
             ( "quit", u"Quit", lambda : _quit_prompt("quit"), 'True' ),
             ]
 
@@ -463,7 +463,7 @@ label _load_screen:
 
         fn, exists = _file_picker("load", False )
 
-        if not renpy.context().main_menu and _load_prompt:
+        if not renpy.context()._main_menu and _load_prompt:
             if _yesno_prompt("load", u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
                 renpy.load(fn)
         else:                        

common/_developer.rpym

@@ -2,30 +2,41 @@
 # games.
 
 screen _developer:
-    window style "gm_root"
 
     frame:
-        style_group "_developer"
+        style_group ""
 
         align (.025, .05)
 
-        has vbox:
-            first_spacing 10
+        has vbox
 
         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"
-        
+        textbutton _(u"Reload Game (Shift+R)"): 
+            action ui.callsinnewcontext("_save_reload_game")
+            size_group "developer"
+        textbutton _(u"Variable Viewer"):
+            action Jump("_debugger_screen")
+            size_group "developer"
+        textbutton _(u"Theme Test"): 
+            action Jump("_theme_test")
+            size_group "developer"
+        textbutton _(u"Style Hierarchy"): 
+            action Jump("_style_hierarchy")
+            size_group "developer"
+        textbutton _(u"Image Location Picker"): 
+            action Jump("_image_location_picker")
+            size_group "developer"
+        textbutton _(u"Filename List"): 
+            action Jump("_filename_list")
+            size_group "developer"
+
+        null height 15
+
+        textbutton _(u"Return"):
+            action Return()
+            size_group "developer"
+         
 label _developer_screen:
 
     call screen _developer
@@ -444,7 +455,7 @@ label _image_location_picker:
 
             for fn in image_files:
                 ui.button(clicked=ui.returns(fn), size_group="files", xminimum=1.0)
-                ui.text(fn, style="button_text", xalign=0.0)
+                ui.text(fn.replace("{", "{{"), style="button_text", xalign=0.0)
                 
             ui.close()
 
@@ -494,7 +505,68 @@ label _filename_list:
         
     
     jump _developer_screen
+
+# The style inspector.
+screen _inspector:
+    zorder 1010
+    modal True
+    
+    frame:
+        style_group ""
         
+        xfill True
+        yfill True
+        
+        
+        has vbox
+        
+        label _("Style Inspector")
+        
+        null height 20
+        
+        if not tree:
+            text _("Nothing to inspect.")
+        else:
+            for depth, width, height, d in tree:      
+                $ t = ( "  " * depth + 
+                        u" \u2022 " + 
+                        d.__class__.__name__ + " : " + 
+                        "style=%s, " % (__format_style(d.style),) + 
+                        "size=(%dx%d)" % (width, height) ) 
+                 
+                text t
+                  
+        null height 20
+        
+        text _("(Click to continue.)")
+    
+    python:
+        ui.saybehavior()
+   
+   
+init python:
+
+    def __format_style(s):
+        
+        while s:
+            if s.name:
+                break
+            
+            if s.parent:
+                s = style.get(s.parent)
+            else:
+                break
+                
+        return s.name[0] + "".join([ "[%r]" % i for i in s.name[1:] ]) 
+    
+    def __inspect(tree):
+        renpy.context_dynamic("_window")
+        store._window = False
+        
+        renpy.exports.show_screen("_inspector", _transient=True, tree=tree)
+        renpy.ui.interact(mouse="screen", type="screen", suppress_overlay=True, suppress_underlay=True)
+             
+    config.inspector = __inspect
 
 init python:
     config.underlay.append(im.Tile("_transparent_tile.png"))

common/_errorhandling.rpym

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

common/_layout/classic_load_save.rpym

@@ -351,11 +351,3 @@ label load_screen:
                     continue
 
             renpy.load(fn)
-            
-            
-            
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    

common/_layout/imagemap_load_save.rpym

@@ -352,9 +352,3 @@ label load_screen:
                     continue
 
             renpy.load(fn)
-                        
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    

common/_layout/screen_yesno_prompt.rpym

@@ -6,6 +6,7 @@ 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))
+        rv = renpy.call_screen('yesno_prompt', message=message, yes_action=Return(True), no_action=Return(False))
+        return rv
     
     layout.yesno_prompt = yesno_prompt

common/_layout/scrolling_load_save.rpym

@@ -227,10 +227,3 @@ label load_screen:
                     continue
 
             renpy.load(fn)
-            
-            
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    

distribute.py

@@ -5,7 +5,6 @@ import sys
 import os
 import zipfile
 import tarfile
-import time
 import zlib
 import compileall
 import shutil
@@ -13,6 +12,7 @@ import subprocess
 import makeupdate
 import glob
 import time
+import argparse
 
 zlib.Z_DEFAULT_COMPRESSION = 9
 
@@ -115,27 +115,50 @@ def tree(root):
 
 def main():
 
-    if len(sys.argv) != 2:
-        print "Usage: %s <prefix>" % sys.argv[0]
-        return
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--fast", action="store_true")
+    ap.add_argument("prefix")
+    
+    args = ap.parse_args()
 
-    prefix = sys.argv[1]
-
-    shutil.copy("tutorial/game/screens.rpy", "template/game/screens.rpy")
-        
-    # Update the update-version.txt file.
+    # Revision updating is done early, so we can do it even if the rest
+    # of the program fails.
+    
+    # Determine the version. We grab the current revision, and if any
+    # file has changed, bump it by 1.
     p = subprocess.Popen(["bzr", "revno"], stdout=subprocess.PIPE)
-    revno = p.stdout.read().strip() + "-" + str(time.time())
+    revno = p.stdout.read().strip()
+    revno = int(revno)
     p.wait()
 
+    p = subprocess.Popen(["bzr", "status", "-V"], stdout=subprocess.PIPE)
+    status = p.stdout.read().strip()
+    p.wait()
+    
+    if status:
+        revno += 1
+        
+    # Write the revno to the necessary files.
     f = file("lib/update-version.txt", "w")
-    f.write(revno + " base\n")
+    f.write("{revno}-{now} base\n".format(revno=revno, now=time.time()))
+    f.close()
+
+    f = file("renpy/vc_version.py", "w")
+    f.write("""\
+# The version of Ren'Py reported by the version control software.
+vc_version = {revno}
+""".format(revno=revno))
     f.close()
     
-    # Compile all the python files.
-    compileall.compile_dir("renpy/", ddir=prefix + "/renpy/", force=1)
+    prefix = args.prefix
 
-    os.environ['RENPY_PATH_ELIDE'] = '/home/tom/ab/renpy:' + prefix
+    # Copy over the screens, to keep them up to date.
+    shutil.copy("tutorial/game/screens.rpy", "template/game/screens.rpy")
+
+    # Compile all the python files.
+    compileall.compile_dir("renpy/", ddir="renpy/", force=1)
+
+    # os.environ['RENPY_PATH_ELIDE'] = '/home/tom/ab/renpy:' + prefix
 
     # Chmod the mac app.
     os.chmod("./renpy.app/Contents/MacOS/Ren'Py Launcher", 0755)
@@ -150,7 +173,7 @@ def main():
     files = [ ]
     more_files = [ ]
 
-    files.append("CHANGELOG.txt")
+    # files.append("CHANGELOG.txt")
     files.append("LICENSE.txt")
     files.extend(tree("common"))
     files.extend(tree("launcher"))
@@ -162,12 +185,14 @@ def main():
     more_files.extend(tree("lib/linux-x86"))
     
     module_files = [
-        "*.c",
-        "*.h",
-        "*.py",
-        "*.pyx",
         "README.txt",
-        "lib/pysdlsound/*.py",
+        "*.c",
+        "gen/*.c",
+        "*.h",
+        "*.py*",
+        "include/*.pxd",
+        "pysdlsound/*.py",
+        "pysdlsound/*.pyx",
         ]
 
     for i in module_files:
@@ -190,38 +215,42 @@ def main():
     files.sort()
     more_files.sort()
 
-    # zipup("dists/" + prefix + "-win32.zip", prefix, files)
-    # print "----"
+    for fn in files + more_files:
+        if "~" in fn or "#" in fn:
+            raise Exception("Bad filename {0}.".format(fn))
+
     zipup("dists/" + prefix + "-sdk.zip", prefix, files + more_files)
-    print "----"
-    tarup("dists/" + prefix + "-sdk.tar.bz2", prefix, files + more_files)
-    print "----"
-    tarup("dists/" + prefix + "-source.tar.bz2", prefix, files)
-    print "----"
 
-    # Make the 7zip.
-    os.chdir("dists")
-    os.system("unzip " + prefix + "-sdk.zip")
+    if not args.fast:
+        print "----"
+        tarup("dists/" + prefix + "-sdk.tar.bz2", prefix, files + more_files)
+        print "----"
+        tarup("dists/" + prefix + "-source.tar.bz2", prefix, files)
+        print "----"
 
-    try:
+        # Make the 7zip.
+        os.chdir("dists")
+        os.system("unzip " + prefix + "-sdk.zip")
+    
+        try:
+            os.unlink(prefix + "-sdk.7z")
+        except:
+            pass
+    
+        os.system("7z a " + prefix + "-sdk.7z " + prefix)
+        os.system("cat ../7z.sfx " + prefix + "-sdk.7z > " + prefix + "-sdk.7z.exe""")
         os.unlink(prefix + "-sdk.7z")
-    except:
-        pass
-
-    os.system("7z a " + prefix + "-sdk.7z " + prefix)
-    os.system("cat ../7z.sfx " + prefix + "-sdk.7z > " + prefix + "-sdk.7z.exe""")
-    os.unlink(prefix + "-sdk.7z")
-
-    os.chdir("..")
-
-    if os.path.exists("updates/prerelease"):
-        shutil.rmtree("updates/prerelease")
-
-    os.rename("dists/" + prefix, "updates/prerelease")
-    os.unlink("updates/prerelease/lib/update-version.txt")
-
-    makeupdate.make_update("updates/prerelease", revno)
-
+    
+        os.chdir("..")
+    
+        if os.path.exists("updates/prerelease"):
+            shutil.rmtree("updates/prerelease")
+    
+        os.rename("dists/" + prefix, "updates/prerelease")
+        os.unlink("updates/prerelease/lib/update-version.txt")
+    
+        makeupdate.make_update("updates/prerelease", str(revno))
+    
     os.chmod("renpy.py", 0755)
 
     print

launcher/EasyDialogsWin.py

@@ -1,3 +1,4 @@
+#@PydevCodeAnalysisIgnore
 """Easy to use dialogs.
 
 Message(msg) -- display a message and an OK button.

launcher/change_icon.py

@@ -42,7 +42,7 @@ class BinFile(object):
         c = self.u16()
 
         rv = u""
-        for i in range(c):
+        for _i in range(c):
             rv += unichr(self.u16())
 
         return rv
@@ -78,7 +78,7 @@ def parse_data(bf, offset):
     l = [ ]
 
     bf.seek(data_offset - resource_virtual)
-    for i in range(data_len):
+    for _i in range(data_len):
         l.append(chr(bf.u8()))
 
     return (code_page, "".join(l))
@@ -87,16 +87,16 @@ def parse_data(bf, offset):
 def parse_directory(bf, offset):
 
     bf.seek(offset)
-    char = bf.u32()
-    timedate = bf.u32()
-    major = bf.u16()
-    minor = bf.u16()
+    char = bf.u32() #@UnusedVariable
+    timedate = bf.u32() #@UnusedVariable
+    major = bf.u16() #@UnusedVariable
+    minor = bf.u16() #@UnusedVariable
     n_named = bf.u16()
     n_id = bf.u16()
 
     entries = [ ]
     
-    for i in range(n_named + n_id):
+    for _i in range(n_named + n_id):
         entries.append((bf.u32(), bf.u32()))
 
     rv = { }

launcher/distribute.py

@@ -1,4 +1,3 @@
-import os
 import os.path
 import zipfile
 import tarfile
@@ -373,7 +372,7 @@ def distribute(
          extension is allowed by the game.
          """
 
-        for a, b in multi_files:
+        for _a, b in multi_files:
             if b == "/game/" + fn:
                 return
 
@@ -398,8 +397,9 @@ def distribute(
         win_files.append((rb + "Microsoft.VC90.CRT.manifest", "/Microsoft.VC90.CRT.manifest"))
 
         win_files.append((rb + "lib", "/lib"))
+        win_files.append((rb + "lib/dxwebsetup.exe", "/lib/dxwebsetup.exe"))
         win_files.extend(tree(rb + "lib/windows-x86", "/lib/windows-x86"))
-
+        
         if os.path.exists(project_path + "/icon.ico"):
             file_data[rb + "renpy.exe"] = change_icon.change_icons(
                 rb + "renpy.exe",

launcher/options.rpy

@@ -103,6 +103,9 @@ init -1 python hide:
     # Disable opengl.
     config.gl_enable = False
     
+    # Disable logging.
+    config.log_enable = False
+    
 python early:
     config.save_directory = "launcher-2"
 
@@ -130,3 +133,4 @@ init -1 python hide:
     config.window_icon = "logo.png"
     config.windows_icon = "logo32.png"
     
+    config.new_substitutions = False

launcher/pefile.py

@@ -1,3 +1,5 @@
+#@PydevCodeAnalysisIgnore
+
 """pefile, Portable Executable reader module
 
 
@@ -25,11 +27,9 @@ __version__ = '1.2.10-%d' % int( __revision__[21:-2] )
 __contact__ = 'ero@dkbza.org'
 
 
-import os
 import struct
 import time
 import math
-import re
 import exceptions
 import string
 import array
@@ -844,9 +844,10 @@ class SectionStructure(Structure):
         """Check whether the section contains the file offset provided."""
         
         if not self.PointerToRawData:
-           # bss and other sections containing only uninitialized data must have 0
-           # and do not take space in the file
-           return False
+            # bss and other sections containing only uninitialized data must have 0
+            # and do not take space in the file
+            return False
+        
         return self.PointerToRawData <= offset < self.PointerToRawData + self.SizeOfRawData
     
     
@@ -3183,7 +3184,7 @@ class PE:
         try:
             # If the RVA is invalid all would blow up. Some EXEs seem to be
             # specially nasty and have an invalid RVA.
-            data = self.get_data(rva, 2)
+            self.get_data(rva, 2)
         except PEFormatError, e:
             return None
         

launcher/posixpath.py

@@ -1,3 +1,4 @@
+#@PydevCodeAnalysisIgnore
 """Common operations on Posix pathnames.
 
 Instead of importing this module directly, import os and refer to

launcher/script_version.rpy

@@ -1,3 +1,4 @@
 init -999:
-    $ config.script_version = (6, 12, 0)
+    $ config.script_version = (6, 13, 7)
+
     

launcher/themes_data.rpy

@@ -5,8 +5,13 @@ init 1 python:
         ("Roundrect", "roundrect", "Basic Blue"),
         ("Bordered", "bordered", "Dramatic Flesh"),
         ("Diamond", "diamond", "Colorblind"),
-        ("TV", "tv", "Fine China"),
+        ("Regal", "regal", "Fine China"),
+        ("Austen", "austen", "White Chocolate"),
+        ("TV", "tv", "Old Polaroid"),
+        ("3D", "threeD", "Colorblind"),
         ("Glow", "glow", "Really Red"),
+        ("Marker", "marker", "Creamsicle"),
+        ("Crayon", "crayon", "First Valentines"),
         ]
 
     # This is a map from theme function to template text that sensibly calls
@@ -65,6 +70,11 @@ init 1 python:
     theme_templates["diamond"] = theme_templates["roundrect"].replace("roundrect", "diamond")
     theme_templates["tv"] = theme_templates["roundrect"].replace("roundrect", "tv")
     theme_templates["glow"] = theme_templates["roundrect"].replace("roundrect", "glow")
+    theme_templates["regal"] = theme_templates["roundrect"].replace("roundrect", "regal")
+    theme_templates["crayon"] = theme_templates["roundrect"].replace("roundrect", "crayon")
+    theme_templates["threeD"] = theme_templates["roundrect"].replace("roundrect", "threeD")
+    theme_templates["marker"] = theme_templates["roundrect"].replace("roundrect", "marker")
+    theme_templates["austen"] = theme_templates["roundrect"].replace("roundrect", "austen")
     
     # This is a map from theme name to the code needed to implement that
     # theme.
@@ -288,5 +298,177 @@ init 1 python:
                         'widget': '#7AA27B',
                         'widget_hover': '#A3C7A3',
                         'widget_selected': '#ffffff',
-                        'widget_text': '#CDE0CE'}}
+                        'widget_text': '#CDE0CE'},
+       'Mint Chocolate': {'disabled': '#ffe69c',
+                       'disabled_text': '#ddbc7e',
+                       'frame': '#8ab395',
+                       'gm_root': '#7a4229',
+                       'label': '#7a4229',
+                       'mm_root': '#7a4229',
+                       'widget': '#ffe69c',
+                       'widget_hover': '#f5c153',
+                       'widget_selected': '#7a4229',
+                       'widget_text': '#b5743a'},
+       'Parachute Pants': {'disabled': '#53c7bb',
+                       'disabled_text': '#97d7bd',
+                       'frame': '#457b9f',
+                       'gm_root': '#37397f',
+                       'label': '#cce2ae',
+                       'mm_root': '#37397f',
+                       'widget': '#53c7bb',
+                       'widget_hover': '#97d7bd',
+                       'widget_selected': '#37397f',
+                       'widget_text': '#457b9f'},
+       'Strawberry Orchard': {'disabled': '#b3c292',
+                       'disabled_text': '#525748',
+                       'frame': '#d8ebae',
+                       'gm_root': '#e7f3cb',
+                       'label': '#525748',
+                       'mm_root': '#e7f3cb',
+                       'widget': '#525748',
+                       'widget_hover': '#f45c73',
+                       'widget_selected': '#ffce95',
+                       'widget_text': '#e7f3cb'},
+       'Grape Jelly': {'disabled': '#81859a',
+                       'disabled_text': '#5e2862',
+                       'frame': '#8ea9b0',
+                       'gm_root': '#5e2862',
+                       'label': '#ffffff',
+                       'mm_root': '#5e2862',
+                       'widget': '#c45693',
+                       'widget_hover': '#5e2862',
+                       'widget_selected': '#e59eae',
+                       'widget_text': '#ffffff'},
+       'Dreamscape': {'disabled': '#966077',
+                       'disabled_text': '#c75f77',
+                       'frame': '#836177',
+                       'gm_root': '#c75f77',
+                       'label': '#fefab6',
+                       'mm_root': '#c75f77',
+                       'widget': '#77a493',
+                       'widget_hover': '#8accb3',
+                       'widget_selected': '#c75f77',
+                       'widget_text': '#ffffff'},
+       'Unrequited Love': {'disabled': '#dbe4dd',
+                       'disabled_text': '#bd9ca9',
+                       'frame': '#fffeed',
+                       'gm_root': '#b38698',
+                       'label': '#23000e',
+                       'mm_root': '#b38698',
+                       'widget': '#7fa1b3',
+                       'widget_hover': '#b38698',
+                       'widget_selected': '#fffeed',
+                       'widget_text': '#ffffff'},
+    
+       'Watermellon': {'disabled': '#f9cdad',
+                       'disabled_text': '#fc9d9a',
+                       'frame': '#f9cdad',
+                       'gm_root': '#83af9b',
+                       'label': '#fe4365',
+                       'mm_root': '#83af9b',
+                       'widget': '#fc9d9a',
+                       'widget_hover': '#fe4365',
+                       'widget_selected': '#e5fcc2',
+                       'widget_text': '#ffffff'},
+       'City Lights': {'disabled': '#638e89',
+                       'disabled_text': '#594f4f',
+                       'frame': '#547980',
+                       'gm_root': '#594f4f',
+                       'label': '#e5fcc2',
+                       'mm_root': '#594f4f',
+                       'widget': '#45ada8',
+                       'widget_hover': '#2e5860',
+                       'widget_selected': '#e5fcc2',
+                       'widget_text': '#9de0ad'},
+       'Vampire Bite': {'disabled': '#971140',
+                       'disabled_text': '#bd4b40',
+                       'frame': '#bd1550',
+                       'gm_root': '#490a3d',
+                       'label': '#f8ca00',
+                       'mm_root': '#490a3d',
+                       'widget': '#e97f02',
+                       'widget_hover': '#f5a240',
+                       'widget_selected': '#490a3d',
+                       'widget_text': '#bd1550'},
+        'Underground Rave': {'disabled': '#57cdff',
+                       'disabled_text': '#717be5',
+                       'frame': '#04b4ff',
+                       'gm_root': '#cd249b',
+                       'label': '#000000',
+                       'mm_root': '#cd249b',
+                       'widget': '#8833ce',
+                       'widget_hover': '#cd249b',
+                       'widget_selected': '#b6d754',
+                       'widget_text': '#000000'},
+       'Tree Frog': {'disabled': '#ffffff',
+                       'disabled_text': '#1c140d',
+                       'frame': '#cbe86b',
+                       'gm_root': '#ffffff',
+                       'label': '#1c140d',
+                       'mm_root': '#ffffff',
+                       'widget': '#1c140d',
+                       'widget_hover': '#86827e',
+                       'widget_selected': '#f2e9e1',
+                       'widget_text': '#cbe86b'},
+       'Sun Kissed': {'disabled': '#ffffff',
+                       'disabled_text': '#ec4c51',
+                       'frame': '#f0874d',
+                       'gm_root': '#f8c821',
+                       'label': '#ffffff',
+                       'mm_root': '#f8c821',
+                       'widget': '#ec4c51',
+                       'widget_hover': '#dc454a',
+                       'widget_selected': '#f8c821',
+                       'widget_text': '#ffffff'},
+       'Vintage Faded': {'disabled': '#b17d6f',
+                       'disabled_text': '#8c4e3d',
+                       'frame': '#ab7464',
+                       'gm_root': '#935844',
+                       'label': '#f7d3c8',
+                       'mm_root': '#935844',
+                       'widget': '#8c4e3d',
+                       'widget_hover': '#734032',
+                       'widget_selected': '#fcf5ed',
+                       'widget_text': '#e2b9ad'},
+       'Vintage': {'disabled': '#883e35',
+                       'disabled_text': '#b86258',
+                       'frame': '#b86258',
+                       'gm_root': '#a24637',
+                       'label': '#ffffff',
+                       'mm_root': '#a24637',
+                       'widget': '#6c2921',
+                       'widget_hover': '#832f26',
+                       'widget_selected': '#ffc7c0',
+                       'widget_text': '#fff4eb'},
+       'Earth Tones': {'disabled': '#12612f',
+                       'disabled_text': '#2c6e44',
+                       'frame': '#00551f',
+                       'gm_root': '#6b4a27',
+                       'label': '#ffffff',
+                       'mm_root': '#568153',
+                       'widget': '#ad8c31',
+                       'widget_hover': '#568153',
+                       'widget_selected': '#f2edc4',
+                       'widget_text': '#ffffff'},
+       'Kindergarten': {'disabled': '#1ca4b2',
+                       'disabled_text': '#22d5b3',
+                       'frame': '#22d5b3',
+                       'gm_root': '#ffeca6',
+                       'label': '#ffffff',
+                       'mm_root': '#ffeca6',
+                       'widget': '#1781b1',
+                       'widget_hover': '#12678e',
+                       'widget_selected': '#f2edc4',
+                       'widget_text': '#fdfbee'},
+       'Phone Operator': {'disabled': '#929292',
+                       'disabled_text': '#ababab',
+                       'frame': '#d2d2d2',
+                       'gm_root': '#59667a',
+                       'label': '#343e4d',
+                       'mm_root': '#59667a',
+                       'widget': '#59667a',
+                       'widget_hover': '#343e4d',
+                       'widget_selected': '#bed4f6',
+                       'widget_text': '#ffffff'},
+                        }
 

launcher/updater.rpy

@@ -1,5 +1,6 @@
 init python:
 
+    import urllib
     import urllib2
     import bz2
     import os
@@ -71,6 +72,7 @@ init python:
             bz = os.path.join(self.local, relative + ".new.bz2")
             new = os.path.join(self.local, relative + ".new")
 
+            relative = urllib.quote(relative)
             url = self.remote + "/" + relative + ".bz2"
             
             try:

makeupdate.py

@@ -6,9 +6,10 @@ sys.path.append('/home/tom/ab/keys/')
 import os
 import bz2
 import hashlib
-import public
-import private
+import public #@UnresolvedImport
+import private #@UnresolvedImport
 import shutil
+import time
 
 def sha(s):
     """
@@ -40,6 +41,8 @@ def make_update(root, version):
             
     for dir, dirs, files in os.walk(root):
 
+        all = set(dirs + files)
+
         for fn in dirs + files:
 
             path = os.path.join(dir, fn)
@@ -58,7 +61,7 @@ def make_update(root, version):
             elif relpath.endswith(".rpyb.bz2"):
                 continue            
 
-            elif relpath.endswith(".pyo.bz2"):
+            elif relpath.endswith(".pyo.bz2") and relpath.replace(".pyo", ".py") in all:
                 continue            
                 
             elif relpath.endswith(".bz2"):
@@ -89,7 +92,7 @@ def make_update(root, version):
     out.close()
 
     f = file(os.path.join(root, "version"), "w")
-    f.write(version)
+    f.write(version + "-" + str(time.time()))
     f.write("\n")
     f.write("the latest Ren'Py pre-release")
     f.close()