axlsx 1.0.12 → 1.0.14

data/lib/axlsx/drawing/picture_locking.rb

@@ -0,0 +1,72 @@
+module Axlsx
+  # The picture locking class defines the locking properties for pictures in your workbook. 
+  class PictureLocking
+    
+    
+    attr_reader :noGrp
+    attr_reader :noSelect
+    attr_reader :noRot
+    attr_reader :noChangeAspect
+    attr_reader :noMove
+    attr_reader :noResize
+    attr_reader :noEditPoints
+    attr_reader :noAdjustHandles
+    attr_reader :noChangeArrowheads
+    attr_reader :noChangeShapeType
+
+    # Creates a new PictureLocking object
+    # @option options [Boolean] noGrp
+    # @option options [Boolean] noSelect
+    # @option options [Boolean] noRot
+    # @option options [Boolean] noChangeAspect
+    # @option options [Boolean] noMove
+    # @option options [Boolean] noResize
+    # @option options [Boolean] noEditPoints
+    # @option options [Boolean] noAdjustHandles
+    # @option options [Boolean] noChangeArrowheads
+    # @option options [Boolean] noChangeShapeType
+    def initialize(options={})
+      @noChangeAspect = true
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end        
+
+    # @see noGrp
+    def noGrp=(v) Axlsx::validate_boolean v; @noGrp = v end    
+
+    # @see noSelect
+    def noSelect=(v) Axlsx::validate_boolean v; @noSelect = v end    
+
+    # @see noRot
+    def noRot=(v) Axlsx::validate_boolean v; @noRot = v end    
+
+    # @see noChangeAspect
+    def noChangeAspect=(v) Axlsx::validate_boolean v; @noChangeAspect = v end    
+
+    # @see noMove
+    def noMove=(v) Axlsx::validate_boolean v; @noMove = v end    
+
+    # @see noResize
+    def noResize=(v) Axlsx::validate_boolean v; @noResize = v end    
+
+    # @see noEditPoints
+    def noEditPoints=(v) Axlsx::validate_boolean v; @noEditPoints = v end    
+
+    # @see noAdjustHandles
+    def noAdjustHandles=(v) Axlsx::validate_boolean v; @noAdjustHandles = v end    
+
+    # @see noChangeArrowheads
+    def noChangeArrowheads=(v) Axlsx::validate_boolean v; @noChangeArrowheads = v end    
+
+    # @see noChangeShapeType
+    def noChangeShapeType=(v) Axlsx::validate_boolean v; @noChangeShapeType = v end    
+
+    # Serializes the picture locking
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:a].picLocks(self.instance_values)      
+    end
+  end
+end

data/lib/axlsx/drawing/picture_locking.rb~

@@ -0,0 +1,36 @@
+module Axlsx
+  # The picture locking class defines the locking properties for pictures in your workbook. 
+  class PictureLocking
+    
+    
+    attr_reader :noGrp
+    attr_reader :noSelect
+    attr_reader :noRot
+    attr_reader :noChangeAspect
+    attr_reader :noMove
+    attr_reader :noResize
+    attr_reader :noEditPoints
+    attr_reader :noAdjustHandles
+    attr_reader :noChangeArrowheads
+    attr_reader :noChangeShapeType
+
+    # Creates a new PictureLocking object
+    # @option options [Boolean] noGrp
+    # @option options [Boolean] noSelect
+    # @option options [Boolean] noRot
+    # @option options [Boolean] noChangeAspect
+    # @option options [Boolean] noMove
+    # @option options [Boolean] noResize
+    # @option options [Boolean] noEditPoints
+    # @option options [Boolean] noAdjustHandles
+    # @option options [Boolean] noChangeArrowheads
+    # @option options [Boolean] noChangeShapeType
+    def initialize(options={})
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end        
+
+
+  end
+end

data/lib/axlsx/drawing/pie_3D_chart.rb

