menus.templatetags.menu_tags: 231 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/menus/templatetags/menu_tags.py

Stats: 0 executed, 220 missed, 11 excluded, 152 ignored

1. # -*- coding: utf-8 -*-
2. from classytags.arguments import IntegerArgument, Argument, StringArgument
3. from classytags.core import Options
4. from classytags.helpers import InclusionTag
5. from django import template
6. from django.conf import settings
7. from django.contrib.sites.models import Site
8. from django.core.cache import cache
9. from django.core.urlresolvers import reverse
10. from django.utils.translation import activate, get_language, ugettext
11. from menus.menu_pool import menu_pool
12. import urllib
14. register = template.Library()
17. class NOT_PROVIDED: pass
20. def cut_after(node, levels, removed):
21. """
22. given a tree of nodes cuts after N levels
23. """
24. if levels == 0:
25. removed.extend(node.children)
26. node.children = []
27. else:
28. removed_local = []
29. for child in node.children:
30. if child.visible:
31. cut_after(child, levels - 1, removed)
32. else:
33. removed_local.append(child)
34. for removed_child in removed_local:
35. node.children.remove(removed_child)
36. removed.extend(removed_local)
38. def remove(node, removed):
39. removed.append(node)
40. if node.parent:
41. if node in node.parent.children:
42. node.parent.children.remove(node)
44. def cut_levels(nodes, from_level, to_level, extra_inactive, extra_active):
45. """
46. cutting nodes away from menus
47. """
48. final = []
49. removed = []
50. selected = None
51. for node in nodes:
52. if not hasattr(node, 'level'):
53. # remove and ignore nodes that don't have level information
54. remove(node, removed)
55. continue
56. if node.level == from_level:
57. # turn nodes that are on from_level into root nodes
58. final.append(node)
59. node.parent = None
60. if not node.ancestor and not node.selected and not node.descendant:
61. # cut inactive nodes to extra_inactive, but not of descendants of
62. # the selected node
63. cut_after(node, extra_inactive, removed)
64. if node.level > to_level and node.parent:
65. # remove nodes that are too deep, but not nodes that are on
66. # from_level (local root nodes)
67. remove(node, removed)
68. if node.selected:
69. selected = node
70. if not node.visible:
71. remove(node, removed)
72. if selected:
73. cut_after(selected, extra_active, removed)
74. if removed:
75. for node in removed:
76. if node in final:
77. final.remove(node)
78. return final
80. def flatten(nodes):
81. flat = []
82. for node in nodes:
83. flat.append(node)
84. flat.extend(flatten(node.children))
85. return flat
88. class ShowMenu(InclusionTag):
89. """
90. render a nested list of all children of the pages
91. - from_level: starting level
92. - to_level: max level
93. - extra_inactive: how many levels should be rendered of the not active tree?
94. - extra_active: how deep should the children of the active node be rendered?
95. - namespace: the namespace of the menu. if empty will use all namespaces
96. - root_id: the id of the root node
97. - template: template used to render the menu
98. """
99. name = 'show_menu'
100. template = 'menu/dummy.html'
102. options = Options(
103. IntegerArgument('from_level', default=0, required=False),
104. IntegerArgument('to_level', default=100, required=False),
105. IntegerArgument('extra_inactive', default=0, required=False),
106. IntegerArgument('extra_active', default=1000, required=False),
107. StringArgument('template', default='menu/menu.html', required=False),
108. StringArgument('namespace', default=None, required=False),
109. StringArgument('root_id', default=None, required=False),
110. Argument('next_page', default=None, required=False),
111. )
113. def get_context(self, context, from_level, to_level, extra_inactive,
114. extra_active, template, namespace, root_id, next_page):
115. try:
116. # If there's an exception (500), default context_processors may not be called.
117. request = context['request']
118. except KeyError:
119. return {'template': 'menu/empty.html'}
121. if next_page:
122. children = next_page.children
123. else:
124. #new menu... get all the data so we can save a lot of queries
125. nodes = menu_pool.get_nodes(request, namespace, root_id)
126. if root_id: # find the root id and cut the nodes
127. id_nodes = menu_pool.get_nodes_by_attribute(nodes, "reverse_id", root_id)
128. if id_nodes:
129. node = id_nodes[0]
130. nodes = node.children
131. for remove_parent in nodes:
132. remove_parent.parent = None
133. from_level += node.level + 1
134. to_level += node.level + 1
135. nodes = flatten(nodes)
136. else:
137. nodes = []
138. children = cut_levels(nodes, from_level, to_level, extra_inactive, extra_active)
139. children = menu_pool.apply_modifiers(children, request, namespace, root_id, post_cut=True)
141. try:
142. context.update({'children':children,
143. 'template':template,
144. 'from_level':from_level,
145. 'to_level':to_level,
146. 'extra_inactive':extra_inactive,
147. 'extra_active':extra_active,
148. 'namespace':namespace})
149. except:
150. context = {"template":template}
151. return context
152. register.tag(ShowMenu)
155. class ShowMenuBelowId(ShowMenu):
156. name = 'show_menu_below_id'
157. options = Options(
158. Argument('root_id', default=None, required=False),
159. IntegerArgument('from_level', default=0, required=False),
160. IntegerArgument('to_level', default=100, required=False),
161. IntegerArgument('extra_inactive', default=0, required=False),
162. IntegerArgument('extra_active', default=1000, required=False),
163. Argument('template', default='menu/menu.html', required=False),
164. Argument('namespace', default=None, required=False),
165. Argument('next_page', default=None, required=False),
166. )
167. register.tag(ShowMenuBelowId)
170. class ShowSubMenu(InclusionTag):
171. """
172. show the sub menu of the current nav-node.
173. - levels: how many levels deep
174. - template: template used to render the navigation
175. """
176. name = 'show_sub_menu'
177. template = 'menu/dummy.html'
179. options = Options(
180. IntegerArgument('levels', default=100, required=False),
181. Argument('template', default='menu/sub_menu.html', required=False),
182. )
184. def get_context(self, context, levels, template):
185. try:
186. # If there's an exception (500), default context_processors may not be called.
187. request = context['request']
188. except KeyError:
189. return {'template': 'menu/empty.html'}
190. nodes = menu_pool.get_nodes(request)
191. children = []
192. for node in nodes:
193. if node.selected:
194. cut_after(node, levels, [])
195. children = node.children
196. for child in children:
197. child.parent = None
198. children = menu_pool.apply_modifiers(children, request, post_cut=True)
199. context.update({
200. 'children':children,
201. 'template':template,
202. 'from_level':0,
203. 'to_level':0,
204. 'extra_inactive':0,
205. 'extra_active':0
206. })
207. return context
208. register.tag(ShowSubMenu)
211. class ShowBreadcrumb(InclusionTag):
212. """
213. Shows the breadcrumb from the node that has the same url as the current request
215. - start level: after which level should the breadcrumb start? 0=home
216. - template: template used to render the breadcrumb
217. """
218. name = 'show_breadcrumb'
219. template = 'menu/dummy.html'
221. options = Options(
222. Argument('start_level', default=0, required=False),
223. Argument('template', default='menu/breadcrumb.html', required=False),
224. Argument('only_visible', default=True, required=False),
225. )
227. def get_context(self, context, start_level, template, only_visible):
228. try:
229. # If there's an exception (500), default context_processors may not be called.
230. request = context['request']
231. except KeyError:
232. return {'template': 'cms/content.html'}
233. if not (isinstance(start_level, int) or start_level.isdigit()):
234. only_visible = template
235. template = start_level
236. start_level = 0
237. try:
238. only_visible = bool(int(only_visible))
239. except:
240. only_visible = bool(only_visible)
241. ancestors = []
242. nodes = menu_pool.get_nodes(request, breadcrumb=True)
243. selected = None
244. home = None
245. for node in nodes:
246. if node.selected:
247. selected = node
248. if node.get_absolute_url() == urllib.unquote(reverse("pages-root")):
249. home = node
250. if selected and selected != home:
251. node = selected
252. while node:
253. if node.visible or not only_visible:
254. ancestors.append(node)
255. node = node.parent
256. if not ancestors or (ancestors and ancestors[-1] != home) and home:
257. ancestors.append(home)
258. ancestors.reverse()
259. if len(ancestors) >= start_level:
260. ancestors = ancestors[start_level:]
261. else:
262. ancestors = []
263. context.update({'ancestors':ancestors,
264. 'template': template})
265. return context
266. register.tag(ShowBreadcrumb)
269. def _raw_language_marker(language, lang_code):
270. return language
272. def _native_language_marker(language, lang_code):
273. activate(lang_code)
274. return unicode(ugettext(language))
276. def _current_language_marker(language, lang_code):
277. return unicode(ugettext(language))
279. def _short_language_marker(language, lang_code):
280. return lang_code
282. MARKERS = {
283. 'raw': _raw_language_marker,
284. 'native': _native_language_marker,
285. 'current': _current_language_marker,
286. 'short': _short_language_marker,
287. }
289. class LanguageChooser(InclusionTag):
290. """
291. Displays a language chooser
292. - template: template used to render the language chooser
293. """
294. name = 'language_chooser'
295. template = 'menu/dummy.html'
297. options = Options(
298. Argument('template', default=NOT_PROVIDED, required=False),
299. Argument('i18n_mode', default='raw', required=False),
300. )
302. def get_context(self, context, template, i18n_mode):
303. if template in MARKERS:
304. _tmp = template
305. if i18n_mode not in MARKERS:
306. template = i18n_mode
307. else:
308. template = NOT_PROVIDED
309. i18n_mode = _tmp
310. if template is NOT_PROVIDED:
311. template = "menu/language_chooser.html"
312. if not i18n_mode in MARKERS:
313. i18n_mode = 'raw'
314. if 'request' not in context:
315. # If there's an exception (500), default context_processors may not be called.
316. return {'template': 'cms/content.html'}
317. marker = MARKERS[i18n_mode]
318. cms_languages = dict(settings.CMS_LANGUAGES)
319. current_lang = get_language()
320. site = Site.objects.get_current()
321. site_languages = settings.CMS_SITE_LANGUAGES.get(site.pk, cms_languages.keys())
322. cache_key = '%s-language-chooser-%s-%s-%s' % (settings.CMS_CACHE_PREFIX, site.pk, current_lang, i18n_mode)
323. languages = cache.get(cache_key, [])
324. if not languages:
325. for lang in settings.CMS_FRONTEND_LANGUAGES:
326. if lang in cms_languages and lang in site_languages:
327. languages.append((lang, marker(cms_languages[lang], lang)))
328. if current_lang != get_language():
329. activate(current_lang)
330. cache.set(cache_key, languages)
331. lang = get_language()
332. context.update({
333. 'languages':languages,
334. 'current_language':lang,
335. 'template':template,
336. })
337. return context
338. register.tag(LanguageChooser)
341. class PageLanguageUrl(InclusionTag):
342. """
343. Displays the url of the current page in the defined language.
344. You can set a language_changer function with the set_language_changer function in the utils.py if there is no page.
345. This is needed if you have slugs in more than one language.
346. """
347. name = 'page_language_url'
348. template = 'cms/content.html'
350. options = Options(
351. Argument('lang'),
352. )
354. def get_context(self, context, lang):
355. try:
356. # If there's an exception (500), default context_processors may not be called.
357. request = context['request']
358. except KeyError:
359. return {'template': 'cms/content.html'}
360. if hasattr(request, "_language_changer"):
361. try:
362. setattr(request._language_changer, 'request', request)
363. except AttributeError:
364. pass
365. url = "/%s" % lang + request._language_changer(lang)
366. else:
367. page = request.current_page
368. if page == "dummy":
369. return {'content': ''}
370. try:
371. url = page.get_absolute_url(language=lang, fallback=False)
372. url = "/" + lang + url
373. except:
374. # no localized path/slug
375. if settings.CMS_HIDE_UNTRANSLATED:
376. # redirect to root url if CMS_HIDE_UNTRANSLATED
377. url = '/' + lang + '/'
378. else:
379. # If untranslated pages are shown, this will not redirect
380. # at all.
381. url = ''
382. return {'content':url}
383. register.tag(PageLanguageUrl)