write_xlsx 1.12.3 → 1.15.0

data/lib/write_xlsx/worksheet/print_options.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Writexlsx
+  class Worksheet
+    # Print and display options extracted from Worksheet to slim the main class.
+    module PrintOptions
+      #
+      # Set the page orientation as portrait.
+      # The default worksheet orientation is portrait, so you won't generally
+      # need to call this method.
+      #
+      def set_portrait
+        @page_setup.orientation        = true
+        @page_setup.page_setup_changed = true
+      end
+
+      #
+      # Set the page orientation as landscape.
+      #
+      def set_landscape
+        @page_setup.orientation         = false
+        @page_setup.page_setup_changed  = true
+      end
+
+      #
+      # This method is used to display the worksheet in "Page View/Layout" mode.
+      #
+      def set_page_view(flag = 1)
+        @page_view = flag
+      end
+
+      #
+      # set_pagebreak_view
+      #
+      # Set the page view mode.
+      #
+      def set_pagebreak_view
+        @page_view = 2
+      end
+
+      #
+      # Set the colour of the worksheet tab.
+      #
+      def tab_color=(color)
+        @tab_color = Colors.new.color(color)
+      end
+
+      # This method is deprecated. use tab_color=().
+      def set_tab_color(color)
+        put_deprecate_message("#{self}.set_tab_color")
+        self.tab_color = color
+      end
+
+      #
+      # Store the horizontal page breaks on a worksheet.
+      #
+      def set_h_pagebreaks(*args)
+        breaks = args.collect do |brk|
+          Array(brk)
+        end.flatten
+        @page_setup.hbreaks += breaks
+      end
+
+      #
+      # Store the vertical page breaks on a worksheet.
+      #
+      def set_v_pagebreaks(*args)
+        @page_setup.vbreaks += args
+      end
+    end
+  end
+end

data/lib/write_xlsx/worksheet/protection.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Writexlsx
+  class Worksheet
+    # Protection-related operations extracted from Worksheet to slim the main class.
+    module Protection
+      #
+      # Set the worksheet protection flags to prevent modification of worksheet
+      # objects.
+      #
+      def protect(password = nil, options = {})
+        check_parameter(options, protect_default_settings.keys, 'protect')
+        @protect = protect_default_settings.merge(options)
+
+        # Set the password after the user defined values.
+        if password && password != ''
+          @protect[:password] =
+            encode_password(password)
+        end
+      end
+
+      #
+      # Unprotect ranges within a protected worksheet.
+      #
+      def unprotect_range(range, range_name = nil, password = nil)
+        if range.nil?
+          raise "The range must be defined in unprotect_range())\n"
+        else
+          range = range.gsub("$", "")
+          range = range.sub(/^=/, "")
+          @num_protected_ranges += 1
+        end
+
+        range_name ||= "Range#{@num_protected_ranges}"
+        password   &&= encode_password(password)
+
+        @protected_ranges << [range, range_name, password]
+      end
+
+      protected
+
+      def protect_default_settings  # :nodoc:
+        {
+          sheet:                 true,
+          content:               false,
+          objects:               false,
+          scenarios:             false,
+          format_cells:          false,
+          format_columns:        false,
+          format_rows:           false,
+          insert_columns:        false,
+          insert_rows:           false,
+          insert_hyperlinks:     false,
+          delete_columns:        false,
+          delete_rows:           false,
+          select_locked_cells:   true,
+          sort:                  false,
+          autofilter:            false,
+          pivot_tables:          false,
+          select_unlocked_cells: true
+        }
+      end
+    end
+  end
+end

data/lib/write_xlsx/worksheet/rich_text_helpers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Writexlsx
+  class Worksheet
+    module RichTextHelpers
+      def cell_format_of_rich_string(rich_strings)
+        # If the last arg is a format we use it as the cell format.
+        rich_strings.pop if rich_strings[-1].respond_to?(:xf_index)
+      end
+
+      #
+      # Convert the list of format, string tokens to pairs of (format, string)
+      # except for the first string fragment which doesn't require a default
+      # formatting run. Use the default for strings without a leading format.
+      #
+      def rich_strings_fragments(rich_strings) # :nodoc:
+        # Create a temp format with the default font for unformatted fragments.
+        default = Format.new(0)
+
+        last = 'format'
+        pos  = 0
+        raw_string = ''
+
+        fragments = []
+        rich_strings.each do |token|
+          if token.respond_to?(:xf_index)
+            # Can't allow 2 formats in a row
+            return nil if last == 'format' && pos > 0
+
+            # Token is a format object. Add it to the fragment list.
+            fragments << token
+            last = 'format'
+          else
+            # Token is a string.
+            if last == 'format'
+              # If previous token was a format just add the string.
+              fragments << token
+            else
+              # If previous token wasn't a format add one before the string.
+              fragments << default << token
+            end
+
+            raw_string += token    # Keep track of actual string length.
+            last = 'string'
+          end
+          pos += 1
+        end
+        [fragments, raw_string]
+      end
+
+      def xml_str_of_rich_string(fragments)
+        # Create a temp XML::Writer object and use it to write the rich string
+        # XML to a string.
+        writer = Package::XMLWriterSimple.new
+
+        # If the first token is a string start the <r> element.
+        writer.start_tag('r') unless fragments[0].respond_to?(:xf_index)
+
+        # Write the XML elements for the format string fragments.
+        fragments.each do |token|
+          if token.respond_to?(:xf_index)
+            # Write the font run.
+            writer.start_tag('r')
+            token.write_font_rpr(writer, self)
+          else
+            # Write the string fragment part, with whitespace handling.
+            attributes = []
+
+            attributes << ['xml:space', 'preserve'] if token =~ /^\s/ || token =~ /\s$/
+            writer.data_element('t', token, attributes)
+            writer.end_tag('r')
+          end
+        end
+        writer.string
+      end
+    end
+  end
+end

