SoundSoftware Code Site

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module Redmine

  module AccessControl

    class << self

      def map

        mapper = Mapper.new

        @permissions ||= []

        @permissions += mapper.mapped_permissions

      end

      def permissions

        @permissions

      end

      # Returns the permission of given name or nil if it wasn't found

      # Argument should be a symbol

      def permission(name)

        permissions.detect {|p| p.name == name}

      end

      # Returns the actions that are allowed by the permission of given name

      def allowed_actions(permission_name)

        perm = permission(permission_name)

        perm ? perm.actions : []

      end

      def public_permissions

        @public_permissions ||= @permissions.select {|p| p.public?}

      end

      def members_only_permissions

        @members_only_permissions ||= @permissions.select {|p| p.require_member?}

      end

      def loggedin_only_permissions

        @loggedin_only_permissions ||= @permissions.select {|p| p.require_loggedin?}

      end

      def available_project_modules

        @available_project_modules ||= @permissions.collect(&:project_module).uniq.compact

      end

      def modules_permissions(modules)

        @permissions.select {|p| p.project_module.nil? || modules.include?(p.project_module.to_s)}

      end

    end

    class Mapper

      def initialize

        @project_module = nil

      end

      def permission(name, hash, options={})

        @permissions ||= []

        options.merge!(:project_module => @project_module)

        @permissions << Permission.new(name, hash, options)

      end

      def project_module(name, options={})

        @project_module = name

        yield self

        @project_module = nil

      end

      def mapped_permissions

        @permissions

      end

    end

    class Permission

      attr_reader :name, :actions, :project_module

      def initialize(name, hash, options)

        @name = name

        @actions = []

        end

        @actions.flatten!

      end

      def public?

        @public

      end

      def require_member?

        @require && @require == :member

      end

      def require_loggedin?

        @require && (@require == :member || @require == :loggedin)

      end

  end

end

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

                  :search => '4',

                  :new_issue => '7'

                 }.freeze unless const_defined?(:ACCESSKEYS)

    def self.key_for(action)

      ACCESSKEYS[action]

    end

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module Redmine

  module Activity

    mattr_accessor :available_event_types, :default_event_types, :providers

    @@available_event_types = []

    @@default_event_types = []

    @@providers = Hash.new {|h,k| h[k]=[] }

      def map(&block)

        yield self

      end

      # Registers an activity provider

      def register(event_type, options={})

        options.assert_valid_keys(:class_name, :default)

        event_type = event_type.to_s

        providers = options[:class_name] || event_type.classify

        providers = ([] << providers) unless providers.is_a?(Array)

        @@available_event_types << event_type unless @@available_event_types.include?(event_type)

        @@default_event_types << event_type unless options[:default] == false

        @@providers[event_type] += providers

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    # Class used to retrieve activity events

    class Fetcher

      attr_reader :user, :project, :scope

      # Needs to be unloaded in development mode

      @@constantized_providers = Hash.new {|h,k| h[k] = Redmine::Activity.providers[k].collect {|t| t.constantize } }

      def initialize(user, options={})

        options.assert_valid_keys(:project, :with_subprojects, :author)

        @user = user

        @project = options[:project]

        @options = options

        @scope = event_types

      end

      # Returns an array of available event types

      def event_types

        return @event_types unless @event_types.nil?

        @event_types = Redmine::Activity.available_event_types

        @event_types = @event_types.select {|o| @project.self_and_descendants.detect {|p| @user.allowed_to?("view_#{o}".to_sym, p)}} if @project

        @event_types

      end

      # Yields to filter the activity scope

      def scope_select(&block)

        @scope = @scope.select {|t| yield t }

      end

      # Sets the scope

      # Argument can be :all, :default or an array of event types

      def scope=(s)

          @scope = s & event_types

        end

      end

      # Resets the scope to the default scope

      def default_scope!

        @scope = Redmine::Activity.default_event_types

      end

      # Returns an array of events for the given date range

      # sorted in reverse chronological order

      def events(from = nil, to = nil, options={})

        e = []

        @options[:limit] = options[:limit]

        @scope.each do |event_type|

          constantized_providers(event_type).each do |provider|

            e += provider.find_events(event_type, @user, from, to, @options)

          end

        end

        e.sort! {|a,b| b.event_datetime <=> a.event_datetime}

        if options[:limit]

          e = e.slice(0, options[:limit])

        end

        e

      end

      private

      def constantized_providers(event_type)

        @@constantized_providers[event_type]

      end

