axlsx 1.0.0 → 1.0.1

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

@@ -0,0 +1,92 @@
+module Axlsx
+  # A BarSeries defines the title, data and labels for bar charts
+  # @note The recommended way to manage series is to use Chart#add_series
+  # @see Worksheet#add_chart
+  # @see Chart#add_series
+  class BarSeries < Series
+
+    # The series title.
+    # @return [String]
+    attr_accessor :title
+   
+    # The data for this series. 
+    # @return [Array, SimpleTypedList]
+    attr_reader :data
+
+
+    # The labels for this series.
+    # @return [Array, SimpleTypedList]
+    attr_reader :labels
+
+
+    # Creates a new series
+    # @option options [Array, SimpleTypedList] data
+    # @option options [Array, SimpleTypedList] labels
+    # @option options [String] title
+    # @param [Chart] chart
+    def initialize(chart, options={})
+      super(chart, options)
+      self.data = options[:data]  || []
+      self.labels = options[:labels] || []
+      @title = options[:title] || ''
+    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.send('c:ser') {
+        xml.send('c:idx', :val=>index)
+        xml.send('c:order', :val=>index)
+        xml.send('c:tx') {
+          xml.send('c:v', self.title)
+        }
+        
+        if !labels.empty?
+          xml.send('c:cat') {
+            xml.send('c:strRef') {
+              xml.send('c:f', range(labels))
+              xml.send('c:strCache') {
+                xml.send('c:ptCount', :val=>labels.size)
+                labels.each_with_index do |cell, index|
+                  v = cell.is_a?(Cell) ? cell.value : cell
+                  xml.send('c:pt', :idx=>index) {
+                    xml.send('c:v', v)
+                  }                          
+                end
+              }
+            }
+          }
+        end
+        xml.send('c:val') {
+          xml.send('c:numRef') {
+            xml.send('c:f', range(data))
+            xml.send('c:numCache') {
+              xml.send('c:formatCode', 'General')
+              xml.send('c:ptCount', :val=>data.size)
+              data.each_with_index do |cell, index|
+                v = cell.is_a?(Cell) ? cell.value : cell
+                xml.send('c:pt', :idx=>index) {
+                  xml.send('c:v', v) 
+                }
+              end
+            }                        
+          }
+        }
+      }                  
+      
+    end
+
+    
+    private 
+
+
+    # assigns the data for this series
+    def data=(v) DataTypeValidator.validate "Series.data", [Array, SimpleTypedList], v; @data = v; end
+
+    # assigns the labels for this series
+    def labels=(v) DataTypeValidator.validate "Series.labels", [Array, SimpleTypedList], v; @labels = v; end
+
+  end
+
+end

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

@@ -0,0 +1,32 @@
+module Axlsx
+
+  #A CatAxis object defines a chart category axis
+  class CatAxis
+    # <c:catAx>                                                                                                              
+    #   <c:axId val="545184360"/>                                                                                            
+    #   <c:scaling>                                                                                                          
+    #     <c:orientation val="minMax"/>                                                                                      
+    #   </c:scaling>                                                                                                         
+    #   <c:axPos val="l"/>                                                                                                   
+    #   <c:tickLblPos val="nextTo"/>                                                                                         
+    #   <c:crossAx val="545218840"/>                                                                                         
+    #   <c:crosses val="autoZero"/>                                                                                          
+    #   <c:auto val="1"/>                                                                                                    
+    #   <c:lblAlgn val="ctr"/>                                                                                               
+    #   <c:lblOffset val="100"/>                                                                                             
+    # </c:catAx> 
+
+    attr_reader :axId
+
+    att_reader :scaling
+    
+    # The position of the axis
+    # must be one of [:l, :r, :t, :b]
+    # @return [String]
+    attr_accessor :axPos
+    
+    def axPos=(v) RestrictionValidator.validate "CatAxis.axPos", [:l, :r, :b, :t], v; @axPos = v; end
+    
+
+  end
+end

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