data/lib/write_xlsx/worksheet/row_col_sizing.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+require 'write_xlsx/utility/string_width'
+
+module Writexlsx
+  class Worksheet
+    module RowColSizing
+      include Writexlsx::Utility::StringWidth
+
+      #
+      # Convert the width of a cell from user's units to pixels. Excel rounds
+      # the column width to the nearest pixel. If the width hasn't been set
+      # by the user we use the default value. A hidden column is treated as
+      # having a width of zero unless it has the special "object_position" of
+      # 4 (size with cells).
+      #
+      def size_col(col, anchor = 0)
+        info = col_info[col]
+        calculate_col_pixels(
+          info&.width,
+          info&.hidden,
+          anchor
+        )
+      end
+
+      #
+      # Convert the height of a cell from user's units to pixels. If the height
+      # hasn't been set by the user we use the default value. A hidden row is
+      # treated as having a height of zero unless it has the special
+      # "object_position" of 4 (size with cells).
+      #
+      def size_row(row, anchor = 0)
+        info = row_sizes[row]
+        calculate_row_pixels(
+          info&.first,
+          info&.last,
+          anchor
+        )
+      end
+
+      private
+
+      def calculate_col_pixels(width, hidden, anchor)
+        width ||= @default_col_width
+
+        return DEFAULT_COL_PIXELS unless width
+
+        if hidden == 1 && anchor != 4
+          0
+        elsif width < 1
+          ((width * (MAX_DIGIT_WIDTH + PADDING)) + 0.5).to_i
+        else
+          ((width * MAX_DIGIT_WIDTH) + 0.5).to_i + PADDING
+        end
+      end
+
+      def calculate_row_pixels(height, hidden, anchor)
+        height ||= default_row_height
+
+        if hidden == 1 && anchor != 4
+          0
+        else
+          (4 / 3.0 * height).to_i
+        end
+      end
+    end
+  end
+end

data/lib/write_xlsx/worksheet/rows.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Writexlsx
+  class Worksheet
+    # Row-related operations extracted from Worksheet to slim the main class.
+    module Rows
+      #
+      # :call-seq:
+      #   set_row(row [ , height, format, hidden, level, collapsed ])
+      #
+      # This method can be used to change the default properties of a row.
+      # All parameters apart from +row+ are optional.
+      #
+      def set_row(*args)
+        return unless args[0]
+
+        row = args[0]
+        height = args[1] || @default_height
+        xf     = args[2]
+        hidden = args[3] || 0
+        level  = args[4] || 0
+        collapsed = args[5] || 0
+
+        # Use min col in check_dimensions. Default to 0 if undefined.
+        min_col = @dim_colmin || 0
+
+        # Check that row and col are valid and store max and min values.
+        check_dimensions(row, min_col)
+        store_row_col_max_min_values(row, min_col)
+
+        height ||= @default_row_height
+
+        # If the height is 0 the row is hidden and the height is the default.
+        if height == 0
+          hidden = 1
+          height = @default_row_height
+        end
+
+        # Set the limits for the outline levels (0 <= x <= 7).
+        level = 0 if level < 0
+        level = 7 if level > 7
+
+        @outline_row_level = level if level > @outline_row_level
+
+        # Store the row properties.
+        @set_rows[row] = [height, xf, hidden, level, collapsed]
+
+        # Store the row change to allow optimisations.
+        @row_size_changed = true
+
+        # Store the row sizes for use when calculating image vertices.
+        @row_sizes[row] = [height, hidden]
+      end
+
+      #
+      # This method is used to set the height (in pixels) and the properties of the
+      # row.
+      #
+      def set_row_pixels(*data)
+        height = data[1]
+
+        data[1] = pixels_to_height(height) if ptrue?(height)
+        set_row(*data)
+      end
+
+      #
+      # Set the default row properties
+      #
+      def set_default_row(height = nil, zero_height = nil)
+        height      ||= @original_row_height
+        zero_height ||= 0
+
+        if height != @original_row_height
+          @default_row_height = height
+
+          # Store the row change to allow optimisations.
+          @row_size_changed = 1
+        end
+
+        @default_row_zeroed = 1 if ptrue?(zero_height)
+      end
+    end
+  end
+end

data/lib/write_xlsx/worksheet/selection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Writexlsx
+  class Worksheet
+    # Selection-related operations extracted from Worksheet to slim the main class.
+    module Selection
+      #
+      # :call-seq:
+      #   set_selection(cell_or_cell_range)
+      #
+      # Set which cell or cells are selected in a worksheet.
+      #
+      def set_selection(*args)
+        return if args.empty?
+
+        if (row_col_array = row_col_notation(args.first))
+          row_first, col_first, row_last, col_last = row_col_array
+        else
+          row_first, col_first, row_last, col_last = args
+        end
+
+        active_cell = xl_rowcol_to_cell(row_first, col_first)
+
+        if row_last  # Range selection.
+          # Swap last row/col for first row/col as necessary
+          row_first, row_last = row_last, row_first if row_first > row_last
+          col_first, col_last = col_last, col_first if col_first > col_last
+
+          sqref = xl_range(row_first, row_last, col_first, col_last)
+        else          # Single cell selection.
+          sqref = active_cell
+        end
+
+        # Selection isn't set for cell A1.
+        return if sqref == 'A1'
+
+        @selections = [[nil, active_cell, sqref]]
+      end
+    end
+  end
+end