Redmine

  before_filter :find_issue, :only => [:show, :edit, :reply, :destroy_attachment ]

  before_filter :find_project, :only => [:new, :auto_complete_for_issue_parent, :add_subissue, :update_form, :preview ]

  before_filter :authorize, :except => [:index, :changes, :gantt, :calendar, :preview, :update_form, :context_menu, :auto_complete_for_issue_parent ]

  before_filter :find_optional_project, :only => [:index, :changes, :gantt, :calendar ]

  include ActionView::Helpers::PrototypeHelper

  def auto_complete_for_issue_parent

    @phrase = params[:issue_parent]

    @candidates = []

    # If cross project issue relations is allowed we should get

    # candidates from every project

    if Setting.cross_project_issue_relations?

      projects_to_search = nil

    else

      projects_to_search = [ @project ] + @project.active_children

    end

    # Try to find issue by id.

    if @phrase.match(/^#?(\d+)$/)

      if Setting.cross_project_issue_relations?

        issue = Issue.find_by_id( $1)

      else

        issue = Issue.find_by_id_and_project_id( $1, projects_to_search.collect { |i| i.id})

      end

      @candidates = [ issue ] if issue

    end

    # If finding by id is fail, try to find by searching in subject

    # and description.

    if @candidates.empty?

      # extract tokens from the question

      # eg. hello "bye bye" => ["hello", "bye bye"]

      tokens = @phrase.scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)}).collect {|m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '')}

      # tokens must be at least 3 character long

      tokens = tokens.uniq.select {|w| w.length > 2 }

      like_tokens = tokens.collect {|w| "%#{w.downcase}%"}      

      @candidates, count = Issue.search( like_tokens, projects_to_search, :before => true)

    end

    render :inline => "<%= auto_complete_result_parent_issue( @candidates, @phrase) %>"

  end

      @issues = Issue.find( :all, :order => sort_clause,

                            :include => [ :assigned_to,

                                          :status,

                                          :tracker,

                                          :project,

                                          :priority,

                                          :category,

                                          :fixed_version ],

                            :conditions => @query.statement,

                            :limit  => limit,

                            :offset => @issue_pages.current.offset)

    @parent_issue = Issue.find( params[:issue_parent_issue_id]) unless params[:issue_parent_issue_id].blank?

        set_parent( @issue, params[:issue_parent_issue_id]) if params[:issue_parent_issue_id]

  def add_subissue

    if params[:issue_parent_issue_id].nil?

      flash.now[:error] = 'No parent issue specified.'

      render :nothing => true, :layout => true

      return

    else

      redirect_to( :controller => 'issues', :action => 'new',

                   :issue_parent_issue_id => params[:issue_parent_issue_id])

      return

    end

  end

        set_parent(@issue, params[:issue_parent_issue_id]) if params[:issue_parent_issue_id]

          set_parent(issue, params[:issue_parent_issue_id]) unless params[:issue_parent_issue_id].blank?

    @parent_issue = @issue.parent

    @parent_issue = @issue.parent

        if params[:view_options] and params[:view_options].is_a? Hash

          params[:view_options].each_pair do |name, value|

            @query.set_view_option( name, value)

          end

        end

        session[:query] = {

          :project_id => @query.project_id,

          :filters => @query.filters,

          :view_options => @query.view_options

        }

        @query ||= Query.new(:name => "_",

                             :project => @project,

                             :filters => session[:query][:filters],

                             :view_options => session[:query][:view_options])

  helper :versions

  include VersionsHelper

  def sort_as_tree(issues)

    issues.sort!{|a,b| a.hierarchical_level <=> b.hierarchical_level}

    @sorted_issues = []

    issues.each do |issue|

      if @sorted_issues.empty?

        @sorted_issues << issue

        next

      end

      @time_to_stop = false #indicates when this task reaches its parent task (important because it has to stop between its parent task and the next aunt task

      @sorted_issues.each do |sorted_issue|

        #if same parent and smaller date, stop; if same parent, same date and smaller id, stop; after parent and before next parent, stop; 

        if ((sorted_issue.parent == issue.parent) && (sorted_issue.start_date > issue.start_date)) ||

         ((sorted_issue.parent == issue.parent) && (sorted_issue.start_date == issue.start_date) && (sorted_issue.id > issue.id)) ||

         (@time_to_stop && (sorted_issue.hierarchical_level < issue.hierarchical_level))

          @sorted_issues.insert(@sorted_issues.index(sorted_issue), issue)

          break

        end

        @time_to_stop = true if sorted_issue == issue.parent      

      end

      #if this issue's parent is the last element

      @sorted_issues << issue if @time_to_stop

    end

    @sorted_issues

  end

  #assumes that first level issues are ordered by date (sort_as_tree)

  def integrate_versions_with_issues_tree(issues, versions)

    versions.sort! {|x,y| x.start_date <=> y.start_date }    

    versions.each do |version|

      issues << version if issues.empty?

      issues.each do |issue|

        if ((issue.is_a? Issue && issue.root?) || (issue.is_a? Version)) && version.start_date < issue.start_date

          #insert version before a root task or another version whose date is immediately after this task's one 

          issues.insert(issues.index(issue), version)

        elsif issue == issues.last

          issues << version        

        end

      end

    end

    issues

  end  

    params[:view_options].each_pair do |name, value|

      @query.set_view_option( name, value)

    end if params[:view_options]

      params[:view_options].each_pair do |name, value|

        @query.set_view_option( name, value)

      end if params[:view_options]

    @issues = @version.fixed_issues.find(:all,

                                         :include => [:status, :tracker],

                                         :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id")

    @issues = Issue.find_with_parents( @issues.collect { |i| i.id})

  def issue_ancestors(issue=@issue)

    ancestors = ""

    return "" if issue.parent == nil

    ancestors += "issue-#{issue.parent.id}-child " + issue_ancestors(issue.parent)        

  end

  def set_parent(issue, parent_id)

    if (issue && parent_id.to_s.size > 0)

      issue.relations_from.each do |relation|

        if relation.relation_type == IssueRelation::TYPE_PARENTS

          relation.destroy

        end

      end

      issue.reload

      IssueRelation.create do |relation|

        relation.issue_from = issue

        relation.issue_to = Issue.find(parent_id)

        relation.relation_type = IssueRelation::TYPE_PARENTS

        unless relation.save

          flash[:error] = "Can't set ##{parent_id} as parent for the issue."

        end

      end unless parent_id == '0'

    end    

  end

  def auto_complete_result_parent_issue(candidates, phrase)

    return "" if candidates.empty?

    candidates.map! do |c|

      content_tag("li", highlight( c.to_s, phrase), :id => String( c[:id]))

    end

    content_tag("ul", candidates.uniq)

  end

# -*- coding: mule-utf-8 -*-

  def column_content(column, issue, query)

          subject_in_tree(issue, value, query)

  def subject_in_tree(issue, value, query)

    case query.view_options['show_parents']

    when Query::VIEW_OPTIONS_SHOW_PARENTS_NEVER

      content_tag('div', subject_text(issue, value), :class=>'issue-subject')

    else

      content_tag('span', content_tag('div', subject_text(issue, value), :class=>'issue-subject'), :class=>"issue-subject-level-#{issue.hierarchical_level}")

    end

  end

  def subject_text(issue, value)

    subject_text = link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)

    h((@project.nil? || @project != issue.project) ? "#{issue.project.name} - " : '') + subject_text

  end

  def issue_content(issue, query, options = { })

    html = ""

    html << "<tr id=\"issue-#{issue.id}\" class=\"issue hascontextmenu " +

      ( options[:unfiltered] ? 'issue-unfiltered ' : '') +

      "status-#{issue.status.position} priority-#{issue.priority.position} " +

      cycle('odd', 'even') + '">'

    html << '<td class="checkbox">' + check_box_tag( "ids[]", issue.id, false, :id => nil) + '</td>'

    html << '<td>' + link_to( issue.id, :controller => 'issues', :action => 'show', :id => issue) + '</td>'

    query.columns.each do |column|

      html << content_tag( 'td', column_content(column, issue, query), :class => column.name)

    end

    html << "</tr>"

    html

  end

  def issues_family_content( parent, issues_to_show, query)

    html = ""

    html << issue_content( parent, query, :unfiltered => !( issues_to_show.include? parent))

    unless  parent.children.empty?

      parent.children.each do |child|

        if issues_to_show.include?( child) || issues_to_show.detect { |i| i.parents_hierarchy.include? child }

          html << issues_family_content( child, issues_to_show, query)

        end

      end

    end

    html

  end

  def render_list_of_related_issues( issues, version, current_level = 1)

    issues_on_current_level = issues.select { |i| i.hierarchical_level == current_level }

    issues -= issues_on_current_level

    content_tag( 'ul') do

      html = ''

      issues_on_current_level.each do |issue|

        opts_for_issue_li = { }

        if !issue.fixed_version or issue.fixed_version != version

          opts_for_issue_li[:class] = 'issue-unfiltered'

        end

        html << content_tag( 'li', opts_for_issue_li) do

          opts = { }

          if issue.done_ratio == 100

            opts[:style] = 'font-weight: bold'

          end

          link_to_issue(issue, opts)  + ": " + h(issue.subject)

        end

        children_to_print = issues & issue.children

        children_to_print += issues.select { |i| i.hierarchical_level >= current_level + 2}

        unless children_to_print.empty?

          html << render_list_of_related_issues( children_to_print, version, current_level + 1)

        end

      end

      html

    end

  end

  belongs_to :status,        :class_name => 'IssueStatus',   :foreign_key => 'status_id'

  belongs_to :author,        :class_name => 'User',          :foreign_key => 'author_id'

  belongs_to :assigned_to,   :class_name => 'User',          :foreign_key => 'assigned_to_id'

  belongs_to :fixed_version, :class_name => 'Version',       :foreign_key => 'fixed_version_id'

  belongs_to :priority,      :class_name => 'Enumeration',   :foreign_key => 'priority_id'

  belongs_to :category,      :class_name => 'IssueCategory', :foreign_key => 'category_id'

  has_many :relations_to,   :class_name => 'IssueRelation', :foreign_key => 'issue_to_id',   :dependent => :delete_all

    if IssueStatus.find_by_id( @attributes['status_id']).is_closed? && children.find { |i| !i.closed? }

      errors.add :status, "Can't close parent issue while on of the children still is open."

    end

    unless children.empty?

      children_max_fixed_version = children.select { |i| i.fixed_version } .max { |a,b| a.fixed_version <=> b.fixed_version }

      if @attributes['fixed_version_id'] && children_max_fixed_version

        if Version.find_by_id( @attributes['fixed_version_id']) < children_max_fixed_version.fixed_version

          errors.add :fixed_version, "Can't set target version of parent issue lower than any of the children."

        end

      end

    end

                                                      :value => send(c)) unless send(c)==@issue_before_change.send(c) || (!self.edge? && %w(status_id priority_id fixed_version_id start_date due_date done_ratio estimated_hours).include?(c))

    # If target version is set, but "Due to" date is not, set it as

    # the same as the date of target version.

    if self.fixed_version && self.due_date.nil?

      self.due_date = self.fixed_version.due_date if self.fixed_version.due_date

    end

    # Set default status of parent if new status openes the issue.

    relations_from.each do |relation|

      if relation.relation_type == IssueRelation::TYPE_PARENTS

        relation.set_issue_to_default_status

        relation.set_issue_to_target_version

      end

    end

  def priority_id=(pid)

    self.priority = nil

    write_attribute(:priority_id, pid)

  end

    due_date || (fixed_version ? fixed_version.effective_date : 0)

  end

  def duration1

    (start_date && due_date) ? (due_date - start_date + 1) : 0

  def self.visible_by(usr)

    with_scope(:find => { :conditions => Project.visible_by(usr) }) do

      yield

    end

  end

  def done_ratio

    if children?

      @total_planned_days ||= 0

      @total_actual_days ||= 0

      children.each do |child| # from every subtask get the total number of days and the number of days already "worked"

        planned_days = child.duration1

        actual_days = child.done_ratio ?  (planned_days * child.done_ratio / 100).floor : 0

        @total_planned_days += planned_days

        @total_actual_days += actual_days

      end

      @total_done_ratio = @total_planned_days != 0 ? (@total_actual_days * 100 / @total_planned_days).floor : 0

    else

      read_attribute(:done_ratio)

    end

  end

  def estimated_hours

    if children?

      is_set = false

      children.each do |child|

        if child.estimated_hours

          if is_set

            @est_hours += child.estimated_hours

          else

            @est_hours = child.estimated_hours

            is_set = true

          end

        end     

      end

      @est_hours

    else

      read_attribute(:estimated_hours)

    end

  end

  def start_date

    calculate 'start_date'

  end  

  def due_date

    calculate 'due_date'

  end  

  def calculate(field)

    if children?

      @value = eval "children.first.#{field}" 

      children.each do |child|        

        case field

          when 'start_date'

          if child.start_date && (!@value || @value > child.start_date)

            @value = child.start_date

          end

          when 'due_date'

          if child.due_date && (!@value || @value < child.due_date)

            @value = child.due_date

          end

        end        

      end

      @value

    else

      read_attribute(eval(":#{field}"))

    end

  end  

  def children?

    children != []

  end

  def children

    children = []

    relations_to.each do |relation|

      if relation.relation_type == IssueRelation::TYPE_PARENTS

        children << relation.other_issue(self)

      end

    end

    children

  end

  def parent

    relations_from.each do |relation|

      if relation.relation_type == IssueRelation::TYPE_PARENTS

        return parent = relation.other_issue(self)

      end

    end

    return nil

  end

  def parents_hierarchy

    return [] unless p = parent

    parents = [ p ]

    while p = p.parent

      parents += [ p ]

    end

    parents

  end

  def parent?

    parent != nil

  end 

  def root?

    !parent?

  end

  def ancestors(issue=self)

    a = []

    return a if ! issue.parent?

    (a << issue.parent) | ancestors(issue.parent)

  end

  #First level tasks have hierarchical level = 1 and so on

  def hierarchical_level(issue=self)

    issue.parent? ? (1 + hierarchical_level(issue.parent)) : 1

  end

  def edge?

    relations_to.each do |relation|

      if relation.relation_type == IssueRelation::TYPE_PARENTS

        return false

      end

    end

    return true

  end

  def orphan?

    root? && edge?

  end

  def self.find_with_parents( *args)

    issues = find( *args)

    return [] if issues.empty?

    issues.each do |i|

      while not i.root?

        issues += [ i.parent ]

        i = i.parent

      end

    end

    issues.uniq

  end

  belongs_to :issue_to,   :class_name => 'Issue', :foreign_key => 'issue_to_id'

  TYPE_PARENTS      = "parents"

  TYPES = { TYPE_RELATES    => { :name => :label_relates_to, :sym_name => :label_relates_to,    :order => 1 },

            TYPE_DUPLICATES => { :name => :label_duplicates, :sym_name => :label_duplicated_by, :order => 2 },

            TYPE_BLOCKS     => { :name => :label_blocks,     :sym_name => :label_blocked_by,    :order => 3 },

            TYPE_PRECEDES   => { :name => :label_precedes,   :sym_name => :label_follows,       :order => 4 },

            TYPE_PARENTS    => { :name => :label_parents,    :sym_name => :label_children,      :order => 5 },

  validates_presence_of     :issue_from,    :issue_to, :relation_type 

  validates_inclusion_of    :relation_type, :in        => TYPES.keys

  validates_numericality_of :delay,         :allow_nil => true

  validates_uniqueness_of   :issue_to_id,   :scope     => :issue_from_id

  # Only one parent allowed.

  validates_uniqueness_of( :relation_type,

                           :scope   => [:issue_from_id, :relation_type],

                           :message => l(:error_issue_can_have_only_one_parent),

                           :if      => Proc.new { |issue_relation| issue_relation.relation_type == TYPE_PARENTS })

    # Set new status to parent if new status openes the issue.

    if TYPE_PARENTS == relation_type

      set_issue_to_default_status

      set_issue_to_target_version

    end

  def set_issue_to_default_status

    if issue_to.closed? && !issue_from.closed?

      issue_to.update_attribute :status, IssueStatus.default

    end

  end

  def set_issue_to_target_version

    if issue_to.fixed_version.nil? && issue_from.fixed_version or

        ( issue_to.fixed_version && issue_from.fixed_version and

          issue_to.fixed_version.project == issue_from.fixed_version.project and

          issue_to.fixed_version < issue_from.fixed_version )

      issue_to.update_attribute :fixed_version, issue_from.fixed_version

    end

  end

class ViewOption

  attr_accessor :name, :available_values

  include GLoc

  def initialize( name, available_values)

    self.name = name

    self.available_values = available_values

  end

  def caption

    set_language_if_valid( User.current.language)

    l("label_view_option_#{name}")

  end

end

  serialize :view_options

  VIEW_OPTIONS_SHOW_PARENTS_NEVER              = 'do_not_show'

  VIEW_OPTIONS_SHOW_PARENTS_ALWAYS             = 'show_always'

  VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT = 'organize_by_parent'

  @@available_view_options = [

    ViewOption.new( 'show_parents', [ [ l(:label_view_option_parents_do_not_show), VIEW_OPTIONS_SHOW_PARENTS_NEVER ],

                                      [ l(:label_view_option_parents_show_always), VIEW_OPTIONS_SHOW_PARENTS_ALWAYS ],

                                      [ l(:label_view_option_parents_show_and_group), VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT ] ])

  ]

  cattr_reader :available_view_options

    self.view_options ||=  { 'show_parents' => 'do_not_show' }

  def set_view_option( option, value)

    self.view_options[option] = value

  end

  def values_for_view_option( option)

    @@available_view_options.find { |vo| vo.name == option }.available_values

  end

  def caption_for_view_option( option)

    @@available_view_options.find { |vo| vo.name == option }.caption

  end

  include Comparable

    <% if authorize_for('timelog', 'edit') && @issue.edge? %>

<!-- This function is needed for get ID from the text field with parent issue selection. -->

<script type="text/javascript">

  //<![CDATA[

  function setParentIssueValue(element, value) {

          document.getElementById('issue_parent_issue_id').value = value.id;

      }

//]]>

</script>

<% if (@issue.new_record? || @allowed_statuses.any?) %>

<% if @issue.edge? %>	

<% else %>

<p><label><%= l(:field_start_date) %></label> <%= format_date(@issue.start_date) %></p>

<p><label><%= l(:field_due_date) %></label> <%= format_date(@issue.due_date) %></p>

<p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>

<% end %>

<%= content_tag( :input, {}, 

		 :id => :issue_parent_issue_id,

		 :type => :hidden,

		 :name => 'issue_parent_issue_id', :value => @parent_issue ? @parent_issue.id : "") %>

<p><label><%= l(:field_parent_issue) %></label>

<% if authorize_for( 'issues', 'add_subissue') %>

  <%= text_field_with_auto_complete( :issue, :parent,

				     { :name => 'issue_parent', :value => @parent_issue || "" },

				     :url => { :action => 'auto_complete_for_issue_parent', :project_id => @project},

				     :after_update_element => 'setParentIssueValue') %>

<% else %>

  <%= @parent_issue || "-" %>

<% end %>

</p>

<% if @issue.edge? %>

<% else %>

<p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>

<% end %>

<% form_tag({}) do -%>

  <table class="list issues">

                :title => "#{l(:button_check_all)}/#{l(:button_uncheck_all)}" %>

	<%= sort_header_tag('id', :caption => '#', :default_order => 'desc') %>

      </tr></thead>

    <tbody>

      <% if query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_NEVER -%>

	  <%= issue_content( issue, query) %>

      <% elsif query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_ALWAYS -%>

	<% issues.each do |issue| -%>

	  <% issue.parents_hierarchy.reverse.each do |parent_issue| -%>

	    <%= issue_content( parent_issue, query, :unfiltered => true) %>

	  <% end -%>

	  <%= issue_content( issue, query) %>

	<% end -%>

      <% elsif query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT -%>

	<% parents_on_first_lvl = []

	   issues.each do |i|

	     if i.parent

	       first_parent = i.parents_hierarchy.last

	     else

	       first_parent = i

	     end

	     parents_on_first_lvl += [ first_parent ] unless parents_on_first_lvl.include?( first_parent)

	   end -%>

	<% parents_on_first_lvl.each do |parent| -%>

	  <%= issues_family_content( parent, issues, query) %>

	<% end -%>

      <% end -%>

    </tbody>

  </table>

	<% if @issue && @issue.edge? %>

	<% end %>

    <fieldset id="view"><legend><%= l(:label_view) %></legend>

      <%= render :partial => 'queries/view_options', :locals => {:query => @query } %>

    </fieldset>

      <%= render :partial => 'queries/filters', :locals => {:query => @query} %>

    </fieldset>

<%= link_to_if_authorized(l(:button_add_subissue),

			  { :controller => 'issues', :action => 'add_subissue',

			    :project_id => @project.id, :issue_parent_issue_id => @issue.id },

			  :class => 'icon icon-add') %>

   <% end %>

<% end %>

    <%

       unless @selected_tracker_ids.empty?

	 issues = version.fixed_issues.find(:all,

                                           :include => [:status, :tracker],

                                           :conditions => ["tracker_id in (#{@selected_tracker_ids.join(',')})"],

                                           :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id") 

         issues = Issue.find_with_parents( issues.collect { |i| i.id })

       end

      <%= render_list_of_related_issues( issues, version) %>

<fieldset><legend><%= l(:label_view) %></legend>

  <%= render :partial => 'queries/view_options', :locals => {:query => query } %>

</fieldset>

<% query.view_options.each_key do |voption| -%>

  <%= query.caption_for_view_option( voption) %>:

  <%= select_tag( "view_options[#{voption}]",

		  options_for_select( query.values_for_view_option( voption),

				      query.view_options[voption])) %>

<% end %>

<% if @issues.size > 0 %>

<%= render_list_of_related_issues( @issues, @version) %>

class AddQueriesViewOptions < ActiveRecord::Migration

  def self.up

    add_column :queries, :view_options, :text

  end

  def self.down

    remove_column :queries, :view_options

  end

end

class AddDefaultValueOfViewOptionQueries < ActiveRecord::Migration

  def self.up

    Query.find(:all).each do |q|

      q.view_options ||= { 'show_parents' => 'do_not_show' }

      q.save!

    end

  end

  def self.down

  end

end

error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).

field_calendar_firstday: First day of week

field_parent: Subproject of

field_parent_issue: Child of

field_parent_title: Parent page

label_children: parent of

label_parents: child of

label_view_option_parents_do_not_show: Never

label_view_option_parents_show_always: Always

label_view_option_parents_show_and_group: Organize by parent

label_view_option_show_parents: Show parents

button_add_subissue: Add sub-issue

    map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit, :update_subject]}

    map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy], :issues => :add_subissue}

            xml = REXML::Document.new(entries)

            revision = xml.elements['wc-entries'].elements[1].attributes['revision'].to_i

          end

        rescue

          # Could not find the current revision

        end

      end

      revision

    end

    def self.warecorp_revision

      begin

        tag = %x{ git name-rev --tags `git log -1 --pretty=format:'%H'` }.split[1]

        tag = ( tag.match %r{tags/(.*)})[1]

      rescue

        tag = "undefined"

      end

      tag

    WARECORP_REVISION = self.warecorp_revision

    STRING = ARRAY.join('.') + " / #{WARECORP_REVISION}"