@@ -0,0 +1,41 @@
+module Axlsx
+
+
+  # The Pie3DChart is a three dimentional piechart (who would have guessed?) that you can add to your worksheet.
+  # @see Worksheet#add_chart
+  # @see Chart#add_series
+  # @see README for an example
+  class Pie3DChart < Chart
+
+    # Creates a new pie chart object
+    # @param [GraphicFrame] frame The workbook that owns this chart.
+    # @option options [Cell, String] title
+    # @option options [Boolean] show_legend    
+    # @option options [Symbol] grouping
+    # @option options [String] gapDepth
+    # @option options [Integer] rotX
+    # @option options [String] hPercent
+    # @option options [Integer] rotY
+    # @option options [String] depthPercent
+    # @option options [Boolean] rAngAx
+    # @option options [Integer] perspective
+    # @see Chart
+    # @see View3D
+    def initialize(frame, options={})
+      super(frame, options)
+      @series_type = PieSeries
+      @view3D = View3D.new({:rotX=>30, :perspective=>30}.merge(options))
+    end
+
+    # Serializes the pie chart
+    # @return [String]
+    def to_xml
+      super() do |xml|
+        xml[:c].pie3DChart {
+          xml[:c].varyColors :val=>1
+          @series.each { |ser| ser.to_xml(xml) }
+        }                      
+      end
+    end
+  end
+end

data/lib/axlsx/drawing/pie_series.rb

@@ -0,0 +1,56 @@
+module Axlsx
+  # A PieSeries defines the data and labels and explosion for pie charts series.
+  # @note The recommended way to manage series is to use Chart#add_series
+  # @see Worksheet#add_chart
+  # @see Chart#add_series
+  class PieSeries < Series
+
+    # The data for this series. 
+    # @return [SimpleTypedList]
+    attr_reader :data
+
+    # The labels for this series.
+    # @return [SimpleTypedList]
+    attr_reader :labels
+
+    # The explosion for this series
+    # @return [Integert]
+    attr_reader :explosion
+
+    # Creates a new series
+    # @option options [Array, SimpleTypedList] data
+    # @option options [Array, SimpleTypedList] labels
+    # @option options [String] title
+    # @option options [Integer] explosion
+    # @param [Chart] chart
+    def initialize(chart, options={})
+      @explosion = nil
+      super(chart, options)
+      self.labels = CatAxisData.new(options[:labels]) unless options[:labels].nil?
+      self.data = ValAxisData.new(options[:data]) unless options[:data].nil?
+    end 
+    
+    # @see explosion
+    def explosion=(v) Axlsx::validate_unsigned_int(v); @explosion = v; end
+
+    # Serializes the series
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      super(xml) do  |xml_inner|
+        xml_inner.explosion :val=>@explosion unless @explosion.nil?
+        @labels.to_xml(xml_inner) unless @labels.nil?
+        @data.to_xml(xml_inner) unless @data.nil?
+      end      
+    end
+    private 
+
+    # assigns the data for this series
+    def data=(v) DataTypeValidator.validate "Series.data", [SimpleTypedList], v; @data = v; end
+
+    # assigns the labels for this series
+    def labels=(v) DataTypeValidator.validate "Series.labels", [SimpleTypedList], v; @labels = v; end
+
+  end
+
+end

data/lib/axlsx/drawing/scaling.rb

@@ -0,0 +1,59 @@
+module Axlsx
+  # The Scaling class defines axis scaling
+  class Scaling
+
+    # logarithmic base for a logarithmic axis.
+    # must be between 2 and 1000
+    # @return [Integer]
+    attr_reader :logBase
+
+    # the orientation of the axis
+    # must be one of [:minMax, :maxMin]
+    # @return [Symbol]
+    attr_reader :orientation
+
+    # the maximum scaling
+    # @return [Float]
+    attr_reader :max
+
+    # the minimu scaling
+    # @return [Float]
+    attr_reader :min
+
+    # creates a new Scaling object
+    # @option options [Integer, Fixnum] logBase
+    # @option options [Symbol] orientation
+    # @option options [Float] max
+    # @option options [Float] min
+    def initialize(options={})
+      @orientation = :minMax
+      @logBase, @min, @max = nil, nil, nil
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+    
+    # @see logBase
+    def logBase=(v) DataTypeValidator.validate "Scaling.logBase", [Integer, Fixnum], v, lambda { |arg| arg >= 2 && arg <= 1000}; @logBase = v; end
+    # @see orientation
+    def orientation=(v) RestrictionValidator.validate "Scaling.orientation", [:minMax, :maxMin], v; @orientation = v; end
+    # @see max
+    def max=(v) DataTypeValidator.validate "Scaling.max", Float, v; @max = v; end
+
+    # @see min
+    def min=(v) DataTypeValidator.validate "Scaling.min", Float, v; @min = v; end
+
+    # Serializes the axId
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:c].scaling {
+        xml[:c].logBase :val=> @logBase unless @logBase.nil?
+        xml[:c].orientation :val=> @orientation unless @orientation.nil?
+        xml[:c].min :val => @min unless @min.nil?
+        xml[:c].max :val => @max unless @max.nil?
+      }
+    end
+
+  end
+end

