Changeset Navigation

← Previous Changeset
Next Changeset →

Changeset 463

Timestamp:

08/14/06 07:44:42

Author:

piv

Message:

added ajax congiglet with necessary functionality (but not sufficient)

Files:

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

qPloneDropDownMenu/branches/0.2/DropDownMenuTool.py

r462	r463
1	1	import os
2
3	2	from cStringIO import StringIO
4	3
5	4	from Globals import InitializeClass
6	5	from Globals import package_home
	6	from Persistence import PersistentMapping
	7	try:
	8	from ZODB.PersistentList import PersistentList
	9	except ImportError:
	10	from persistent.list import PersistentList
	11
7	12	from OFS.SimpleItem import SimpleItem
8	13	from AccessControl import ClassSecurityInfo
…	…
11	16	from Products.CMFCore.utils import getToolByName, UniqueObject
12	17	from Products.CMFCore.Expression import Expression, createExprContext
13
14		from Products.qPloneDropDownMenu.Extensions.Install import updateMenu
15		from config import ~~VIEW_PERMISSION,~~ UNIQUE_ID
	18	from Products.CMFCore.permissions import ManagePortal, View
	19
	20	from config import UNIQUE_ID
16	21
17	22	from zLOG import LOG
…	…
19	24	_wwwdir = os.path.join(package_home(globals()), 'www')
20	25
21		class MenuItem(UniqueObject, SimpleItem):
	26	class MenuItem(SimpleItem):
	27	""" Element for displaying item in portal tab submenu """
22	28
23	29	security = ClassSecurityInfo()
24	30
25		def __init__(self, title, url=None~~, sub_menu=None~~):
26		""" Init """
	31	def __init__(self, title, url=None):
	32	""" Initialize """
27	33	self._title = title
28	34	self._url = url
29		self._~~sub_menu = sub_menu~~
30
31		security.declarePublic( ~~'getTitle'~~ )
	35	self._menu_items = PersistentList()
	36
	37	security.declarePublic('getTitle')
32	38	def getTitle(self):
33	39	""" Simple accessor. """
34	40	return self._title
35	41
36		security.declareProtected(~~VIEW_PERMISSION~~, 'setTitle')
	42	security.declareProtected(ManagePortal, 'setTitle')
37	43	def setTitle(self, title):
38	44	""" Set menu item's title """
…	…
44	50	return self._url
45	51
46		security.declareProtected(~~VIEW_PERMISSION~~, 'setUrl')
	52	security.declareProtected(ManagePortal, 'setUrl')
47	53	def setUrl(self, url):
48	54	""" Set menu item's url """
49	55	self._url = url
50	56
51		security.declarePublic('~~getSubMenu~~')
52		def ~~getSubMenu~~(self):
53		""" ~~Simple accessor~~. """
54		return ~~self._sub_menu or None~~
55
56		security.declareProtected(~~VIEW_PERMISSION~~, 'setSubMenu')
57		def set~~SubMenu(self, sub_menu~~):
	57	security.declarePublic('listMenuItems')
	58	def listMenuItems(self):
	59	"""Get all the menu items in subMenu. """
	60	return [x.__of__(self) for x in self._menu_items] or []
	61
	62	security.declareProtected(ManagePortal, 'setSubMenu')
	63	def setMenuItems(self, items):
58	64	""" Set menu item's subMenu object """
59		self._sub_menu = sub_menu
	65	self._menu_items = PersistentList(items)
	66
	67	security.declareProtected(ManagePortal, 'addItem')
	68	def addItem(self, item):
	69	""" Add MenuItem to _menu_items list """
	70	self._menu_items.append(item)
	71
	72	security.declareProtected(ManagePortal, 'deleteItem')
	73	def deleteItem(self, idx):
	74	""" Delete MenuItem from _menu_items list """
	75	return self._menu_items.pop(idx)
	76
60	77
61	78	InitializeClass(MenuItem)
62
63		~~class subMenu(UniqueObject, SimpleItem):~~
64
65		~~security = ClassSecurityInfo()~~
66
67
68		~~def __init__(self):~~
69		~~""" Init """~~
70		~~self._menu_items = ()~~
71
72		~~security.declarePublic('listMenuItems')~~
73		~~def listMenuItems( self ):~~
74		~~"""Get all the menu items in subMenu. """~~
75		~~return [x.__of__(self) for x in self._menu_items] or ()~~
76
77		~~InitializeClass(subMenu)~~
78	79
79	80	class DropDownMenuTool(UniqueObject, SimpleItem):
…	…
83	84	title="DropDown Menu Tool"
84	85
85		_submenu_mapping = {}
	86	_submenu_mapping = PersistentMapping()
