i18n: merged r722:774 from trunk

git-svn-id: http://code.djangoproject.com/svn/django/branches/i18n@775 bcc190cf-cafb-0310-a4f2-bffc1f526a37

8 files changed, 128 insertions, 13 deletions

diff --git a/docs/db-api.txt b/docs/db-api.txt
index 4c49a2760f..e0885da8f0 100644
--- a/docs/db-api.txt
+++ b/docs/db-api.txt
@@ -524,7 +524,7 @@ model with an ``ImageField`` will also get this method.
 get_FOO_url()
 -------------
 
-For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
+For every ``FileField``, the object will have a ``get_FOO_url()`` method,
 where ``FOO`` is the name of the field. This returns the full URL to the file,
 according to your ``MEDIA_URL`` setting. If the value is blank, this method
 returns an empty string.
diff --git a/docs/model-api.txt b/docs/model-api.txt
index 918f4eb5db..4af193ca48 100644
--- a/docs/model-api.txt
+++ b/docs/model-api.txt
@@ -248,7 +248,28 @@ Here are all available field types:
     uploaded files don't fill up the given directory).
 
     The admin represents this as an ``<input type="file">`` (a file-upload widget).
+    
+    Using a `FieldField` or an ``ImageField`` (see below) in a model takes a few 
+    steps:
+    
+        1. In your settings file, you'll need to define ``MEDIA_ROOT``as the
+           full path to a directory where you'd like Django to store uploaded
+           files. (For performance, these files are not stored in the database.)
+           Define ``MEDIA_URL`` as the base public URL of that directory. Make
+           sure that this directory is writable by the Web server's user
+           account.
+        
+        2. Add the ``FileField`` or ``ImageField`` to your model, making sure 
+           to define the ``upload_to`` option to tell Django to which
+           subdirectory of ``MEDIA_ROOT`` it should upload files.
 
+        3. All that will be stored in your database is a path to the file
+           (relative to ``MEDIA_ROOT``). You'll must likely want to use the
+           convenience ``get_<fieldname>_url`` function provided by Django. For
+           example, if your ``ImageField`` is called ``mug_shot``, you can get
+           the absolute URL to your image in a template with ``{{
+           object.get_mug_shot_url }}``.
+    
     .. _`strftime formatting`: http://docs.python.org/lib/module-time.html#l2h-1941
 
 ``FloatField``
@@ -281,7 +302,7 @@ Here are all available field types:
     width of the image each time a model instance is saved.
 
     Requires the `Python Imaging Library`_.
-
+    
     .. _Python Imaging Library: http://www.pythonware.com/products/pil/
 
 ``IntegerField``
diff --git a/docs/modpython.txt b/docs/modpython.txt
index 72c2d9a073..acac50a6d5 100644
--- a/docs/modpython.txt
+++ b/docs/modpython.txt
@@ -29,8 +29,8 @@ Then edit your ``httpd.conf`` file and add the following::
         PythonDebug On
     </Location>
 
-...and replace ``myproject.settings.main`` with the path to your settings file,
-in dotted-package syntax.
+...and replace ``myproject.settings.main`` with the Python path to your
+settings file.
 
 This tells Apache: "Use mod_python for any URL at or under '/mysite/', using the
 Django mod_python handler." It passes the value of ``DJANGO_SETTINGS_MODULE``
