Redmine

      # fetch row values

      def fetch_row_values(issue, query, level)

        query.columns.collect do |column|

          s = if column.is_a?(QueryCustomFieldColumn)

            cv = issue.custom_values.detect {|v| v.custom_field_id == column.custom_field.id}

            show_value(cv)

          else

            value = issue.send(column.name)

            if column.name == :subject

              value = "  " * level + value

            end

            if value.is_a?(Date)

              format_date(value)

            elsif value.is_a?(Time)

              format_time(value)

            else

              value

            end

          end

          s.to_s

        end

      end

      # calculate columns width

      def calc_col_width(issues, query, table_width, pdf)

          # calculate statistics

          #  by captions

          col_width_min = query.columns.map {|v| pdf.GetStringWidth(v.caption)}

          col_width_max = Array.new(col_width_min)

          col_width_avg = Array.new(col_width_min)

          word_width_max = query.columns.map {|c| 

            n = 10

            c.caption.split.each {|w| 

              x = pdf.GetStringWidth(w)

              n = x if n < x

            }

            n

          }

          #  by properties of issues

          k = 1

          issue_list(issues) {|issue, level|

            k += 1

            values = fetch_row_values(issue, query, level)

            values.each_with_index {|v,i| 

              n = pdf.GetStringWidth(v.rstrip)

              col_width_max[i] = n if col_width_max[i] < n

              col_width_min[i] = n if col_width_min[i] > n

              col_width_avg[i] += n

              v.split.each {|w| 

                x = pdf.GetStringWidth(w); 

                word_width_max[i] = x if word_width_max[i] < x

              }

            }

          }

          col_width_avg.map! {|x| x / k}

          # calculate columns width

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

          col_width = col_width_avg.map {|w| w * ratio}

          # correct max word width if too many columns

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

          word_width_max.map! {|v| v * ratio} if ratio < 1

          # correct and lock width of some columns

          done = 1

          col_fix = []

          col_width.each_with_index do |w,i| 

            if w > col_width_max[i]

              col_width[i] = col_width_max[i]

              col_fix[i] = 1

              done = 0

            elsif w < word_width_max[i]

              col_width[i] = word_width_max[i]

              col_fix[i] = 1

              done = 0

            else

              col_fix[i] = 0

            end

          end

          # iterate while need to correct and lock coluns width

          while done == 0 

            # calculate free & locked columns width

            done = 1

            fix_col_width = 0

            free_col_width = 0

            col_width.each_with_index do |w,i|

              if col_fix[i] == 1

                fix_col_width += w

              else

                free_col_width += w

              end

            end

            # calculate column normalizing ratio

            if free_col_width == 0

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

            else

              ratio = (table_width - fix_col_width) / free_col_width

            end

            # correct columns width

            col_width.each_with_index do |w,i| 

              if col_fix[i] == 0

                col_width[i] = w * ratio

                # check if column width less then max word width

                if col_width[i] < word_width_max[i]

                  col_width[i] = word_width_max[i]

                  col_fix[i] = 1

                  done = 0

                end

              end

            end

          end 

          # calculate columns alignment

          @col_align = col_width.map {|x| x < table_width / col_width.count ? 'C' : 'L'}

          col_width

      end

      def render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)

        # headers

        pdf.SetFontStyle('B',8)

        pdf.SetFillColor(230, 230, 230)

        # render it background to find the max height used

        base_x = pdf.GetX

        base_y = pdf.GetY

        max_height = issues_to_pdf_write_cells(pdf, query.columns, col_width, row_height, true)

        pdf.Rect(base_x, base_y, table_width, max_height, 'FD');

        pdf.SetXY(base_x, base_y);

        # write the cells on page

        pdf.RDMCell(col_id_width, row_height, "#", "T", 0, 'C', 1)

        issues_to_pdf_write_cells(pdf, query.columns, col_width, row_height, true)

        issues_to_pdf_draw_borders(pdf, base_x, base_y, base_y + max_height, col_id_width, col_width)

        pdf.SetY(base_y + max_height);

        # rows

        pdf.SetFontStyle('',8)

        pdf.SetFillColor(255, 255, 255)

      end

          col_width = calc_col_width(issues, query, table_width - col_id_width, pdf)

          table_width = col_width.inject(0) {|s,v| s += v}

        render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)

            ## ***** conflict

            # pdf.SetFontStyle('B',10)

            # pdf.RDMCell(table_width + col_id_width, row_height * 2,

            #   (group.blank? ? '  None' : '  ' + group.to_s) + " (#{query.issue_count_by_group[group]})",

            #   1, 1, 'L')

          # fetch row values

          col_values = fetch_row_values(issue, query, level)

            render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)

        @col_align ||= []

            pdf.RDMMultiCell(col_widths[i], row_height, column.caption, "T", 'C', 1)

            @col_align[i] = 'L' if @col_align[i].nil?

            pdf.RDMMultiCell(col_widths[i], row_height, column, "T", @col_align[i], 1)