86	87
87	88	security = ClassSecurityInfo()
88	89
89		manage_options = ({ 'label' : 'Sub Menus',
90		~~'action' : 'manage_edits~~ubMenus'},) + SimpleItem.manage_options
91
92		security.declareProtected(~~VIEW_PERMISSION, 'manage_edits~~ubMenus')
93		manage_edit~~subMenus = PageTemplateFile('ddmtEdit~~', _wwwdir)
94
95		security.declareProtected(~~VIEW_PERMISSION~~, 'manage_editMenuItems')
	90	manage_options = ({'label' : 'Sub Menus',
	91	'action' : 'manage_editSubMenus'},) + SimpleItem.manage_options
	92
	93	security.declareProtected(ManagePortal, 'manage_editSubMenus')
	94	manage_editSubMenus = PageTemplateFile('editSubMenus', _wwwdir)
	95
	96	security.declareProtected(ManagePortal, 'manage_editMenuItems')
96	97	manage_editMenuItems = PageTemplateFile('editMenuItems', _wwwdir)
97	98
98		security.declareProtected(VIEW_PERMISSION, 'regenerateMenu')
99		def regenerateMenu(self):
100		""" Update initiale portal menu. """
101		updateMenu(self)
102
103		security.declareProtected(VIEW_PERMISSION, 'listPortalTabActions')
	99	security.declareProtected(ManagePortal, 'listPortalTabActions')
104	100	def listPortalTabActions(self):
105	101	""" Return all portal actions with 'portal_tabs' category. """
106	102	result = []
107	103	pu = getToolByName(self, 'plone_utils')
108
109	104	if hasattr(pu, 'createTopLevelTabs'):
110	105	pactions = getToolByName(self, 'portal_actions').listFilteredActionsFor(self)
111	106	tl_tabs = pu.createTopLevelTabs(pactions)
112
113	107	for act in tl_tabs:
114	108	data = {'title': act['name'],
…	…
116	110	'actionExpression': act['url']}
117	111	result.append(data)
118
119	112	else:
120	113	portal = getToolByName(self, 'portal_url').getPortalObject()
121	114	portal_act = getToolByName(self, 'portal_actions')
122		actions=portal_act._cloneActions()
	115	actions = portal_act._cloneActions()
123	116
124	117	for act in actions:
…	…
131	124	return result
132	125
133		security.declareProtected(~~VIEW_PERMISSION, 'generates~~ubMenuMapping')
134		def generatesubMenuMapping(self):
	126	security.declareProtected(ManagePortal, 'generateSubMenuMapping')
	127	def generateSubMenuMapping(self):
135	128	""" Create top-level subMenu mapping. """
136	129	mapping = self._submenu_mapping
137	130	for item in mapping.keys():
138	131	for tab in self.listPortalTabActions():
139		if item == tab['id']:
140		p~~aram = 1~~
	132	if item == tab['title']:
	133	present = True
141	134	break
142		else: p~~aram = 0~~
143		if ~~param == 0~~: del mapping[item]
	135	else: present = False
	136	if not present: del mapping[item]
144	137	for tab in self.listPortalTabActions():
145		if tab['~~id'] not in self._submenu_~~mapping.keys():
146		mapping[tab['~~id']] = ''~~
	138	if tab['title'] not in mapping.keys():
	139	mapping[tab['title']] = PersistentList()
147	140	self._submenu_mapping = mapping
148	141	return self._submenu_mapping
149	142
150		security.declareProtected(VIEW_PERMISSION, 'getMappingKeys')
151		def getMappingKeys(self):
152		""" Return keys from _submenu_mapping. """
153		return [key for key in self._submenu_mapping.keys()]
154
155		security.declareProtected(VIEW_PERMISSION, 'getMappingValues')
156		def getMappingValues(self):
157		""" Return values from _submenu_mapping. """
158		return [value for value in self._submenu_mapping.values()]
159
160		security.declareProtected(VIEW_PERMISSION, 'getMapping')
161		def getMapping(self):
162		""" Simple accessor """
163		return self._submenu_mapping
164
165		security.declareProtected(VIEW_PERMISSION, 'getValueByKey')
	143	security.declareProtected('View', 'getValueByKey')
166	144	def getValueByKey(self, key):
167	145	""" Return value from _submenu_mapping for given key """
168	146	try:
169		return ~~self._submenu_mapping[key~~]
	147	return [item.__of__(self) for item in self._submenu_mapping[key]]
170	148	except KeyError:
171	149	return None
172	150
173		security.declareProtected(~~VIEW_PERMISSION, 'validateId~~')
	151	security.declareProtected(ManagePortal, 'validateTitle')
174	152	def validateTitle(self, title):
175		""" Safeguard against ~~duplicate~~ title. """
176		if ~~(title == '') or (title == ' ')~~:
	153	""" Safeguard against empty (later duplicate ;) title. """
	154	if not title:
177	155	raise ValueError, 'Please, enter title'
178	156	else: return 1
179	157
180		security.declareProtected(VIEW_PERMISSION, 'getElementsBysubMenuPath')
181		def getElementsBysubMenuPath(self, submenu_path):
182		""" Return MenuItem and it's sub_menu field for a given submenu_path """
183		mapping = self._submenu_mapping
184		LOG('getElementsBysubMenuPath', 111, repr(submenu_path), repr(mapping.keys()))
185		if submenu_path in mapping.keys():
186		return (mapping[submenu_path], submenu_path, None)
187		LOG('getElementsBysubMenuPath', 111, repr(submenu_path), repr(mapping.keys()))
	158	security.declareProtected(ManagePortal, 'getSubMenuByPath')
	159	def getSubMenuByPath(self, submenu_path):
	160	""" Return submenu for a given submenu_path """
	161	if submenu_path in self._submenu_mapping.keys():
	162	return self.getValueByKey(submenu_path)
188	163	else:
189		submenu_path = submenu_path.strip()
190		path_list = submenu_path.split('/')
191		del path_list[0]
192		top_submenu = mapping[submenu_path.split('/')[0]]
193		return self.parsesubMenuPath(top_submenu, path_list)
194
195		security.declareProtected(VIEW_PERMISSION, 'parsesubMenuPath')
196		def parsesubMenuPath(self, top_submenu, path_list):
197		""" Parse submenu_path and return corresponding objects """
198		menuitems = top_submenu.listMenuItems()
199		submenu = top_submenu
200		d = 0
201		for index in path_list:
202		d += 1
203		menuitem = menuitems[int(index)]
204		if d != len(path_list):
205		submenu = menuitem.getSubMenu()
206		menuitems = submenu.listMenuItems()
207		if menuitem.getSubMenu():
208		next_submenu = menuitem.getSubMenu()
209		else:
210		next_submenu = None
211		return (submenu, menuitem, next_submenu)
212
213		security.declareProtected(VIEW_PERMISSION, 'getLevel')
214		def getLevel(self, submenu, space, list):
215		if submenu != None:
216		# if submenu.listMenuItems() != None:
217		space += ' '
218		for menuitem in submenu.listMenuItems():
219		list += space + menuitem.getTitle() + ' == ' + str(menuitem.getSubMenu()) + '\n'
220		list = str(self.getLevel(menuitem.getSubMenu(), space, list))
221		return list
222		else: return list
223
224		security.declareProtected(VIEW_PERMISSION, 'getMenuTree')
225		def getMenuTree(self):
226		""" Return all submenu with it's menuitems """
227		out = '\n'
228		mapping = self._submenu_mapping
229		for item in mapping.items():
230		space = ''
231		out += space + item[0] + ' --- ' + str(item[1]) + '\n'
232		if item[1] != '':
233		out += space + str(mapping[item[0]]) + '\n' + str(self.getLevel(mapping[item[0]], space, list=''))
234		return out
235
236		security.declareProtected(VIEW_PERMISSION, 'deletesubMenu')
237		def deletesubMenu( self, submenu_path):
238		""" Delete a submenu for the given menu item. """
239		mapping = self._submenu_mapping
240		if submenu_path in mapping.keys():
241		mapping[submenu_path] = ''
242		self._submenu_mapping = mapping
243		else:
244		data = self.getElementsBysubMenuPath(submenu_path)
245		data[1].setSubMenu(None)
246
247		security.declareProtected(VIEW_PERMISSION, 'manage_deletesubMenu')
248		def manage_deletesubMenu(self, submenu_path, REQUEST=None):
249		""" Delete a submenu for the given portal-tab action via the ZMI. """
250		self.deletesubMenu(submenu_path)
251
	164	#LOG('getSubMenuByPath', 111, 'afterElseSubmenuPath', str(submenu_path))
	165	return self.getMenuItemByPath(submenu_path).listMenuItems()
	166
	167	security.declareProtected(ManagePortal, 'getMenuItemByPath')
	168	def getMenuItemByPath(self, submenu_path):
	169	""" Return menuitem for a given submenu_path """
	170	path = submenu_path.strip().split('/')
	171	menuitem = self.getValueByKey(path[0])[int(path[1])]
	172	for i in path[2:]:
	173	menuitem = menuitem.listMenuItems()[int(i)]
	174	return menuitem
	175
	176	security.declareProtected(ManagePortal, 'getBreadcrumbs')
	177	def getBreadcrumbs(self, submenu_path):
	178	""" Return breadcrumbs dictionary for listMenuItems form """