data/lib/axlsx/drawing/ser_axis.rb

@@ -0,0 +1,45 @@
+module Axlsx
+  #A SerAxis object defines a series axis
+  class SerAxis < Axis
+
+    # The number of tick lables to skip between labels
+    # @return [Integer]
+    attr_reader :tickLblSkip
+
+    # The number of tickmarks to be skipped before the next one is rendered.
+    # @return [Boolean]
+    attr_reader :tickMarkSkip
+
+    # Creates a new SerAxis object
+    # @param [Integer] axId the id of this axis. Inherited
+    # @param [Integer] crossAx the id of the perpendicular axis. Inherited
+    # @option options [Symbol] axPos. Inherited
+    # @option options [Symbol] tickLblPos. Inherited
+    # @option options [Symbol] crosses. Inherited
+    # @option options [Integer] tickLblSkip
+    # @option options [Integer] tickMarkSkip
+    def initialize(axId, crossAx, options={})
+      @tickLblSkip, @tickMarkSkip = nil, nil
+      super(axId, crossAx, options)
+    end 
+
+    # @see tickLblSkip
+    def tickLblSkip=(v) Axlsx::validate_unsigned_int(v); @tickLblSkip = v; end
+
+    # @see tickMarkSkip
+    def tickMarkSkip=(v) Axlsx::validate_unsigned_int(v); @tickMarkSkip = v; end
+
+    # Serializes the series axis
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:c].serAx {
+        super(xml)
+        xml[:c].tickLblSkip :val=>@tickLblSkip unless @tickLblSkip.nil?
+        xml[:c].tickMarkSkip :val=>@tickMarkSkip unless @tickMarkSkip.nil?
+      }
+    end
+  end
+  
+
+end

data/lib/axlsx/drawing/series.rb

@@ -0,0 +1,71 @@
+module Axlsx
+  # A Series defines the common series attributes and is the super class for all concrete series types.
+  # @note The recommended way to manage series is to use Chart#add_series
+  # @see Worksheet#add_chart
+  # @see Chart#add_series
+  class Series
+
+    # The chart that owns this series
+    # @return [Chart]
+    attr_reader :chart
+
+    # The title of the series
+    # @return [SeriesTitle]
+    attr_reader :title
+
+    # Creates a new series
+    # @param [Chart] chart
+    # @option options [Integer] order
+    # @option options [String] title
+    def initialize(chart, options={})
+      @order = nil
+      self.chart = chart
+      @chart.series << self
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end    
+
+    # The index of this series in the chart's series.
+    # @return [Integer]
+    def index
+      @chart.series.index(self)
+    end
+
+
+    # The order of this series in the chart's series. By default the order is the index of the series.
+    # @return [Integer]
+    def order
+      @order || index
+    end
+
+    # @see order
+    def order=(v)  Axlsx::validate_unsigned_int(v); @order = v; end
+
+    # @see title
+    def title=(v) 
+      v = SeriesTitle.new(v) if v.is_a?(String) || v.is_a?(Cell)
+      DataTypeValidator.validate "#{self.class}.title", SeriesTitle, v
+      @title = v
+    end
+   
+    private 
+    
+    # assigns the chart for this series
+    def chart=(v)  DataTypeValidator.validate "Series.chart", Chart, v; @chart = v; end    
+
+    # Serializes the series
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml.ser {
+        xml.idx :val=>index
+        xml.order :val=>order || index
+        title.to_xml(xml) unless title.nil?
+        yield xml if block_given?
+      }
+    end
+
+  end
+
+end

data/lib/axlsx/drawing/series_title.rb

@@ -0,0 +1,22 @@
+module Axlsx
+  # A series title is a Title with a slightly different serialization than chart titles.
+  class SeriesTitle < Title
+
+    # Serializes the series title
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:c].tx {
+        xml[:c].strRef {
+          xml[:c].f Axlsx::cell_range([@cell])
+          xml[:c].strCache {
+            xml[:c].ptCount :val=>1
+            xml[:c].pt(:idx=>0) {
+              xml[:c].v @text
+            }
+          }
+        }
+      }
+    end
+  end
+end

data/lib/axlsx/drawing/title.rb

