The following menus can now be extended by plugins: top_menu, account_menu, application_menu (empty by default).

Sligth layout change: links in the top menu are now li elements.

git-svn-id: http://redmine.rubyforge.org/svn/trunk@1137 e93f8b46-1217-0410-a6f0-8f06a7374b81

2 files changed, 50 insertions, 18 deletions

diff --git a/lib/redmine.rb b/lib/redmine.rb
index 9bec55409..b235df32e 100644
--- a/lib/redmine.rb
+++ b/lib/redmine.rb
@@ -88,23 +88,41 @@ Redmine::AccessControl.map do |map|
   end
 end
 
-# Project menu configuration
+Redmine::MenuManager.map :top_menu do |menu|
+  menu.push :home, :home_url, :html => { :class => 'home' }
+  menu.push :my_page, { :controller => 'my', :action => 'page' }, :html => { :class => 'mypage' }, :if => Proc.new { User.current.logged? }
+  menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural, :html => { :class => 'projects' }
+  menu.push :administration, { :controller => 'admin', :action => 'index' }, :html => { :class => 'admin' }, :if => Proc.new { User.current.admin? }
+  menu.push :help, Redmine::Info.help_url, :html => { :class => 'help' }
+end
+
+Redmine::MenuManager.map :account_menu do |menu|
+  menu.push :login, :signin_url, :html => { :class => 'login' }, :if => Proc.new { !User.current.logged? }
+  menu.push :register, { :controller => 'account', :action => 'register' }, :html => { :class => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
+  menu.push :my_account, { :controller => 'my', :action => 'account' }, :html => { :class => 'myaccount' }, :if => Proc.new { User.current.logged? }
+  menu.push :logout, :signout_url, :html => { :class => 'logout' }, :if => Proc.new { User.current.logged? }
+end
+
+Redmine::MenuManager.map :application_menu do |menu|
+  # Empty
+end
+
 Redmine::MenuManager.map :project_menu do |menu|
-  menu.push :overview, { :controller => 'projects', :action => 'show' }, :caption => :label_overview
-  menu.push :activity, { :controller => 'projects', :action => 'activity' }, :caption => :label_activity
+  menu.push :overview, { :controller => 'projects', :action => 'show' }
+  menu.push :activity, { :controller => 'projects', :action => 'activity' }
   menu.push :roadmap, { :controller => 'projects', :action => 'roadmap' }, 
-              :if => Proc.new { |p| p.versions.any? }, :caption => :label_roadmap
+              :if => Proc.new { |p| p.versions.any? }
   menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
   menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
               :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
   menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
   menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
   menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil }, 
-              :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }, :caption => :label_wiki
+              :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
   menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
               :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
   menu.push :files, { :controller => 'projects', :action => 'list_files' }, :caption => :label_attachment_plural
   menu.push :repository, { :controller => 'repositories', :action => 'show' },
-              :if => Proc.new { |p| p.repository && !p.repository.new_record? }, :caption => :label_repository
-  menu.push :settings, { :controller => 'projects', :action => 'settings' }, :caption => :label_settings
+              :if => Proc.new { |p| p.repository && !p.repository.new_record? }
+  menu.push :settings, { :controller => 'projects', :action => 'settings' }
 end
diff --git a/lib/redmine/menu_manager.rb b/lib/redmine/menu_manager.rb
index 379028ebc..3b29912a1 100644
--- a/lib/redmine/menu_manager.rb
+++ b/lib/redmine/menu_manager.rb
@@ -61,16 +61,28 @@ module Redmine
         @controller.current_menu_item
       end
       
-      # Renders the application main menu as a ul element
+      # Renders the application main menu
       def render_main_menu(project)
+        render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project)
+      end
+      
+      def render_menu(menu, project=nil)
         links = []
-        Redmine::MenuManager.allowed_items(:project_menu, User.current, project).each do |item|
+        Redmine::MenuManager.allowed_items(menu, User.current, project).each do |item|
           unless item.condition && !item.condition.call(project)
+            url = case item.url
+            when Hash
+              project.nil? ? item.url : {item.param => project}.merge(item.url)
+            when Symbol
+              send(item.url)
+            else
+              item.url
+            end
+            #url = (project && item.url.is_a?(Hash)) ? {item.param => project}.merge(item.url) : (item.url.is_a?(Symbol) ? send(item.url) : item.url)
             links << content_tag('li', 
-                       link_to(l(item.caption), {item.param => project}.merge(item.url),
-                               (current_menu_item == item.name ? item.html_options.merge(:class => 'selected') : item.html_options)))
+              link_to(l(item.caption), url, (current_menu_item == item.name ? item.html_options.merge(:class => 'selected') : item.html_options)))
           end
-        end if project && !project.new_record?
+        end
         links.empty? ? nil : content_tag('ul', links.join("\n"))
       end
     end
@@ -89,35 +101,37 @@ module Redmine
       end
       
       def allowed_items(menu_name, user, project)
-        items(menu_name).select {|item| user && user.allowed_to?(item.url, project)}
+        project ? items(menu_name).select {|item| user && user.allowed_to?(item.url, project)} : items(menu_name)
       end
     end
     
     class Mapper
       # Adds an item at the end of the menu. Available options:
       # * param: the parameter name that is used for the project id (default is :id)
-      # * condition: a proc that is called before rendering the item, the item is displayed only if it returns true
+      # * if: a proc that is called before rendering the item, the item is displayed only if it returns true
       # * caption: the localized string key that is used as the item label
       # * html_options: a hash of html options that are passed to link_to
       def push(name, url, options={})
-        @items ||= []
-        @items << MenuItem.new(name, url, options)
+        items << MenuItem.new(name, url, options)
       end
       
       def items
-        @items
+        @items ||= []
       end
     end
     
     class MenuItem
+      include GLoc
       attr_reader :name, :url, :param, :condition, :caption, :html_options
       
       def initialize(name, url, options)
+        raise "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call)
+        raise "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash)
         @name = name
         @url = url
         @condition = options[:if]
         @param = options[:param] || :id
-        @caption = options[:caption] || name.to_s.humanize
+        @caption = options[:caption] || (l_has_string?("label_#{name}".to_sym) ? "label_#{name}".to_sym : name.to_s.humanize)
         @html_options = options[:html] || {}
       end
     end