On Mon, 2006-09-18 at 18:38 +0000, [EMAIL PROTECTED] wrote:
> I am new to Django, and forgive me if this is a question that has
> already been answered, but I can not seem to find the "official"
> answer. I will explain what I am trying to figure out with an example.
>
> I am building a wiki, I have a number of views which show a wiki page,
> edit a wiki page, save a wiki page..... I want on the page that shows
> a wiki page contents, to also have a listing of all wiki pages for the
> wiki. Essentially I want data from two different views on the same
> page, but I don't want to couple the code.
>
> Looking through the groups and some blogs I seem to keep finding two
> things:
>
> 1. Template Tags
> 2. "nested" templates (base template with blocks for using other
> templates).
>
> If someone could point me in the right direction for this I would
> appreciate it.
There are probably a few ways to view the conceptual difference between
these two things. For the question you are asking, the right answer is a
custom template tag, but let me try and answer the bigger question. This
may get long...
For any request, there is one view function that is responsible for
initially receiving the request (via the URL dispatcher) and doing all
the processing. However that view works, it often ends up creating a
context and a template and then rendering the template using the context
to fill in the variable bits before returning the result to the client.
Now, as you probably realise, many pages share a lot in common and so
Django provides a way to "inherit" the common pieces from other (parent)
templates. This is what template extension is about. You put the common
pieces into a base template (say, base.html) and then your template for
the specific page you are rendering has
{% extends "base.html" %}
at the top and can then override pieces of base.html. Note that in this
case, the template you are rendering can *only* override blocks from
base.html, it cannot create new blocks outside of the structure of
base.html (although you can create blocks inside of other, existing
blocks). So your base.html will usually (but not always) have something
like
{% block content %}{% endblock %}
and every template that extends base.html then overrides the "content"
block to put whatever they like in there, instead of leaving it empty or
at the default value.
So template extension is a way to factor out the common pieces of a
template
Custom template tags, on the other hand are a way to essentially call on
some arbitrary piece of code you have written to perform whatever work
you like and return a string back to the calling template. So if you
want to include the results of some computation in your template that is
worked out at rendering time, you can use a template tag to do the work.
For example, in your wiki case, you will have a page template for
displaying the content and it can include a tag called something like {%
get_all_pages %}. The "get_all_pages" tag just works out the names of
all the pages in your wiki and returns a string that is, say, an HTML
list that can be dropped into the template in place of the tag. That is
how you get your list of pages.
It is possible for a template tag to be passed the context being used to
render the page, so it can do some context-dependent work. This might be
useful if, say, you wanted to only display pages that were linked from
the current page.
Another way to view the difference here is that templates can only work
with whatever are passed in via the context at rendering time. Template
tags, on the other hand, can work with the context plus any other
information they like, since they are pieces of Python code that have
full access to your models and the entire world of Python libraries. So
you could get away without using template tags at all -- and this is how
many people start out -- by passing in a list of all pages in the
context to your template and then displaying it via loops, etc. However,
that means you have to remember to call the "generate list of all pages"
function in each view and pass it in, whereas the template tag approach
allows the page designer to decide when they want that information and
drop in the appropriate tag in the right place when required.
Does any of the above answer your question, or just make your head
explode? I was aiming for the former, honest. :-)
Regards,
Malcolm
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-users
-~----------~----~----~----~------~----~------~--~---