252	179	path = submenu_path.split('/')
253		if submenu_path in self._submenu_mapping.keys():
254		edit_form = 'manage_editsubMenus'
255		new_path = submenu_path
256		else:
257		edit_form = 'manage_editMenuItems'
258		del path[-1]
259		new_path = '/'.join(path)
260		LOG('manage_deletesubMenu', 111, new_path, submenu_path)
261
262		if REQUEST:
263		REQUEST['RESPONSE'].redirect( '%s/%s'
264		'?manage_tabs_message=SubMenu+deleted.&submenu_path=%s'
265		% (self.absolute_url(), edit_form, new_path)
266		)
267
268		security.declareProtected(VIEW_PERMISSION, 'addsubMenu')
269		def addsubMenu(self, submenu_path):
270		""" Add a submenu for the given menu item """
271		javs = 1
272		new_submenu = subMenu()
273		mapping = self._submenu_mapping
274		if submenu_path in mapping.keys():
275		mapping[submenu_path] = new_submenu
276		self._submenu_mapping = mapping
277		else:
278		data = self.getElementsBysubMenuPath(submenu_path)
279		if data == () or data[1] == None: javs = 0
280		data[1].setSubMenu(new_submenu)
281		return javs
282
283		security.declareProtected( VIEW_PERMISSION, 'manage_addsubMenu' )
284		def manage_addsubMenu(self, submenu_path, REQUEST=None):
285		""" Add an sub menu for the given portal-tab action via the ZMI. """
286		self.addsubMenu(submenu_path)
287
288		path = submenu_path.split('/')
289		if submenu_path in self._submenu_mapping.keys():
290		edit_form = 'manage_editsubMenus'
291		new_path = submenu_path
292		else:
293		edit_form = 'manage_editMenuItems'
294		del path[-1]
295		new_path = '/'.join(path)
296
297		if REQUEST:
298		REQUEST['RESPONSE'].redirect( '%s/%s'
299		'?manage_tabs_message=SubMenu+added.&submenu_path=%s'
300		% (self.absolute_url(), edit_form, new_path)
301		)
302
303		security.declareProtected(VIEW_PERMISSION, 'addMenuItem')
304		def addMenuItem(self, submenu_path, title, url=None):
305		""" Add MenuItem """
306		javs = 1
307		if self.validateTitle(title) != 1: javs = 0
308		mapping = self._submenu_mapping
309		if submenu_path in mapping.keys():
310		submenu = mapping[submenu_path]
311		if submenu == None: javs = 0
312		else:
313		submenu = self.getElementsBysubMenuPath(submenu_path)[1].getSubMenu()
314		if submenu == None: javs = 0
315		menuitems = list(submenu._menu_items)
316		menuitems.append(MenuItem(title, url))
317		submenu._menu_items = tuple(menuitems)
318		if submenu._menu_items == (): javs = 0
319		return javs
320
321		security.declareProtected(VIEW_PERMISSION, 'manage_addMenuItem')
	180	result = [{'title' : path[0],
	181	'url' : '%s/manage_editMenuItems?submenu_path=%s'%(self.absolute_url(), path[0])},]
	182	for i in range(len(path[1:])):
	183	temp_path = '/'.join(path[:i+2])
	184	result.append({'title' : self.getMenuItemByPath(temp_path).getTitle(),
	185	'url' : '%s/manage_editMenuItems?submenu_path=%s'%(self.absolute_url(), temp_path)})
	186	return result
	187
	188	#security.declareProtected(ManagePortal, 'getLevel')
	189	#def getLevel(self, submenu, space, lst):
	190	#if submenu != None:
	191	## if submenu.listMenuItems() != ():
	192	#space += ' '
	193	#for menuitem in submenu.listMenuItems():
	194	#lst += space + menuitem.getTitle() + ' == ' + str(menuitem.getSubMenu()) + '\n'
	195	#lst = str(self.getLevel(menuitem.getSubMenu(), space, lst))
	196	#return lst
	197	#else: return lst
	198
	199	#security.declareProtected(ManagePortal, 'getMenuTree')
	200	#def getMenuTree(self):
	201	#""" Return all submenu with it's menuitems """
	202	#out = '\n'
	203	#mapping = self._submenu_mapping
	204	#for item in mapping.items():
	205	#space = ''
	206	#out += space + item[0] + ' --- ' + str(item[1]) + '\n'
	207	#if item[1] != '':
	208	#out += space + str(self.getValueByKey(item[0])) + '\n' + str(self.getLevel(self.getValueByKey(item[0]), space, lst=''))
	209	#return out
	210
	211	security.declareProtected(ManagePortal, 'manage_addMenuItem')
322	212	def manage_addMenuItem(self, submenu_path, title, url=None, REQUEST=None):
323	213	""" Add MenuItem via ZMI """
324		self.addMenuItem(submenu_path, title, url)
	214	self.validateTitle(title)
	215	if submenu_path in self._submenu_mapping.keys():
	216	self._submenu_mapping[submenu_path].append(MenuItem(title, url))
	217	else:
	218	self.getMenuItemByPath(submenu_path).addItem(MenuItem(title, url))