@@ -0,0 +1,102 @@
+module Axlsx
+  # A Drawing is a canvas for charts. Each worksheet has a single drawing that can specify multiple anchors which reference charts.
+  # @note The recommended way to manage drawings is to use the Worksheet.add_chart method, specifying the chart class, start and end marker locations. 
+  # @see Worksheet#add_chart
+  # @see TwoCellAnchor
+  # @see Chart
+  class Drawing
+
+    # The workbook that owns the drawing
+    # @return [Workbook]
+    attr_reader :workbook
+    
+    # A collection of anchors for this drawing
+    # @return [SimpleTypedList]
+    attr_reader :anchors
+
+    # An array of charts that are associated with this drawing's anchors
+    # @return [Array]
+    attr_reader :charts
+
+    # The index of this drawing in the owning workbooks's drawings collection.
+    # @return [Integer]
+    attr_reader :index
+
+    # The relation reference id for this drawing
+    # @return [String]
+    attr_reader :rId
+
+    # The part name for this drawing
+    # @return [String]
+    attr_reader :pn
+
+    # The relational part name for this drawing
+    # @return [String]
+    attr_reader :rels_pn
+
+    # The drawing's relationships.
+    # @return [Relationships]
+    attr_reader :relationships
+
+    # Creates a new Drawing object
+    # @param [Workbook] workbook The workbook that owns the drawing.
+    def initialize(workbook)
+      DataTypeValidator.validate "Drawing.workbook", Workbook, workbook
+      @workbook=workbook
+      @workbook.drawings << self
+      @anchors = SimpleTypedList.new TwoCellAnchor
+    end
+    
+
+    # Adds a chart to the drawing. 
+    # @note The recommended way to manage charts is to use Worksheet.add_chart.
+    # @param [Chart] chart_type The class of the chart to be added to the drawing
+    # @param [Hash] options
+    def add_chart(chart_type, options={})
+      DataTypeValidator.validate "Drawing.chart_type", [Chart, Pie3DChart], chart_type 
+      chart = chart_type.new(@workbook, options)
+      TwoCellAnchor.new(self, chart, options)
+      @anchors.last.graphic_frame.chart
+    end
+    
+    def charts
+      @anchors.map { |a| a.graphic_frame.chart }
+    end
+
+    def index
+      @workbook.drawings.index(self)
+    end
+
+    def rId
+      "rId#{index+1}"
+    end
+
+    def pn
+      "#{DRAWING_PN % (index+1)}"
+    end
+    
+    def rels_pn
+      "#{DRAWING_RELS_PN % (index+1)}"
+    end
+
+    def relationships
+      r = Relationships.new
+      @anchors.each do |anchor|
+        chart = anchor.graphic_frame.chart
+        r << Relationship.new(CHART_R, "../#{chart.pn}")
+      end
+      r
+    end
+
+    # Serializes the pie chart
+    # @return [String]
+    def to_xml
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.send('xdr:wsDr', :'xmlns:xdr'=>XML_NS_XDR, :'xmlns:a'=>XML_NS_A) {
+          anchors.each {|anchor| anchor.to_xml(xml) }
+        }        
+      end
+      builder.to_xml
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Axlsx
+  # A graphic frame defines a container for a chart object
+  # @note The recommended way to manage charts is Worksheet#add_chart
+  # @see Worksheet#add_chart
+  class GraphicFrame
+    #TODO add in support for other graphical objects, primarily images.
+    
+    # A reference to the chart object associated with this frame
+    # @return [Chart]
+    attr_reader :chart
+
+    # Creates a new GraphicFrame object
+    # @param [Chart] chart
+    def initialize(chart)
+      @chart = chart
+    end
+
+    # Serializes the gradientStop
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      xml.send('xdr:graphicFrame') {        
+        xml.send('xdr:nvGraphicFramePr') {
+          xml.send('xdr:cNvPr', :id=>2, :name=>chart.title)
+          xml.send('xdr:cNvGraphicFramePr')                
+        }
+        xml.send('xdr:xfrm') {
+          xml.send('a:off', :x=>0, :y=>0)
+          xml.send('a:ext', :cx=>0, :cy=>0)
+        }
+        xml.send('a:graphic') {
+          xml.send('a:graphicData', :uri=>XML_NS_C) {
+            xml.send('c:chart', :'xmlns:c'=>XML_NS_C, :'xmlns:r'=>XML_NS_R, :'r:id'=>chart.rId)
+          }
+        }
+      }
+      
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Axlsx
+  # The Marker class defines a point in the worksheet that drawing anchors attach to.
+  # @note The recommended way to manage markers is Worksheet#add_chart Markers are created for a two cell anchor based on the :start and :end options.
+  # @see Worksheet#add_chart
+  class Marker
+
+    # The column this marker anchors to
+    # @return [Integer]
+    attr_accessor :col
+
+    # The offset distance from this marker's column
+    # @return [Integer]
+    attr_accessor :colOff
+
+    # The row this marker anchors to
+    # @return [Integer]
+    attr_accessor :row
+
+    # The offset distance from this marker's row
+    # @return [Integer]
+    attr_accessor :rowOff
+
+    # Creates a new Marker object
+    # @option options [Integer] col
+    # @option options [Integer] colOff
+    # @option options [Integer] row
+    # @option options [Integer] rowOff
+    def initialize(options={})
+      @col, @colOff, @row, @rowOff = 0, 0, 0, 0
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? o[0]
+      end      
+    end
+    
+    def col=(v) Axlsx::validate_unsigned_int v; @col = v end
+    def colOff=(v) Axlsx::validate_int v; @colOff = v end
+    def row=(v) Axlsx::validate_unsigned_int v; @row = v end
+    def rowOff=(v) Axlsx::validate_int v; @rowOff = v end
+
+    # Serializes the gradientStop
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      [:col, :colOff, :row, :rowOff].each do |k|
+        xml.send("xdr:#{k.to_s}", self.send(k))
+      end      
+    end
+  end
+
+end

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