@@ -0,0 +1,65 @@
+module Axlsx
+  # A Title stores information about the title of a chart
+  class Title
+    
+    # The text to be shown. Setting this property directly with a string will remove the cell reference.
+    # @return [String]
+    attr_reader :text
+
+    # The cell that holds the text for the title. Setting this property will automatically update the text attribute.
+    # @return [Cell]
+    attr_reader :cell
+
+    # Creates a new Title object
+    # @param [String, Cell] title The cell or string to be used for the chart's title
+    def initialize(title="")
+      self.cell = title if title.is_a?(Cell)
+      self.text = title.to_s unless title.is_a?(Cell)
+    end
+    
+    # @see text
+    def text=(v) 
+      DataTypeValidator.validate 'Title.text', String, v
+      @text = v
+      @cell = nil
+      v
+    end
+
+    # @see cell
+    def cell=(v)
+      DataTypeValidator.validate 'Title.text', Cell, v
+      @cell = v
+      @text = v.value.to_s      
+      v
+    end
+
+    # Not implemented at this time.
+    #def layout=(v) DataTypeValidator.validate 'Title.layout', Layout, v; @layout = v; end
+    #def overlay=(v) Axlsx::validate_boolean v; @overlay=v; end
+    #def spPr=(v) DataTypeValidator.validate 'Title.spPr', SpPr, v; @spPr = v; end
+    
+    # Serializes the chart title
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:c].title {
+        unless @text.empty?
+          xml[:c].tx {
+            xml[:c].strRef {
+              xml[:c].f Axlsx::cell_range([@cell])
+              xml[:c].strCache {
+                xml[:c].ptCount :val=>1
+                xml[:c].pt(:idx=>0) {
+                  xml[:c].v @text
+                }
+              }
+            }
+          }
+        end
+        xml[:c].layout
+        xml[:c].overlay :val=>0
+      }      
+    end
+    
+  end
+end

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -0,0 +1,76 @@
+module Axlsx
+  # This class details the anchor points for drawings.
+  # @note The recommended way to manage drawings and charts is Worksheet#add_chart. Anchors are specified by the :start_at and :end_at options to that method.
+  # @see Worksheet#add_chart
+  class TwoCellAnchor
+
+    # A marker that defines the from cell anchor. The default from column and row are 0 and 0 respectively
+    # @return [Marker]
+    attr_reader :from
+    # A marker that returns the to cell anchor. The default to column and row are 5 and 10 respectively
+    # @return [Marker]
+    attr_reader :to
+
+    # The frame for your chart
+    # @note this will be discontinued in version 2.0 please use object
+    # @return [GraphicFrame]
+    # attr_reader :graphic_frame
+
+    # The object this anchor hosts
+    # @return [Pic, GraphicFrame]
+    attr_reader :object
+
+    # The drawing that holds this anchor
+    # @return [Drawing]
+    attr_reader :drawing
+
+
+    # Creates a new TwoCellAnchor object and sets up a reference to the from and to markers in the 
+    # graphic_frame's chart. That means that you can do stuff like
+    # c = worksheet.add_chart Axlsx::Chart
+    # c.start_at 5, 9
+    # @note the chart_type parameter will be replaced with object in v. 2.0.0
+    # @param [Drawing] drawing
+    # @param [Class] chart_type This is passed to the graphic frame for instantiation. must be Chart or a subclass of Chart
+    # @param object The object this anchor holds.
+    # @option options [Array] start_at the col, row to start at
+    # @option options [Array] end_at the col, row to end at
+    def initialize(drawing, options={})
+      @drawing = drawing
+      drawing.anchors << self      
+      @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
+    end
+
+    # Creates a graphic frame and chart object associated with this anchor
+    # @return [Chart]
+    def add_chart(chart_type, options)      
+      @object = GraphicFrame.new(self, chart_type, options)
+      @object.chart
+    end
+
+    # The index of this anchor in the drawing
+    # @return [Integer]
+    def index
+      @drawing.anchors.index(self)
+    end
+    # Serializes the two cell anchor
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      #build it for now, break it down later!
+      xml[:xdr].twoCellAnchor {
+        xml.from {
+          from.to_xml(xml)
+        }
+        xml.to {
+          to.to_xml(xml)
+        }
+        @object.to_xml(xml)
+        xml.clientData
+      }
+    end    
+
+    private
+
+  end
+end

data/lib/axlsx/drawing/val_axis.rb