325	219
326	220	if REQUEST:
327	221	REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
328		'?manage_tabs_message=MenuItem+\'+%s+\'+added+to+subMenu.&submenu_path=%s'
329		% (self.absolute_url(), title, submenu_path))
330
331		security.declareProtected(VIEW_PERMISSION, 'manage_saveMenuItems')
	222	'?submenu_path=%s&manage_tabs_message=MenuItem+\'%s\'+added.'
	223	% (self.absolute_url(), submenu_path, title))
	224
	225	security.declareProtected(ManagePortal, 'manage_removeMenuItem')
	226	def manage_removeMenuItem(self, submenu_path, REQUEST=None):
	227	""" Remove MenuItem via ZMI """
	228	path = submenu_path.strip().split('/')
	229	if len(path)==2:
	230	self._submenu_mapping[path[0]].pop(int(path[1]))
	231	elif len(path)>2:
	232	self.getMenuItemByPath('/'.join(path[:-1])).deleteItem(int(path[-1]))
	233
	234	if REQUEST:
	235	REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
	236	'?submenu_path=%s&manage_tabs_message=MenuItem+removed.'
	237	% (self.absolute_url(), '/'.join(path[:-1])))
	238
	239	security.declareProtected(ManagePortal, 'manage_saveMenuItems')
332	240	def manage_saveMenuItems(self, submenu_path, REQUEST=None):
333	241	""" Save MenuItems for given subMenu via ZMI. """
334	242	records = REQUEST.get('menuitems')
335		mapping = self._submenu_mapping
336		if submenu_path in mapping.keys():
337		submenu = mapping[submenu_path]
	243	if submenu_path in self._submenu_mapping.keys():
	244	submenu = self._submenu_mapping[submenu_path]
338	245	else:
339		submenu = self.getElementsBysubMenuPath(submenu_path)[1].getSubMenu()
340		menuitems = submenu._menu_items
341
342		if records:
343		for i in range(len(menuitems)):
344		menuitems[i].setTitle(records[i].get('title'))
345		menuitems[i].setUrl(records[i].get('url'))
346		submenu._menu_items = tuple( menuitems )
347
348		if REQUEST:
349		REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
350		'?manage_tabs_message=MenuItems+list+updated.&submenu_path=%s'
351		% (self.absolute_url(), submenu_path))
352
353		security.declareProtected(VIEW_PERMISSION, 'removeMenuItem')
354		def removeMenuItem(self, submenu_path):
355		""" Remove MenuItem """
356		javs = 1
357		mapping = self._submenu_mapping
358		path = submenu_path.split('/')
359		if len(path) == 2:
360		submenu = mapping[path[0]]
361		if submenu == None: javs = 0
362		else:
363		submenu = self.getElementsBysubMenuPath(submenu_path)[0]
364		if submenu == None: javs = 0
365		menuitems = [item for item in submenu.listMenuItems()]
366		if (menuitems == []) or (menuitems[int(path[-1])] == None): javs = 0
367		del menuitems[int(path[-1])]
368		submenu._menu_items = tuple(menuitems)
369		if submenu._menu_items == (): javs = 0
370		return javs
371
372		security.declareProtected(VIEW_PERMISSION, 'manage_removeMenuItem')
373		def manage_removeMenuItem(self, submenu_path, REQUEST=None):
374		""" Remove MenuItem via ZMI """
375		self.removeMenuItem(submenu_path)
376
377		path = submenu_path.split('/')
378		del path[-1]
379		new_path = '/'.join(path)
380
381		if REQUEST:
382		REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
383		'?manage_tabs_message=MenuItem+removed.&submenu_path=%s'
384		% (self.absolute_url(), new_path))
385
386		security.declareProtected(VIEW_PERMISSION, 'moveMenuItemDown')
387		def moveMenuItemDown(self, submenu_path):
388		""" Move the MenuItem down """
389		javs = 1
390		mapping = self._submenu_mapping
391		path = submenu_path.split('/')
392		if len(path) == 2:
393		submenu = mapping[path[0]]
394		if submenu == None: javs = 0
395		else:
396		submenu = self.getElementsBysubMenuPath(submenu_path)[0]
397		if submenu == None: javs = 0
398		menuitems = [item for item in submenu.listMenuItems()]
399		if menuitems == []: javs = 0
400		submenu._menu_items = tuple(self.moveItem(path[-1], int(path[-1]) + 1, menuitems))
401		if submenu._menu_items == (): javs = 0
402		return javs
403
404		security.declareProtected(VIEW_PERMISSION, 'moveMenuItemUp')
405		def moveMenuItemUp(self, submenu_path):
406		""" Move the MenuItem up """
407		javs = 1
408		mapping = self._submenu_mapping
409		path = submenu_path.split('/')
410		if len(path) == 2:
411		submenu = mapping[path[0]]
412		if submenu == None: javs = 0
413		else:
414		submenu = self.getElementsBysubMenuPath(submenu_path)[0]
415		if submenu == None: javs = 0
416		menuitems = [item for item in submenu.listMenuItems()]
417		if menuitems == []: javs = 0
418		submenu._menu_items = tuple(self.moveItem(path[-1], int(path[-1]) - 1, menuitems))
419		if submenu._menu_items == (): javs = 0
420		return javs
421
422		security.declareProtected(VIEW_PERMISSION, 'manage_moveMenuItemDown')
	246	submenu = self.getSubMenuByPath(submenu_path)
	247	if records and len(records) == len(submenu):
	248	for i in range(len(submenu)):
	249	if records[i].get('title'): submenu[i].setTitle(records[i].get('title'))
	250	submenu[i].setUrl(records[i].get('url'))
	251
	252	if REQUEST:
	253	REQUEST['RESPONSE'].redirect('%s/manage_editMenuItems'
	254	'?&submenu_path=%s&manage_tabs_message=MenuItems+updated.'
	255	% (self.absolute_url(), submenu_path))
	256
	257	security.declareProtected(ManagePortal, 'manage_moveMenuItemDown')