diff --git a/docs/outputting_pdf.txt b/docs/outputting_pdf.txt
new file mode 100644
index 0000000000..bd209b2e90
--- /dev/null
+++ b/docs/outputting_pdf.txt
@@ -0,0 +1,90 @@
+===========================
+Outputting PDFs with Django
+===========================
+
+This document explains how to output PDF files dynamically using Django views.
+This is made possible by the excellent, open-source ReportLab_ Python PDF
+library.
+
+The advantage of generating PDF files dynamically is that you can create
+customized PDFs for different purposes -- say, for different users or different
+pieces of content.
+
+For example, Django was used at kusports.com to generate customized,
+printer-friendly NCAA tournament brackets, as PDF files, for people
+participating in a March Madness contest.
+
+.. _ReportLab: http://www.reportlab.org/rl_toolkit.html
+
+Install ReportLab
+=================
+
+Download and install the ReportLab library from http://www.reportlab.org/downloads.html.
+The `user guide`_ (not coincidentally, a PDF file) explains how to install it.
+
+Test your installation by importing it in the Python interactive interpreter::
+
+    >>> import reportlab
+
+If that command doesn't raise any errors, the installation worked.
+
+.. _user guide: http://www.reportlab.org/rsrc/userguide.pdf
+
+Write your view
+===============
+
+The key to generating PDFs dynamically with Django is that the ReportLab API
+acts on file-like objects, and Django's ``HttpResponse`` objects are file-like
+objects.
+
+.. admonition:: Note
+
+    For more information on ``HttpResponse`` objects, see
+    `Request and response objects`_.
+
+    .. _Request and response objects: http://www.djangoproject.com/documentation/request_response/
+
+Here's a "Hello World" example::
+
+    from reportlab.pdfgen import canvas
+    from django.utils.httpwrappers import HttpResponse
+
+    def some_view(request):
+        # Create the HttpResponse object with the appropriate PDF headers.
+        response = HttpResponse(mimetype='application/pdf')
+        response['Content-Disposition'] = 'attachment; filename=somefilename.pdf'
+
+        # Create the PDF object, using the response object as its "file."
+        p = canvas.Canvas(response)
+
+        # Draw things on the PDF. Here's where the PDF generation happens.
+        # See the ReportLab documentation for the full list of functionality.
+        p.drawString(100, 100, "Hello world.")
+
+        # Close the PDF object cleanly, and we're done.
+        p.showPage()
+        p.save()
+        return response
+
+The code and comments should be self-explanatory, but a few things deserve a
+mention:
+
+    * The response gets a special mimetype, ``application/pdf``. This tells
+      browsers that the document is a PDF file, rather than an HTML file. If
+      you leave this off, browsers will probably interpret the output as HTML,
+      which would result in ugly, scary gobbledygook in the browser window.
+
+    * The response gets an additional ``Content-Disposition`` header, which
+      contains the name of the PDF file. This filename is arbitrary: Call it
+      whatever you want. It'll be used by browsers in the "Save as..."
+      dialogue, etc.
+
+    * Hooking into the ReportLab API is easy: Just pass ``response`` as the
+      first argument to ``canvas.Canvas``. The ``Canvas`` class expects a
+      file-like object, and ``HttpResponse`` objects fit the bill.
+
+    * Note that all subsequent PDF-generation methods are called on the PDF
+      object (in this case, ``p``) -- not on ``response``.
+
+    * Finally, it's important to call ``showPage()`` and ``save()`` on the PDF
+      file.
diff --git a/docs/templates.txt b/docs/templates.txt
index 09431c1dda..a6848a9638 100644
--- a/docs/templates.txt
+++ b/docs/templates.txt
@@ -376,6 +376,10 @@ Built-in tag reference
         ==========================  ================================================
         ``forloop.counter``         The current iteration of the loop (1-indexed)
         ``forloop.counter0``        The current iteration of the loop (0-indexed)
+        ``forloop.revcounter``      The number of iterations from the end of the 
+                                    loop (1-indexed)
+        ``forloop.revcounter0``     The number of iterations from the end of the 
+                                    loop (0-indexed)
         ``forloop.first``           True if this is the first time through the loop
         ``forloop.last``            True if this is the last time through the loop
         ``forloop.parentloop``      For nested loops, this is the loop "above" the
diff --git a/docs/templates_python.txt b/docs/templates_python.txt
index 63b734dc44..39b768429b 100644
--- a/docs/templates_python.txt
+++ b/docs/templates_python.txt
@@ -267,7 +267,7 @@ every template automatic access to the current time, use something like this::
 
     from django.core.template import Context
     import datetime
-    class TimeContext(template.Context):
+    class TimeContext(Context):
         def __init__(self, *args, **kwargs):
             Context.__init__(self, *args, **kwargs)
             self['current_time'] = datetime.datetime.now()
diff --git a/docs/tutorial01.txt b/docs/tutorial01.txt
index 629a2ab017..d69afa7392 100644
--- a/docs/tutorial01.txt
+++ b/docs/tutorial01.txt
@@ -385,23 +385,23 @@ Let's jump back into the Python interactive shell::
     # Django provides a rich database lookup API that's entirely driven by
     # keyword arguments.
     >>> polls.get_object(id__exact=1)
-    What's up
+    What's up?
     >>> polls.get_object(question__startswith='What')
-    What's up
+    What's up?
     >>> polls.get_object(pub_date__year=2005)
-    What's up
+    What's up?
     >>> polls.get_object(id__exact=2)
     Traceback (most recent call last):
         ...
     PollDoesNotExist: Poll does not exist for {'id__exact': 2}
     >>> polls.get_list(question__startswith='What')
-    [What's up]
+    [What's up?]
 
     # Lookup by a primary key is the most common case, so Django provides a
     # shortcut for primary-key exact lookups.
     # The following is identical to polls.get_object(id__exact=1).
     >>> polls.get_object(pk=1)
-    What's up
+    What's up?
 
     # Make sure our custom method worked.
     >>> p = polls.get_object(pk=1)
@@ -419,7 +419,7 @@ Let's jump back into the Python interactive shell::
 
     # Choice objects have API access to their related Poll objects.
     >>> c.get_poll()
-    What's up
+    What's up?
 
     # And vice versa: Poll objects get access to Choice objects.
     >>> p.get_choice_list()
diff --git a/docs/tutorial03.txt b/docs/tutorial03.txt
index 2bbd8d7782..84fb64abfe 100644
--- a/docs/tutorial03.txt
+++ b/docs/tutorial03.txt
@@ -91,8 +91,8 @@ Finally, it calls that ``detail()`` function like so::
     detail(request=<HttpRequest object>, poll_id=23)
 
 The ``poll_id=23`` part comes from ``(?P<poll_id>\d+)``. Using
-``(?<name>pattern)`` "captures" the text matched by ``pattern`` and sends it as
-a keyword argument to the view function.
+``(?P<name>pattern)`` "captures" the text matched by ``pattern`` and sends it
+as a keyword argument to the view function.
 
 Because the URL patterns are regular expressions, there really is no limit on
 what you can do with them. And there's no need to add URL cruft such as