@@ -0,0 +1,34 @@
+module Axlsx
+  # the ValAxis class defines a chart value axis.
+  class ValAxis < Axis
+
+    # This element specifies how the value axis crosses the category axis.
+    # must be one of [:between, :midCat]
+    # @return [Symbol]
+    attr_reader :crossBetween
+
+    # Creates a new ValAxis object
+    # @param [Integer] axId the id of this axis
+    # @param [Integer] crossAx the id of the perpendicular axis
+    # @option options [Symbol] axPos
+    # @option options [Symbol] tickLblPos
+    # @option options [Symbol] crosses
+    # @option options [Symbol] crossesBetween
+    def initialize(axId, crossAx, options={})
+      self.crossBetween = :between
+      super(axId, crossAx, options)
+    end
+    # @see crossBetween
+    def crossBetween=(v) RestrictionValidator.validate "ValAxis.crossBetween", [:between, :midCat], v; @crossBetween = v; end
+
+    # Serializes the value axis
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml.valAx {
+        super(xml)
+        xml.crossBetween :val=>@crossBetween
+      }
+    end
+  end
+end

data/lib/axlsx/drawing/val_axis_data.rb

@@ -0,0 +1,26 @@
+module Axlsx
+  # The ValAxisData class manages the values for a chart value series.
+  class ValAxisData < CatAxisData
+
+    # Serializes the value axis data
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml.val {
+        xml.numRef {
+          xml.f Axlsx::cell_range(@list)
+          xml.numCache {
+            xml.formatCode 'General'
+            xml.ptCount :val=>size
+            each_with_index do |item, index|
+              v = item.is_a?(Cell) ? item.value : item
+              xml.pt(:idx=>index) { xml.v v }
+            end
+          }                        
+        }
+      }
+    end
+
+  end
+  
+end

data/lib/axlsx/drawing/view_3D.rb

@@ -0,0 +1,85 @@
+module Axlsx
+  # 3D attributes for a chart.
+  class View3D
+
+    # Validation for hPercent
+    H_PERCENT_REGEX = /0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%/
+    
+    # validation for depthPercent
+    DEPTH_PERCENT_REGEX = /0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%/
+
+    # x rotation for the chart 
+    # must be between -90 and 90
+    # @return [Integer]
+    attr_reader :rotX
+    
+    # height of chart as % of chart
+    # must be between 5% and 500%
+    # @return [String]
+    attr_reader :hPercent
+    
+    # y rotation for the chart
+    # must be between 0 and 360
+    # @return [Integer]
+    attr_reader :rotY
+    
+    # depth or chart as % of chart width
+    # must be between 20% and 2000%
+    # @return [String]
+    attr_reader :depthPercent
+    
+    # Chart axis are at right angles
+    # @return [Boolean]
+    attr_reader :rAngAx
+    
+    # field of view angle
+    # @return [Integer]
+    attr_reader :perspective
+
+    # Creates a new View3D for charts
+    # @option options [Integer] rotX
+    # @option options [String] hPercent
+    # @option options [Integer] rotY
+    # @option options [String] depthPercent
+    # @option options [Boolean] rAngAx
+    # @option options [Integer] perspective
+    def initialize(options={})
+      @rotX, @hPercent, @rotY, @depthPercent, @rAngAx, @perspective  = nil, nil, nil, nil, nil, nil 
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end    
+    end
+
+    # @see rotX
+    def rotX=(v) DataTypeValidator.validate "#{self.class}.rotX", [Integer, Fixnum], v, lambda {|arg| arg >= -90 && arg <= 90 }; @rotX = v; end
+
+    # @see hPercent
+    def hPercent=(v) RegexValidator.validate "#{self.class}.rotX", H_PERCENT_REGEX, v; @hPercent = v; end
+
+    # @see rotY
+    def rotY=(v) DataTypeValidator.validate "#{self.class}.rotY", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 360 }; @rotY = v; end
+
+    # @see depthPercent
+    def depthPercent=(v) RegexValidator.validate "#{self.class}.depthPercent", DEPTH_PERCENT_REGEX, v; @depthPercent = v; end
+
+    # @see rAngAx
+    def rAngAx=(v) Axlsx::validate_boolean(v); @rAngAx = v; end
+
+    # @see perspective
+    def perspective=(v) DataTypeValidator.validate "#{self.class}.perspective", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
+
+    # Serializes the view3D properties
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml[:c].view3D {
+        xml[:c].rotX :val=>@rotX unless @rotX.nil?
+        xml[:c].hPercent :val=>@hPercent unless @hPercent.nil?
+        xml[:c].rotY :val=>@rotY unless @rotY.nil?
+        xml[:c].depthPercent :val=>@depthPercent unless @depthPercent.nil?
+        xml[:c].rAngAx :val=>@rAngAx unless @rAngAx.nil?
+        xml[:c].perspective :val=>@perspective unless @perspective.nil?
+      }
+    end
+  end
+end