423	258	def manage_moveMenuItemDown(self, submenu_path, REQUEST=None):
424	259	""" Move the MenuItem down via ZMI """
425		self.moveMenuItemDown(submenu_path)
426
427		path = submenu_path.split('/')
428		del path[-1]
429		new_path = '/'.join(path)
430
431		if REQUEST:
432		REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
433		'?manage_tabs_message=MenuItem+moved+down.&submenu_path=%s'
434		% (self.absolute_url(), new_path))
435
436		security.declareProtected(VIEW_PERMISSION, 'manage_moveMenuItemUp')
	260	path = submenu_path.strip().split('/')
	261	if len(path)==2:
	262	self._submenu_mapping[path[0]] = PersistentList(self.moveItem(path[1], int(path[1])+1, self._submenu_mapping[path[0]]))
	263	elif len(path)>2:
	264	menuitem = self.getMenuItemByPath('/'.join(path[:-1]))
	265	menuitem.setMenuItems(list(self.moveItem(path[-1], int(path[-1])+1, menuitem.listMenuItems())))
	266
	267	if REQUEST:
	268	REQUEST['RESPONSE'].redirect('%s/manage_editMenuItems'
	269	'?&submenu_path=%s&manage_tabs_message=MenuItem+moved+up.'
	270	% (self.absolute_url(), '/'.join(path[:-1])))
	271
	272	security.declareProtected(ManagePortal, 'manage_moveMenuItemUp')
437	273	def manage_moveMenuItemUp(self, submenu_path, REQUEST=None):
438	274	""" Move the MenuItem up via ZMI """
439		self.moveMenuItemUp(submenu_path)
440
441		path = submenu_path.split('/')
442		del path[-1]
443		new_path = '/'.join(path)
444
445		if REQUEST:
446		REQUEST['RESPONSE'].redirect( '%s/manage_editMenuItems'
447		'?manage_tabs_message=MenuItem+moved+up.&submenu_path=%s'
448		% (self.absolute_url(), new_path))
449
450		security.declareProtected(VIEW_PERMISSION, 'moveItem')
	275	path = submenu_path.strip().split('/')
	276	if len(path)==2:
	277	self._submenu_mapping[path[0]] = PersistentList(self.moveItem(path[1], int(path[1])-1, self._submenu_mapping[path[0]]))
	278	elif len(path)>2:
	279	menuitem = self.getMenuItemByPath('/'.join(path[:-1]))
	280	menuitem.setMenuItems(list(self.moveItem(path[-1], int(path[-1])-1, menuitem.listMenuItems())))
	281
	282	if REQUEST:
	283	REQUEST['RESPONSE'].redirect('%s/manage_editMenuItems'
	284	'?&submenu_path=%s&manage_tabs_message=MenuItem+moved+up.'
	285	% (self.absolute_url(), '/'.join(path[:-1])))
	286
	287	security.declareProtected(ManagePortal, 'moveItem')
451	288	def moveItem(self, index, position, menuitems):
452	289	""" Move an item to the given position."""
…	…
460	297	return menuitems
461	298
462		security.declareProtected(VIEW_PERMISSION, 'getMenuItemPosition')
463		def getMenuItemPosition(self, submenu_path):
464		""" Return MenuItem position by submenu_path """
465		path = submenu_path.split('/')
466		return int(path[-1])
	299	security.declareProtected(ManagePortal, 'manage_reorderItems')
	300	def manage_reorderItems(self, idxs, submenu_path):
	301	""" Reorder menu items of the same submenu in given order """
	302	path = submenu_path.strip().split('/')
	303	submenu = self.reorderItems(idxs, self.getSubMenuByPath(submenu_path))
	304	if len(path) == 1:
	305	self._submenu_mapping[path[0]] = PersistentList(submenu)
	306	elif len(path) > 1:
	307	menuitem = self.getMenuItemByPath(submenu_path)
	308	menuitem.setMenuItems(submenu)
	309
	310	security.declareProtected(ManagePortal, 'reorderItems')
	311	def reorderItems(self, idxs, submenu):
	312	""" Return list in given order """
	313	idxs = list(map(int,idxs))
	314	#if len(idxs) != len(submenu): return False
	315	return [submenu[idx] for idx in idxs]