@@ -0,0 +1,132 @@
+module Axlsx
+
+  # A Chart is the class that real classes (e.g. Pie3DChart) inherit from. When you actually create a chart, you will not be creating a new instance of this class, but an instance of a subclass that defines the behavour and serialization for the chart.
+  # @note Worksheet#add_chart is the recommended way to create charts for your worksheets.
+  class Chart
+
+    # The title object for the chart.
+    # @return [Title]
+    attr_reader :title
+
+    # A reference to the workbook that owns this chart
+    # @return [Workbook]
+    attr_reader :workbook
+
+    # A collection of series objects that are applied to the chart
+    # @return [SimpleTypedList]
+    attr_reader :series
+
+    # The relation referece id for this object.
+    # @return [String]
+    attr_reader :rId
+    
+    # The index of this chart in the workbooks charts collection
+    # @return [Integer]
+    attr_reader :index
+
+    # The part name for this chart
+    # @return [String]
+    attr_reader :pn
+
+   
+    # Creates a new chart object
+    # @param [Workbook] workbook The workbook that owns this chart.
+    # @option options [Cell, String] title
+    def initialize(workbook, options={})
+      @workbook=workbook
+      @workbook.charts << self
+      @title = Title.new options[:title]      
+      @series = SimpleTypedList.new Series
+    end
+    
+
+    def rId
+      "rId#{index+1}"
+    end
+
+    def index
+      @workbook.charts.index(self)
+    end
+
+    def pn
+      "#{CHART_PN % (index+1)}"
+    end
+
+    # Adds a new series to the chart's series collection.
+    # 
+    # @return [Series]
+    # @see Series
+    def add_series(options={})
+      Series.new(self, options)
+      @series.last
+    end
+
+    # @raise [StandardError] This method must be overridden in subclasses.
+    def to_xml
+      raise "This method must be overriden in subclasses."
+    end
+  end
+
+  # The Pie3DChart is a three dimentional piechart (who would have guessed?) that you can add to your worksheet.
+  # @example Creating a chart
+  #   # This example creates two charts in a single sheet.
+  #   # The first uses data directly fed to the sheet, while the second references cells withing the worksheet for data.
+  #
+  #   require "rubygems" # if that is your preferred way to manage gems!
+  #   require "axlsx"
+  #
+  #   p = Axlsx::Package.new
+  #   ws = p.workbook.add_worksheet
+  #   ws.add_row :values => ["This is a chart with no data in the sheet"]
+  #
+  #   chart = ws.add_chart(Axlsx::Pie3DChart, :start_at=> [0,1], :end_at=>[0,6], :title=>"Most Popular Pets")
+  #   chart.add_series :data => [1, 9, 10], :labels => ["Slimy Reptiles", "Fuzzy Bunnies", "Rottweiler"]
+  # 
+  #   ws.add_row :values => ["This chart uses the data below"]
+  #   title_row = ws.add_row :values => ["Least Popular Pets"]
+  #   label_row = ws.add_row :values => ["", "Dry Skinned Reptiles", "Bald Cats", "Violent Parrots"]
+  #   data_row = ws.add_row :values => ["Votes", 6, 4, 1]
+  #   
+  #   chart = ws.add_chart(Axlsx::Pie3DChart, :start_at => [0,11], :end_at =>[0,16], :title => title_row.cells.last)
+  #   chart.add_series :data => data_row.cells[(1..-1)], :labels => label_row.cells  
+  #
+  #   f = File.open('example_pie_3d_chart.xlsx', 'w')
+  #   p.serialize(f)
+  #
+  # @see Worksheet#add_chart
+  # @see Worksheet#add_row
+  # @see Chart#add_series
+  # @see Series
+  # @see Package#serialize
+  class Pie3DChart < Chart
+
+    # Serializes the pie chart
+    # @return [String]
+    def to_xml
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.send('c:chartSpace',:'xmlns:c' => XML_NS_C,
+                 :'xmlns:a' => XML_NS_A) {
+          xml.send('c:chart') {
+            @title.to_xml(xml)            
+            xml.send('c:view3D') {
+              xml.send('c:rotX', :val=>30)
+              xml.send('c:perspective', :val=>30)
+            }
+            xml.send('c:plotArea') {
+              xml.send('c:layout')
+              xml.send('c:pie3DChart') {
+                xml.send('c:varyColors', :val=>1)
+                @series.each { |ser| ser.to_xml(xml) }
+              }              
+            }
+            xml.send('c:legend') {
+              xml.send('c:legendPos', :val => "r")
+              xml.send('c:layout')
+            }
+          }
+        }
+      end
+      builder.to_xml
+    end
+  end
+end