module Redmine

  module Ciphering

      base.extend ClassMethods

    end

    class << self

      def encrypt_text(text)

          text

        else

          c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")

          "aes-256-cbc:" + [e, iv].map {|v| Base64.encode64(v).strip}.join('--')

        end

      end

      def decrypt_text(text)

        if text && match = text.match(/\Aaes-256-cbc:(.+)\Z/)

          text = match[1]

          c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")

          e, iv = text.split("--").map {|s| Base64.decode64(s)}

          text

        end

      end

      def cipher_key

        key = Redmine::Configuration['database_cipher_key'].to_s

        key.blank? ? nil : Digest::SHA256.hexdigest(key)

      end

    end

    module ClassMethods

      def encrypt_all(attribute)

        transaction do

          end

        end ? true : false

      end

      def decrypt_all(attribute)

        transaction do

          all.each do |object|

        end

      end ? true : false

    end

    private

    # Returns the value of the given ciphered attribute

    def read_ciphered_attribute(attribute)

      Redmine::Ciphering.decrypt_text(read_attribute(attribute))

    end

    # Sets the value of the given ciphered attribute

    def write_ciphered_attribute(attribute, value)

      write_attribute(attribute, Redmine::Ciphering.encrypt_text(value))

          str = str.encode("US-ASCII", :invalid => :replace,

                :undef => :replace, :replace => '?').encode("UTF-8")

        end

      else

        ic = Iconv.new('UTF-8', 'UTF-8')

        txtar = ""

      end

      str

    end

  end