467	316
468	317	InitializeClass(DropDownMenuTool)

qPloneDropDownMenu/branches/0.2/Extensions/Install.py

r462	r463
4	4	from Products.CMFCore.utils import getToolByName
5	5	from Products.CMFCore.DirectoryView import addDirectoryViews
6
7		from Products.CMFPlone.migrations.migration_util import safeEditProperty
8		from Products.CMFCore.Expression import Expression, createExprContext
	6	from Products.CMFCore.permissions import ManagePortal
9	7
10	8	from Products.qPloneDropDownMenu.config import *
11	9
12		configlets = ({'id':PROJECT_NAME,
	10	configlets = ({'id':PROJECTNAME,
13	11	'name':'Drop Down Menu',
14	12	'action':'string:${portal_url}/prefs_dropdownmenu_edit_form',
…	…
16	14	'category':'Products',
17	15	'visible':1,
18		'appId':PROJECT_NAME,
19		'permission':VIEW_PERMISSION,
20		'imageUrl':'qplonedropdownmenu.gif' },)
	16	'appId':PROJECTNAME,
	17	'permission':ManagePortal,
	18	'imageUrl':'qplonedropdownmenu.gif'},)
	19
	20	def setupConfiglets(self, out):
	21	configTool = getToolByName(self, 'portal_controlpanel', None)
	22	if configTool:
	23	for conf in configlets:
	24	configTool.registerConfiglet(**conf)
	25	out.write('Added configlet %s\n' % conf['id'])
	26
	27	def removeConfiglets(self, out):
	28	configTool = getToolByName(self, 'portal_controlpanel', None)
	29	if configTool:
	30	for conf in configlets:
	31	configTool.unregisterConfiglet(conf['id'])
	32	out.write('Removed configlet %s\n' % conf['id'])
21	33
22	34	def registerCSS(self, out):
23
24	35	qi = getToolByName(self, 'portal_quickinstaller', None)
25	36	if qi is not None:
…	…
41	52
42	53	def unregisterCSS(self, out):
43
44	54	qi = getToolByName(self, 'portal_quickinstaller', None)
45	55	if qi is not None:
…	…
57	67	pass
58	68
59		~~def updateMenu(self):~~
60		~~out = ''~~
61
62		~~pu = getToolByName(self, 'plone_utils')~~
63
64		~~if hasattr(pu, 'createTopLevelTabs'):~~
65		~~pactions = getToolByName(self, 'portal_actions').listFilteredActionsFor(self)~~
66		~~tl_tabs = pu.createTopLevelTabs(pactions)~~
67
68		~~for act in tl_tabs:~~
69		~~out += '<li id="portaltab-%s" class="plain"><a href="%s" accesskey="t">' % \~~
70		~~(act['id'], act['url']) + act['name'] + '</a></li>\n'~~
71		~~else:~~
72		~~portal = getToolByName(self, 'portal_url').getPortalObject()~~
73
74		~~portal_act = getToolByName(self, 'portal_actions')~~
75		~~actions=portal_act._cloneActions()~~
76
77		~~for act in actions:~~
78		~~if act.category == 'portal_tabs':~~
79		~~out += '<li id="portaltab-%s" class="plain"><a href="%s" accesskey="t">%s</a></li>\n' % \~~
80		~~(act.id, \~~
81		~~Expression(act.getActionExpression())(createExprContext(portal, portal, portal)), \~~
82		~~act.title)~~
83
84		~~portal_props = getToolByName(self, 'portal_properties')~~
85		~~if not hasattr(portal_props, PROPERTY_SHEET):~~
86		~~portal_props.addPropertySheet(PROPERTY_SHEET, 'DropDown Menu Properties')~~
87		~~ap = getattr(portal_props, PROPERTY_SHEET)~~
88		~~safeEditProperty(ap, 'menu', out, 'text')~~
89
90	69	def setupSkin(self, out, skinFolder):
91
92	70	skinstool=getToolByName(self, 'portal_skins')
93
94	71	addDirectoryViews(skinstool, SKINS_DIR, GLOBALS)
95
96	72	for skin in skinstool.getSkinSelections():
97	73	path = skinstool.getSkinPath(skin)
98		path = map( string.strip, string.split( path,',' ) )
99
	74	path = map(string.strip, string.split(path,','))
100	75	if not skinFolder in path:
101	76	try:
102		path.insert( ~~path.index( 'custom')+1, skinFolder~~ )
	77	path.insert(path.index('custom')+1, skinFolder)
103	78	except ValueError:
104	79	path.append(skinFolder)
105		path = string.join( ~~path, ', '~~ )
106		skinstool.addSkinSelection( ~~skin, path~~ )
	80	path = string.join(path, ', ')
	81	skinstool.addSkinSelection(skin, path)
