rubyXL 3.3.21 → 3.4.17

data/lib/rubyXL/convenience_methods/cell.rb

@@ -0,0 +1,272 @@
+module RubyXL
+  module CellConvenienceMethods
+
+    def change_contents(data, formula_expression = nil)
+      validate_worksheet
+
+      if formula_expression then
+        self.datatype = nil
+        self.formula = RubyXL::Formula.new(:expression => formula_expression)
+      else
+        self.datatype = case data
+                        when Date, Numeric then nil
+                        else RubyXL::DataType::RAW_STRING
+                        end
+      end
+
+      data = workbook.date_to_num(data) if data.is_a?(Date)
+
+      self.raw_value = data
+    end
+
+    def remove_formula
+      self.formula = nil
+
+      calculation_chain = workbook && workbook.calculation_chain
+      calculation_cells = calculation_chain && calculation_chain.cells
+      calculation_cells && calculation_cells.reject! { |c|
+        c.ref.col_range.c == self.column && c.ref.row_range.begin == self.row
+      }
+    end
+
+    def get_border(direction)
+      validate_worksheet
+      get_cell_border.get_edge_style(direction)
+    end
+
+    def get_border_color(direction)
+      validate_worksheet
+      get_cell_border.get_edge_color(direction)
+    end
+
+    def change_horizontal_alignment(alignment = 'center')
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.horizontal = alignment }
+    end
+
+    def change_vertical_alignment(alignment = 'center')
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.vertical = alignment }
+    end
+
+    def change_text_wrap(wrap = false)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.wrap_text = wrap }
+    end
+
+    def change_text_rotation(rot)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.text_rotation = rot }
+    end
+
+    def change_text_indent(indent)
+      validate_worksheet
+      self.style_index = workbook.modify_alignment(self.style_index) { |a| a.indent = indent }
+    end
+
+    def change_border(direction, weight)
+      validate_worksheet
+      self.style_index = workbook.modify_border(self.style_index, direction, weight)
+    end
+
+    def change_border_color(direction, color)
+      validate_worksheet
+      Color.validate_color(color)
+      self.style_index = workbook.modify_border_color(self.style_index, direction, color)
+    end
+
+    def is_italicized()
+      validate_worksheet
+      get_cell_font.is_italic
+    end
+
+    def is_bolded()
+      validate_worksheet
+      get_cell_font.is_bold
+    end
+
+    def is_underlined()
+      validate_worksheet
+      get_cell_font.is_underlined
+    end
+
+    def is_struckthrough()
+      validate_worksheet
+      get_cell_font.is_strikethrough
+    end
+
+    def font_name()
+      validate_worksheet
+      get_cell_font.get_name
+    end
+
+    def font_size()
+      validate_worksheet
+      get_cell_font.get_size
+    end
+
+    def font_color()
+      validate_worksheet
+      get_cell_font.get_rgb_color || '000000'
+    end
+
+    def fill_color()
+      validate_worksheet
+      return workbook.get_fill_color(get_cell_xf)
+    end
+
+    def horizontal_alignment()
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.horizontal
+    end
+
+    def vertical_alignment()
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.vertical
+    end
+
+    def text_wrap()
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.wrap_text
+    end
+    
+    def text_rotation
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.text_rotation    
+    end
+
+    def text_indent()
+      validate_worksheet
+      xf_obj = get_cell_xf
+      return nil if xf_obj.alignment.nil?
+      xf_obj.alignment.indent
+    end
+
+    def set_number_format(format_code)
+      new_xf = get_cell_xf.dup
+      new_xf.num_fmt_id = workbook.stylesheet.register_number_format(format_code)
+      new_xf.apply_number_format = true
+      self.style_index = workbook.register_new_xf(new_xf)
+    end
+
+    # Changes fill color of cell
+    def change_fill(rgb = 'ffffff')
+      validate_worksheet
+      Color.validate_color(rgb)
+      self.style_index = workbook.modify_fill(self.style_index, rgb)
+    end
+
+    # Changes font name of cell
+    def change_font_name(new_font_name = 'Verdana')
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_name(new_font_name)
+      update_font_references(font)
+    end
+
+    # Changes font size of cell
+    def change_font_size(font_size = 10)
+      validate_worksheet
+      raise 'Argument must be a number' unless font_size.is_a?(Integer) || font_size.is_a?(Float)
+
+      font = get_cell_font.dup
+      font.set_size(font_size)
+      update_font_references(font)
+    end
+
+    # Changes font color of cell
+    def change_font_color(font_color = '000000')
+      validate_worksheet
+      Color.validate_color(font_color)
+
+      font = get_cell_font.dup
+      font.set_rgb_color(font_color)
+      update_font_references(font)
+    end
+
+    # Changes font italics settings of cell
+    def change_font_italics(italicized = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_italic(italicized)
+      update_font_references(font)
+    end
+
+    # Changes font bold settings of cell
+    def change_font_bold(bolded = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_bold(bolded)
+      update_font_references(font)
+    end
+
+    # Changes font underline settings of cell
+    def change_font_underline(underlined = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_underline(underlined)
+      update_font_references(font)
+    end
+
+    def change_font_strikethrough(struckthrough = false)
+      validate_worksheet
+
+      font = get_cell_font.dup
+      font.set_strikethrough(struckthrough)
+      update_font_references(font)
+    end
+
+    # Helper method to update the font array and xf array
+    def update_font_references(modified_font)
+      xf = workbook.register_new_font(modified_font, get_cell_xf)
+      self.style_index = workbook.register_new_xf(xf)
+    end
+    private :update_font_references
+
+    # Performs correct modification based on what type of change_type is specified
+    def font_switch(change_type, arg)
+      case change_type
+      when Worksheet::NAME          then change_font_name(arg)
+      when Worksheet::SIZE          then change_font_size(arg)
+      when Worksheet::COLOR         then change_font_color(arg)
+      when Worksheet::ITALICS       then change_font_italics(arg)
+      when Worksheet::BOLD          then change_font_bold(arg)
+      when Worksheet::UNDERLINE     then change_font_underline(arg)
+      when Worksheet::STRIKETHROUGH then change_font_strikethrough(arg)
+      else raise 'Invalid change_type'
+      end
+    end
+
+=begin
+    def add_hyperlink(l)
+      worksheet.hyperlinks ||= RubyXL::Hyperlinks.new
+      worksheet.hyperlinks << RubyXL::Hyperlink.new(:ref => self.r, :location => l)
+#    define_relationship
+#    define_attribute(:location, :string)
+#    define_attribute(:tooltip,  :string)
+#    define_attribute(:display,  :string)
+
+    end
+
+    def add_shared_string(str)
+      self.datatype = RubyXL::DataType::SHARED_STRING
+      self.raw_value = @workbook.shared_strings_container.add(str)
+    end
+=end
+
+  end
+
+  RubyXL::Cell.send(:include, RubyXL::CellConvenienceMethods) # ruby 2.1 compat
+end

data/lib/rubyXL/convenience_methods/color.rb

@@ -0,0 +1,160 @@
+module RubyXL
+  module ColorConvenienceMethods
+
+    def get_rgb(workbook)
+      if rgb then
+        return rgb
+      elsif theme then
+        theme_color = workbook.theme.get_theme_color(theme)
+        rgb_color = theme_color && theme_color.a_srgb_clr
+        color_value = rgb_color && rgb_color.val
+        return nil if color_value.nil?
+
+        RubyXL::RgbColor.parse(color_value).to_hls.apply_tint(tint).to_rgb.to_s
+      end
+    end
+
+  end
+
+  module ColorConvenienceClasses
+    # https://ciintelligence.blogspot.com/2012/02/converting-excel-theme-color-and-tint.html
+    class RgbColor
+      attr_accessor :r, :g, :b, :a
+
+      def to_hls
+        hls_color = HlsColor.new
+
+        # Note that we are overriding accessors with local vars here:
+        r = self.r / 255.0
+        g = self.g / 255.0
+        b = self.b / 255.0
+
+        hls_color.a = (self.a || 0) / 255.0
+
+        min = [r, g, b].min
+        max = [r, g, b].max
+        delta = max - min
+
+        if (max == min) then
+          hls_color.h = hls_color.s = 0
+          hls_color.l = max
+          return hls_color
+        end
+
+        hls_color.l = (min + max) / 2
+
+        if (hls_color.l < 0.5) then
+          hls_color.s = delta / (max + min);
+        else
+          hls_color.s = delta / (2.0 - max - min);
+        end
+
+        hls_color.h = (g - b) / delta       if (r == max)
+        hls_color.h = 2.0 + (b - r) / delta if (g == max)
+        hls_color.h = 4.0 + (r - g) / delta if (b == max)
+
+        hls_color.h *= 60;
+        hls_color.h += 360 if hls_color.h < 0
+
+        hls_color
+      end
+
+      def self.parse(str)
+        r, g, b, a = str.unpack("A2A2A2A2")
+
+        rgb_color = RgbColor.new
+        rgb_color.r = r && r.to_i(16)
+        rgb_color.g = g && g.to_i(16)
+        rgb_color.b = b && b.to_i(16)
+        rgb_color.a = a && a.to_i(16)
+
+        rgb_color
+      end
+
+      def to_s
+        if a && a != 0 then
+          "%02x%02x%02x%02x" % [ r, g, b, a ]
+        else
+          "%02x%02x%02x" % [ r, g, b ]
+        end
+      end
+
+    end
+
+    class HlsColor
+      attr_accessor :h, :l, :s, :a
+
+      def to_rgb
+        rgb_color = RgbColor.new
+
+        r = g = b = l
+
+        if s != 0 then
+          t1 = nil
+
+          if l < 0.5 then
+            t1 = l * (1.0 + s)
+          else
+            t1 = l + s - (l * s)
+          end
+
+          t2 = 2.0 * l - t1;
+          h = self.h / 360.0
+
+          t_r = h + (1.0 / 3.0)
+          r = set_color(t1, t2, t_r)
+
+          t_g = h;
+          g = set_color(t1, t2, t_g)
+
+          t_b = h - (1.0 / 3.0);
+          b = set_color(t1, t2, t_b)
+        end
+
+        rgb_color.r = (r * 255).round(0).to_i
+        rgb_color.g = (g * 255).round(0).to_i
+        rgb_color.b = (b * 255).round(0).to_i
+
+        rgb_color.a = (a * 255).round(0).to_i
+
+        rgb_color
+      end
+
+      def set_color(t1, t2, t3)
+        color = 0
+
+        t3 += 1.0 if (t3 < 0)
+        t3 -= 1.0 if (t3 > 1)
+
+        if (6.0 * t3 < 1) then
+          color = t2 + (t1 - t2) * 6.0 * t3;
+        elsif (2.0 * t3 < 1) then
+          color = t1;
+        elsif (3.0 * t3 < 2) then
+          color = t2 + (t1 - t2) * ((2.0 / 3.0) - t3) * 6.0;
+        else
+          color = t2;
+        end
+
+        color
+      end
+      private :set_color
+
+      def apply_tint(tint)
+        return self if tint.nil? || tint == 0
+
+        if tint < 0 then
+          self.l = l * (1.0 + tint);
+        else
+          self.l = l * (1.0 - tint) + tint;
+        end
+
+        self
+      end
+
+    end
+  end
+
+  RubyXL::Color.send(:include, RubyXL::ColorConvenienceMethods) # ruby 2.1 compat
+  include(RubyXL::ColorConvenienceClasses)
+end

data/lib/rubyXL/convenience_methods/font.rb

@@ -0,0 +1,63 @@
+module RubyXL
+  module FontConvenienceMethods
+    # Funny enough, but presence of <i> without value (equivalent to `val == nul`) means "italic = true"!
+    # Same is true for bold, strikethrough, etc
+    def is_italic
+      i && (i.val != false)
+    end
+
+    def is_bold
+      b && (b.val != false)
+    end
+
+    def is_underlined
+      u && (u.val != false)
+    end
+
+    def is_strikethrough
+      strike && (strike.val != false)
+    end
+
+    def get_name
+      name && name.val
+    end
+
+    def get_size
+      sz && sz.val
+    end
+
+    def get_rgb_color
+      color && color.rgb
+    end
+
+    def set_italic(val)
+      self.i = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_bold(val)
+      self.b = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_underline(val)
+      self.u = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_strikethrough(val)
+      self.strike = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def set_name(val)
+      self.name = RubyXL::StringValue.new(:val => val)
+    end
+
+    def set_size(val)
+      self.sz = RubyXL::FloatValue.new(:val => val)
+    end
+
+    def set_rgb_color(font_color)
+      self.color = RubyXL::Color.new(:rgb => font_color.to_s)
+    end
+  end
+
+  RubyXL::Font.send(:include, RubyXL::FontConvenienceMethods) # ruby 2.1 compat
+end