end

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module Redmine

  module Configuration

    # Configuration default values

    @defaults = {

      'email_delivery' => nil

    }

    @config = nil

    class << self

      # Loads the Redmine configuration file

      # Valid options:

      # * <tt>:file</tt>: the configuration file to load (default: config/configuration.yml)

      def load(options={})

        filename = options[:file] || File.join(Rails.root, 'config', 'configuration.yml')

        env = options[:env] || Rails.env

        @config = @defaults.dup

        load_deprecated_email_configuration(env)

        if File.file?(filename)

          @config.merge!(load_from_yaml(filename, env))

        end

        # Compatibility mode for those who copy email.yml over configuration.yml

        %w(delivery_method smtp_settings sendmail_settings).each do |key|

          if value = @config.delete(key)

            @config['email_delivery'][key] = value

          end

        end

        if @config['email_delivery']

          ActionMailer::Base.perform_deliveries = true

          @config['email_delivery'].each do |k, v|

            ActionMailer::Base.send("#{k}=", v)

          end

        end

        @config

      end

      # Returns a configuration setting

      def [](name)

        load unless @config

        @config[name]

      end

      # Yields a block with the specified hash configuration settings

      def with(settings)

        settings.stringify_keys!

        yield if block_given?

        @config.merge! was

      end

      private

      def load_from_yaml(filename, env)

        conf = {}

        if yaml.is_a?(Hash)

          if yaml['default']

            conf.merge!(yaml[env])

          end

        else

          exit 1

        end

        conf

      end

      def load_deprecated_email_configuration(env)

        deprecated_email_conf = File.join(Rails.root, 'config', 'email.yml')

        if File.file?(deprecated_email_conf)

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

          s.gsub!(',', '.')

          begin; Kernel.Float(s); rescue; nil; end

        end

        # Object#to_a removed in ruby1.9

        if RUBY_VERSION > '1.9'

          def to_a

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

        return value

      }

    end

    ['user', 'version'].each do |name|

      define_method("format_as_#{name}") {|value|

        return value.blank? ? "" : name.classify.constantize.find_by_id(value.to_i).to_s

      def map(&block)

        yield self

      end

      # Registers a custom field format

      def register(custom_field_format, options={})

        @@available[custom_field_format.name] = custom_field_format unless @@available.keys.include?(custom_field_format.name)

        end

      end

    end

end

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    module Loader

      include Redmine::I18n

      class << self

        # Returns true if no data is already loaded in the database

        # otherwise false

            !IssueStatus.find(:first) &&

            !Enumeration.find(:first)

        end

        # Loads the default data

        # Raises a RecordNotSaved exception if something goes wrong

        def load(lang=nil)

          raise DataAlreadyLoaded.new("Some configuration data is already loaded.") unless no_data?

          set_language_if_valid(lang)

          Role.transaction do

            # Roles

                                   :issues_visibility => 'all',

                                   :position => 1

            manager.permissions = manager.setable_permissions.collect {|p| p.name}

            manager.save!

                                                      :manage_categories,

                                                      :view_issues,

                                                      :add_issues,

                                                      :browse_repository,

                                                      :view_changesets,

                                                      :commit_access]

            reporter = Role.create! :name => l(:default_role_reporter),

                                    :position => 3,

                                    :permissions => [:view_issues,

                                                    :view_files,

                                                    :browse_repository,

                                                    :view_changesets]

            Role.non_member.update_attribute :permissions, [:view_issues,

                                                            :add_issues,

                                                            :add_issue_notes,

                                                            :view_files,

                                                            :browse_repository,

                                                            :view_changesets]

            Role.anonymous.update_attribute :permissions, [:view_issues,

                                                           :view_gantt,

                                                           :view_calendar,

                                                           :view_files,

                                                           :browse_repository,

                                                           :view_changesets]

            # Trackers

            Tracker.create!(:name => l(:default_tracker_bug),     :is_in_chlog => true,  :is_in_roadmap => false, :position => 1)

            Tracker.create!(:name => l(:default_tracker_feature), :is_in_chlog => true,  :is_in_roadmap => true,  :position => 2)

            Tracker.create!(:name => l(:default_tracker_support), :is_in_chlog => false, :is_in_roadmap => false, :position => 3)

            # Issue statuses

            new       = IssueStatus.create!(:name => l(:default_issue_status_new), :is_closed => false, :is_default => true, :position => 1)

            in_progress  = IssueStatus.create!(:name => l(:default_issue_status_in_progress), :is_closed => false, :is_default => false, :position => 2)

            feedback  = IssueStatus.create!(:name => l(:default_issue_status_feedback), :is_closed => false, :is_default => false, :position => 4)

            closed    = IssueStatus.create!(:name => l(:default_issue_status_closed), :is_closed => true, :is_default => false, :position => 5)

            rejected  = IssueStatus.create!(:name => l(:default_issue_status_rejected), :is_closed => true, :is_default => false, :position => 6)

            # Workflow

            Tracker.find(:all).each { |t|

              IssueStatus.find(:all).each { |os|

                IssueStatus.find(:all).each { |ns|

                  Workflow.create!(:tracker_id => t.id, :role_id => manager.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

            }

            Tracker.find(:all).each { |t|

              [new, in_progress, resolved, feedback].each { |os|

                [in_progress, resolved, feedback, closed].each { |ns|

                  Workflow.create!(:tracker_id => t.id, :role_id => developer.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

            }

            Tracker.find(:all).each { |t|

              [new, in_progress, resolved, feedback].each { |os|

                [closed].each { |ns|

                  Workflow.create!(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns

              }

              Workflow.create!(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => resolved.id, :new_status_id => feedback.id)

            }

            # Enumerations

            DocumentCategory.create!(:name => l(:default_doc_category_user), :position => 1)

            DocumentCategory.create!(:name => l(:default_doc_category_tech), :position => 2)

            IssuePriority.create!(:name => l(:default_priority_low), :position => 1)

            IssuePriority.create!(:name => l(:default_priority_normal), :position => 2, :is_default => true)

            IssuePriority.create!(:name => l(:default_priority_high), :position => 3)

            IssuePriority.create!(:name => l(:default_priority_urgent), :position => 4)

            IssuePriority.create!(:name => l(:default_priority_immediate), :position => 5)

            TimeEntryActivity.create!(:name => l(:default_activity_design), :position => 1)

            TimeEntryActivity.create!(:name => l(:default_activity_development), :position => 2)

          end

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require 'iconv'

require 'fpdf/chinese'

require 'fpdf/japanese'

require 'fpdf/korean'

module Redmine

  module Export

    module PDF

      include ActionView::Helpers::TextHelper

      include ActionView::Helpers::NumberHelper

      class ITCPDF < TCPDF

        include Redmine::I18n

        attr_accessor :footer_date

        def initialize(lang)

          set_language_if_valid lang

          pdf_encoding = l(:general_pdf_encoding).upcase

          super('P', 'mm', 'A4', (pdf_encoding == 'UTF-8'), pdf_encoding)

          case current_language.to_s.downcase

          when 'vi'

        end

        def fix_text_encoding(txt)

        end

        def RDMCell(w ,h=0, txt='', border=0, ln=0, align='', fill=0, link='')

          MultiCell(w, h, fix_text_encoding(txt), border, align, fill, ln)

        end

        def Footer

          SetFont(@font_for_footer, 'I', 8)

          SetY(-15)

        col_width = []

        unless query.columns.empty?

          col_width = query.columns.collect do |c|

          end

          ratio = (table_width - col_id_width) / col_width.inject(0) {|s,w| s += w}

          col_width = col_width.collect {|w| w * ratio}

        pdf.SetFontStyle('',8)

        pdf.SetFillColor(255, 255, 255)

        previous_group = false

          if query.grouped? &&

               (group = query.group_by_column.value(issue)) != previous_group

            pdf.SetFontStyle('B',9)

              show_value(cv)

            else

              value = issue.send(column.name)

              if value.is_a?(Date)

                format_date(value)

              elsif value.is_a?(Time)

        pdf.footer_date = format_date(Date.today)

        pdf.AddPage

        pdf.SetFontStyle('B',11)

        pdf.Ln

        pdf.SetFontStyle('B',9)

        pdf.SetFontStyle('B',9)

        pdf.RDMCell(35+155, 5, l(:field_description), "LRT", 1)

        pdf.SetFontStyle('',9)

        pdf.Ln

        if issue.changesets.any? &&

            pdf.Ln

            unless changeset.comments.blank?

              pdf.SetFontStyle('',8)

            end

            pdf.Ln

          end

        pdf.SetFontStyle('B',9)

        pdf.RDMCell(190,5, l(:label_history), "B")

        pdf.Ln

        for journal in issue.journals.find(

                          :all, :include => [:user, :details],

                          :order => "#{Journal.table_name}.created_on ASC")

          pdf.SetFontStyle('B',8)

          pdf.RDMCell(190,5,

          pdf.Ln

          pdf.SetFontStyle('I',8)

          for detail in journal.details

          if journal.notes?

            pdf.Ln unless journal.details.empty?

            pdf.SetFontStyle('',8)

          end

          pdf.Ln

        end

        pdf.Output

      end

      class RDMPdfEncoding

          txt ||= ''

          if txt.respond_to?(:force_encoding)

            txt.force_encoding('ASCII-8BIT')

          end

          txt

        end

      end

    end

  end

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module Redmine

  module Helpers

    # Simple class to compute the start and end dates of a calendar

    class Calendar

      include Redmine::I18n

      attr_reader :startdt, :enddt

      def initialize(date, lang = current_language, period = :month)

        @date = date

        @events = []

        @ending_events_by_days = {}

        @starting_events_by_days = {}

        case period

        when :month

          @startdt = Date.civil(date.year, date.month, 1)

          raise 'Invalid period'

        end

      end

      # Sets calendar events

      def events=(events)

        @events = events

        @ending_events_by_days = @events.group_by {|event| event.due_date}

        @starting_events_by_days = @events.group_by {|event| event.start_date}

      end

      # Returns events for the given day

      def events_on(day)

        ((@ending_events_by_days[day] || []) + (@starting_events_by_days[day] || [])).uniq

      end

      # Calendar current month

      def month

        @date.month

      end

      # Return the first day of week

      # 1 = Monday ... 7 = Sunday

      def first_wday

          @first_dow ||= (l(:general_first_day_of_week).to_i - 1)%7 + 1

        end

      end

      def last_wday

        @last_dow ||= (first_wday + 5)%7 + 1

      end

  end

end

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

      include ActionView::Helpers::TagHelper

      include ActionView::Helpers::TextHelper

      attr_reader :diff, :words

      def initialize(content_to, content_from)

        @words = content_to.to_s.split(/(\s+)/)

        @words = @words.select {|word| word != ' '}

        words_from = content_from.to_s.split(/(\s+)/)

        @diff = words_from.diff @words

      end

      def to_html

        words = self.words.collect{|word| h(word)}

        words_add = 0

          add_at = nil

          add_to = nil

          del_at = nil

          diff.each do |change|

            pos = change[1]

            if change[0] == "+"

            words_del = 0

          end

        end

      end

    end

  end

      def subject_for_project(project, options)

        case options[:format]

        when :html

          html_subject(options, subject, :css => "project-name")

        when :image

          image_subject(options, project.name)

      def subject_for_version(version, options)

        case options[:format]

        when :html

          html_subject(options, subject, :css => "version-name")

        when :image

          image_subject(options, version.to_s_with_project)

          css_classes << ' issue-behind-schedule' if issue.behind_schedule?

          css_classes << ' icon icon-issue' unless Setting.gravatar_enabled? && issue.assigned_to

          if issue.assigned_to.present?

            assigned_string = l(:field_assigned_to) + ": " + issue.assigned_to.name

          end

          html_subject(options, subject, :css => "issue-subject", :title => issue.subject) + "\n"

        when :image

          image_subject(options, issue.subject)

        output = ''

        # Renders the task bar, with progress and late

        if coords[:bar_start] && coords[:bar_end]

          if coords[:bar_late_end]

          end

          if coords[:bar_progress_end]

          end

        end

        # Renders the markers

        if options[:markers]

          if coords[:start]

          end

          if coords[:end]

          end

        end

        # Renders the label on the right

        if options[:label]

          output << options[:label]

        end

        # Renders the tooltip

        if options[:issue] && coords[:bar_start] && coords[:bar_end]

        end

        @lines << output

        output

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    @@listener_classes = []

    @@listeners = nil