107	82	out.write(' %s layer sucessfully installed into skin %s.\n' % (skinFolder, skin))
108	83	else:
109	84	out.write(' %s layer was already installed into skin %s.\n' % (skinFolder, skin))
110	85
111		def setupTool(self):
	86	def removeSkin(self, skins=[]):
	87	if skins:
	88	skinstool = getToolByName(self, 'portal_skins')
	89	for skinName in skinstool.getSkinSelections():
	90	path = skinstool.getSkinPath(skinName)
	91	path = [i.strip() for i in path.split(',')]
	92	for s in skins:
	93	if s in path:
	94	path.remove(s)
	95	s += '/'
	96	for layer in path:
	97	if layer.startswith(s):
	98	path.remove(layer)
	99	path = ','.join(path)
	100	skinstool.addSkinSelection(skinName, path)
112	101
	102	def setupTool(self, out):
	103	if hasattr(self, UNIQUE_ID):
	104	self.manage_delObjects([UNIQUE_ID])
	105	out.write('Deleting old %s\n' % (UNIQUE_ID))
113	106	portal_url = getToolByName(self, 'portal_url')
114	107	p = portal_url.getPortalObject()
115		x = p.manage_addProduct[PROJECT_NAME].manage_addTool(type='DropDownMenu Tool')
	108	x = p.manage_addProduct[PROJECTNAME].manage_addTool(type='DropDownMenu Tool')
	109
	110	def deleteTool(self, out):
	111	if hasattr(self, UNIQUE_ID):
	112	self.manage_delObjects([UNIQUE_ID])
	113	out.write('Deleted %s tool\n' % (UNIQUE_ID))
116	114
117	115	def install(self):
118	116	out = StringIO()
119
120	117	registerCSS(self, out)
121
122		~~configTool = getToolByName(self, 'portal_controlpanel', None)~~
123		~~if configTool:~~
124		~~for conf in configlets:~~
125		~~configTool.registerConfiglet(**conf)~~
126		~~out.write('Added configlet %s\n' % conf['id'])~~
127
128		~~if hasattr(self, UNIQUE_ID):~~
129		~~self.manage_delObjects([UNIQUE_ID])~~
130		~~out.write('Deleting old %s\n' % (UNIQUE_ID))~~
131		~~setupTool(self)~~
132		~~out.write('Added %s to the portal root folder\n' % (UNIQUE_ID))~~
133
134		~~portal_props = getToolByName(self, 'portal_properties')~~
135		~~if not hasattr(portal_props, PROPERTY_SHEET):~~
136		~~out.write('updateMenu... \n')~~
137		~~updateMenu(self)~~
138		~~else:~~
139		~~out.write('skipping updateMenu... \n')~~
140
141	118	out.write('setupSkin... \n')
142	119	setupSkin(self, out, 'qPloneDropDownMenu')
143
	120	mtool = getToolByName(self, 'portal_migration')
	121	plone_version = mtool.getFileSystemVersion()
	122	if plone_version == '2.0.5':
	123	setupSkin(self, out, PROJECT_NAME+'/2.0.5')
	124	out.write('Added %s/2.0.5 Layer to portal_skins\n' % PROJECT_NAME)
	125	setupConfiglets(self, out)
	126	out.write('Added %s to the portal root folder\n' % (UNIQUE_ID))
	127	setupTool(self, out)
144	128	return out.getvalue()
145	129
146	130	def uninstall(self):
147	131	out = StringIO()
148
149	132	unregisterCSS(self, out)
150
151		configTool = getToolByName(self, 'portal_controlpanel', None)
152		if configTool:
153		for conf in configlets:
154		configTool.unregisterConfiglet(conf['id'])
155		out.write('Removed configlet %s\n' % conf['id'])
156
	133	removeConfiglets(self, out)
	134	removeSkin(self, [PROJECTNAME,])
	135	deleteTool(self, out)
157	136	return out.getvalue()

qPloneDropDownMenu/branches/0.2/HISTORY.txt

r462	r463
1	1	0.2
2	2
	3	* removed subMenu class
	4
	5	* improved dropdownmenu tool
	6
	7	* added plone ajax configlet with necessary functionality
	8
3	9	* added menu editor tool in ZMI
	10
	11
	12	############################################################
	13
	14
4	15
5	16	0.1.8

qPloneDropDownMenu/branches/0.2/README.txt

r462	r463
26	26	Usage
27	27
28		~~You have a list of items of your top level menu, which you can edit in~~
29		~~'drop down menu' configlet form. Now, to add submenu to the certain~~
30		~~menu item, you need to add unordered list inside of top level menu~~
31		~~item ('<li>...</li>') after its title ('<a></a>')::~~
32
33		~~<ul><li>...</li>...<li>...</li></ul>~~
34
35		~~To make your changes live click 'save' button.~~
36
37		~~Sample menu with 2 submenus::~~
38
39		~~<li id="portalt~~