/***** Subtasks *****/

/*blocks composed of icon (+, - or none), project identification (if there is one) and link to the task*/

.issue-subject-level-1, .issue-subject-level-1 .issue-subject { 

    margin-left: 0em;

}

.issue-subject-level-2, .issue-subject-level-2 .issue-subject { 

    margin-left: 1em;

}

.issue-subject-level-3, .issue-subject-level-3 .issue-subject { 

    margin-left: 2em;

}

.issue-subject-level-4, .issue-subject-level-4 .issue-subject { 

    margin-left: 3em;

}

.issue-subject-level-5, .issue-subject-level-5 .issue-subject { 

    margin-left: 4em;

}

.issue-subject-level-2, .issue-subject-level-2 .issue-subject, .issue-subject-level-3, .issue-subject-level-3 .issue-subject, .issue-subject-level-4, .issue-subject-level-4 .issue-subject, .issue-subject-level-5, .issue-subject-level-5 .issue-subject { 

    background-image: url(../images/corner-dots.gif);

    background-repeat: no-repeat;

    background-position: -3px center;

}

/* Used to show issues which is not pass by filter, but should by

   shown as parent for other issue. */

.issue-unfiltered {

    opacity: 0.5;

    filter: alpha(opacity=50);

}

.expanded-issue {

	background-image: url(contract.png);

	background-repeat: no-repeat;

}

.contracted-issue {

	background-image: url(expand.png);

	background-repeat: no-repeat;

}

.expand-icon, .contract-icon{

/* 	position: absolute; */

	vertical-align: middle;

}

/*text after the icon, which needs to be indented so that all its lines stay completely after the icon*/

.issue-subject{

	padding-left: 1em;

}

  view_options: |

    ---

    show_parents: "do_not_show"

  view_options: |

    ---

    show_parents: "do_not_show"

  view_options: |

    ---

    show_parents: "do_not_show"

  view_options: |

    ---

    show_parents: "do_not_show"

onlinestore_1_0: 

  created_on: 2006-07-19 21:00:33 +02:00

  name: "1.0"

  project_id: 1

  updated_on: 2006-07-19 21:00:33 +02:00

  id: 4

  description: Future version

  effective_date: 

           :queries,