ruby_pptx 0.1.0

data/lib/ruby_pptx/oxml/shapes/autoshape.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/oxml/shapes/shared"
+require "ruby_pptx/oxml/text"
+
+module Pptx
+  module Oxml
+    # `a:avLst`, the adjustment values of a preset geometry.
+    class CT_GeomGuideList < Element
+      tag "a:avLst"
+      zero_or_more "a:gd", as: :gd
+    end
+
+    # `a:gd`, one geometry guide (adjustment value).
+    class CT_GeomGuide < Element
+      tag "a:gd"
+      required_attr "name", type: SimpleTypes::XsdString
+      required_attr "fmla", type: SimpleTypes::XsdString
+    end
+
+    # `a:prstGeom`, a preset (built-in) shape geometry.
+    class CT_PresetGeometry2D < Element
+      tag "a:prstGeom"
+      zero_or_one "a:avLst", successors: []
+      required_attr "prst", type: Enum::MSO_AUTO_SHAPE_TYPE
+
+      # The adjustment guides, in document order.
+      def gd_list = avLst ? avLst.gd_list : []
+
+      # Replace the adjustment values with +name_value_pairs+.
+      def rewrite_guides(name_value_pairs)
+        remove_avLst
+        av_lst = get_or_add_avLst
+        name_value_pairs.each do |name, value|
+          av_lst.add_gd(name: name, fmla: "val #{value}")
+        end
+      end
+    end
+
+    # `a:custGeom`, a freeform shape geometry.
+    class CT_CustomGeometry2D < Element
+      tag "a:custGeom"
+      zero_or_one "a:pathLst", successors: []
+    end
+
+    # `a:pt`, one point of a path.
+    class CT_AdjPoint2D < Element
+      tag "a:pt"
+      required_attr "x", type: SimpleTypes::ST_Coordinate
+      required_attr "y", type: SimpleTypes::ST_Coordinate
+    end
+
+    # `a:moveTo` and `a:lnTo`: lift the pen to a point, or draw to it.
+    class CT_Path2DPoint < Element
+      tag "a:moveTo", "a:lnTo"
+      zero_or_one "a:pt", successors: []
+
+      def point_at(x, y)
+        point = get_or_add_pt
+        point.x = x
+        point.y = y
+        point
+      end
+    end
+
+    # `a:close`, ending a contour by joining it back to its start.
+    class CT_Path2DClose < Element
+      tag "a:close"
+    end
+
+    # `a:path`, one contour of a freeform shape.
+    #
+    # Its `w` and `h` are in the path's own coordinate space, not EMU: the
+    # shape's extents scale that space onto the slide.
+    class CT_Path2D < Element
+      tag "a:path"
+      zero_or_more "a:close", successors: [], as: :close
+      zero_or_more "a:lnTo", successors: [], as: :lnTo
+      zero_or_more "a:moveTo", successors: [], as: :moveTo
+      optional_attr "w", type: SimpleTypes::ST_PositiveCoordinate
+      optional_attr "h", type: SimpleTypes::ST_PositiveCoordinate
+
+      def move_to(x, y) = add_moveTo.point_at(x, y)
+
+      def line_to(x, y) = add_lnTo.point_at(x, y)
+
+      def close_contour = add_close
+    end
+
+    # `a:pathLst`, the contours of a freeform shape.
+    class CT_Path2DList < Element
+      tag "a:pathLst"
+      zero_or_more "a:path", successors: [], as: :path
+
+      def add_path_of(width, height)
+        add_path(w: width, h: height)
+      end
+    end
+
+    # `p:cNvSpPr`, the non-visual properties specific to a `p:sp`.
+    class CT_NonVisualDrawingShapeProps < Element
+      tag "p:cNvSpPr"
+      zero_or_one "a:spLocks", successors: %w[a:extLst]
+      optional_attr "txBox", type: SimpleTypes::XsdBoolean
+    end
+
+    # `p:nvSpPr`, the non-visual properties group of a `p:sp`.
+    class CT_ShapeNonVisual < Element
+      tag "p:nvSpPr"
+      one_and_only_one "p:cNvPr"
+      one_and_only_one "p:cNvSpPr"
+      one_and_only_one "p:nvPr"
+    end
+
+    # `p:sp`, an auto shape, text box, placeholder or freeform.
+    class CT_Shape < Element
+      include BaseShapeElement
+
+      tag "p:sp"
+      one_and_only_one "p:nvSpPr"
+      one_and_only_one "p:spPr"
+      zero_or_one "p:txBody", successors: %w[p:extLst]
+
+      # Placeholder types that come with a text frame when created.
+      TEXTUAL_PLACEHOLDERS = [
+        Enum::PP_PLACEHOLDER::TITLE, Enum::PP_PLACEHOLDER::CENTER_TITLE,
+        Enum::PP_PLACEHOLDER::SUBTITLE, Enum::PP_PLACEHOLDER::BODY,
+        Enum::PP_PLACEHOLDER::OBJECT
+      ].freeze
+
+      class << self
+        # A `p:sp` configured as a placeholder inheriting from a layout.
+        #
+        # The shape carries no geometry or position of its own: a placeholder
+        # inherits both from the corresponding placeholder on its layout.
+        def new_placeholder_sp(id, name, ph_type, orient, sz, idx)
+          sp = Element.parse(<<~XML)
+            <p:sp #{Ns.nsdecls("a", "p")}>
+              <p:nvSpPr>
+                <p:cNvPr id="#{id}" name="#{escape(name)}"/>
+                <p:cNvSpPr>
+                  <a:spLocks noGrp="1"/>
+                </p:cNvSpPr>
+                <p:nvPr/>
+              </p:nvSpPr>
+              <p:spPr/>
+            </p:sp>
+          XML
+
+          ph = sp.nvSpPr.nvPr.get_or_add_ph
+          ph.type = ph_type
+          ph.idx = idx
+          ph.orient = orient
+          ph.sz = sz
+
+          sp.append(CT_TextBody.new_element(sp)) if TEXTUAL_PLACEHOLDERS.include?(ph_type)
+
+          sp
+        end
+
+        # A `p:sp` configured as an auto shape with preset geometry.
+        def new_autoshape_sp(id, name, prst, x, y, cx, cy)
+          Element.parse(<<~XML)
+            <p:sp #{Ns.nsdecls("a", "p")}>
+              <p:nvSpPr>
+                <p:cNvPr id="#{id}" name="#{escape(name)}"/>
+                <p:cNvSpPr/>
+                <p:nvPr/>
+              </p:nvSpPr>
+              <p:spPr>
+                <a:xfrm>
+                  <a:off x="#{x.to_i}" y="#{y.to_i}"/>
+                  <a:ext cx="#{cx.to_i}" cy="#{cy.to_i}"/>
+                </a:xfrm>
+                <a:prstGeom prst="#{prst}">
+                  <a:avLst/>
+                </a:prstGeom>
+              </p:spPr>
+              #{DEFAULT_STYLE}
+              <p:txBody>
+                <a:bodyPr rtlCol="0" anchor="ctr"/>
+                <a:lstStyle/>
+                <a:p>
+                  <a:pPr algn="ctr"/>
+                </a:p>
+              </p:txBody>
+            </p:sp>
+          XML
+        end
+
+        # A `p:sp` configured as a freeform: custom geometry with an empty
+        # path list, ready for contours to be added.
+        def new_freeform_sp(id, name, x, y, cx, cy)
+          Element.parse(<<~XML)
+            <p:sp #{Ns.nsdecls("a", "p")}>
+              <p:nvSpPr>
+                <p:cNvPr id="#{id}" name="#{escape(name)}"/>
+                <p:cNvSpPr/>
+                <p:nvPr/>
+              </p:nvSpPr>
+              <p:spPr>
+                <a:xfrm>
+                  <a:off x="#{x.to_i}" y="#{y.to_i}"/>
+                  <a:ext cx="#{cx.to_i}" cy="#{cy.to_i}"/>
+                </a:xfrm>
+                <a:custGeom>
+                  <a:avLst/>
+                  <a:gdLst/>
+                  <a:ahLst/>
+                  <a:cxnLst/>
+                  <a:rect l="l" t="t" r="r" b="b"/>
+                  <a:pathLst/>
+                </a:custGeom>
+              </p:spPr>
+              #{DEFAULT_STYLE}
+              <p:txBody>
+                <a:bodyPr rtlCol="0" anchor="ctr"/>
+                <a:lstStyle/>
+                <a:p>
+                  <a:pPr algn="ctr"/>
+                </a:p>
+              </p:txBody>
+            </p:sp>
+          XML
+        end
+
+        # A `p:sp` configured as a text box.
+        def new_textbox_sp(id, name, x, y, cx, cy)
+          Element.parse(<<~XML)
+            <p:sp #{Ns.nsdecls("a", "p")}>
+              <p:nvSpPr>
+                <p:cNvPr id="#{id}" name="#{escape(name)}"/>
+                <p:cNvSpPr txBox="1"/>
+                <p:nvPr/>
+              </p:nvSpPr>
+              <p:spPr>
+                <a:xfrm>
+                  <a:off x="#{x.to_i}" y="#{y.to_i}"/>
+                  <a:ext cx="#{cx.to_i}" cy="#{cy.to_i}"/>
+                </a:xfrm>
+                <a:prstGeom prst="rect">
+                  <a:avLst/>
+                </a:prstGeom>
+                <a:noFill/>
+              </p:spPr>
+              <p:txBody>
+                <a:bodyPr wrap="none">
+                  <a:spAutoFit/>
+                </a:bodyPr>
+                <a:lstStyle/>
+                <a:p/>
+              </p:txBody>
+            </p:sp>
+          XML
+        end
+
+        def escape(text) = text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub('"', "&quot;")
+
+        DEFAULT_STYLE = <<~XML
+          <p:style>
+            <a:lnRef idx="1">
+              <a:schemeClr val="accent1"/>
+            </a:lnRef>
+            <a:fillRef idx="3">
+              <a:schemeClr val="accent1"/>
+            </a:fillRef>
+            <a:effectRef idx="2">
+              <a:schemeClr val="accent1"/>
+            </a:effectRef>
+            <a:fontRef idx="minor">
+              <a:schemeClr val="lt1"/>
+            </a:fontRef>
+          </p:style>
+        XML
+      end
+
+      # A text body added to a shape that has none needs the minimum structure
+      # the schema requires, not an empty element.
+      def new_txBody = CT_TextBody.new_element(self)
+
+      # Start a new contour on this shape's custom geometry.
+      #
+      # @raise [Error] unless the shape has custom geometry
+      def add_path(width, height)
+        geometry = spPr.custGeom
+        raise Error, "shape does not have custom geometry" if geometry.nil?
+
+        geometry.get_or_add_pathLst.add_path_of(width, height)
+      end
+
+      def prstGeom = spPr.prstGeom
+
+      def prst = prstGeom&.prst
+
+      def ln = spPr.ln
+
+      def get_or_add_ln = spPr.get_or_add_ln
+
+      # A shape has custom geometry -- is a freeform -- when it carries
+      # `a:custGeom` in place of `a:prstGeom`.
+      def custom_geometry? = !spPr.custGeom.nil?
+
+      # A text box is an `p:sp` whose `p:cNvSpPr` says `txBox="1"`.
+      def textbox? = nvSpPr.cNvSpPr.txBox == true
+
+      # An auto shape has preset geometry and is not a text box.
+      def autoshape? = !prstGeom.nil? && nvSpPr.cNvSpPr.txBox != true
+    end
+  end
+end

data/lib/ruby_pptx/oxml/shapes/groupshape.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/oxml/shapes/shared"
+require "ruby_pptx/oxml/shapes/autoshape"
+require "ruby_pptx/oxml/shapes/other"
+
+module Pptx
+  module Oxml
+    # `p:nvGrpSpPr`, the non-visual properties of a group shape.
+    class CT_GroupShapeNonVisual < Element
+      tag "p:nvGrpSpPr"
+      one_and_only_one "p:cNvPr"
+    end
+
+    # `p:spTree` and `p:grpSp`: a shape tree or a group of shapes.
+    class CT_GroupShape < Element
+      include BaseShapeElement
+
+      tag "p:spTree", "p:grpSp"
+
+      one_and_only_one "p:nvGrpSpPr"
+      one_and_only_one "p:grpSpPr"
+
+      # The child tags that count as shapes. Anything else in a shape tree
+      # (extension lists and so on) is not part of the shape sequence.
+      SHAPE_TAGS = %w[p:sp p:grpSp p:graphicFrame p:cxnSp p:pic p:contentPart].freeze
+
+      # A group's transform hangs off `p:grpSpPr`, not `p:spPr`.
+      def xfrm = grpSpPr.xfrm
+
+      def get_or_add_xfrm = grpSpPr.get_or_add_xfrm
+
+      def chOff = get_or_add_xfrm.get_or_add_chOff
+
+      def chExt = get_or_add_xfrm.get_or_add_chExt
+
+      # Each shape child, in document order.
+      def shape_elements
+        return enum_for(:shape_elements) unless block_given?
+
+        tags = SHAPE_TAGS.map { |t| Ns.qn(t) }
+        @node.element_children.each do |child|
+          yield Element.wrap(child) if tags.include?(Ns.clark_name_of(child))
+        end
+      end
+
+      # Each placeholder shape child, in document order.
+      def placeholder_elements
+        return enum_for(:placeholder_elements) unless block_given?
+
+        shape_elements { |shape| yield shape if shape.placeholder? }
+      end
+
+      def add_placeholder(id, name, ph_type, orient, sz, idx)
+        sp = adopt_xml(CT_Shape.new_placeholder_sp(id, name, ph_type, orient, sz, idx))
+        insert_element_before(sp, "p:extLst")
+        sp
+      end
+
+      def add_autoshape(id, name, prst, x, y, cx, cy)
+        sp = adopt_xml(CT_Shape.new_autoshape_sp(id, name, prst, x, y, cx, cy))
+        insert_element_before(sp, "p:extLst")
+        sp
+      end
+
+      def add_pic(id, name, desc, r_id, x, y, cx, cy)
+        pic = adopt_xml(CT_Picture.new_pic(id, name, desc, r_id, x, y, cx, cy))
+        insert_element_before(pic, "p:extLst")
+        pic
+      end
+
+      def add_graphic_frame_chart(id, name, r_id, x, y, cx, cy)
+        frame = adopt_xml(
+          CT_GraphicalObjectFrame.new_chart_graphic_frame(id, name, r_id, x, y, cx, cy)
+        )
+        insert_element_before(frame, "p:extLst")
+        frame
+      end
+
+      def add_video_pic(id, name, video_r_id, media_r_id, poster_r_id, x, y, cx, cy)
+        pic = adopt_xml(CT_Picture.new_video_pic(id, name, video_r_id, media_r_id,
+                                                 poster_r_id, x, y, cx, cy))
+        insert_element_before(pic, "p:extLst")
+        pic
+      end
+
+      def add_graphic_frame_ole_object(id, name, ole_r_id, prog_id, icon_r_id, x, y, cx, cy, img_w, img_h)
+        frame = adopt_xml(
+          CT_GraphicalObjectFrame.new_ole_object_graphic_frame(id, name, ole_r_id, prog_id, icon_r_id,
+                                                               x, y, cx, cy, img_w, img_h)
+        )
+        insert_element_before(frame, "p:extLst")
+        frame
+      end
+
+      def add_graphic_frame_table(id, name, rows, cols, x, y, cx, cy)
+        frame = adopt_xml(
+          CT_GraphicalObjectFrame.new_table_graphic_frame(id, name, rows, cols, x, y, cx, cy)
+        )
+        insert_element_before(frame, "p:extLst")
+        frame
+      end
+
+      def add_cxnSp(id, name, prst, x, y, cx, cy, flip_h, flip_v)
+        cxn_sp = adopt_xml(CT_Connector.new_cxnSp(id, name, prst, x, y, cx, cy, flip_h, flip_v))
+        insert_element_before(cxn_sp, "p:extLst")
+        cxn_sp
+      end
+
+      # An empty `p:grpSp` at the origin with no size; its extents follow from
+      # whatever is put in it.
+      def add_grpSp
+        id = next_shape_id
+        grp_sp = adopt_xml(CT_GroupShape.new_grpSp(id, "Group #{id - 1}"))
+        insert_element_before(grp_sp, "p:extLst")
+        grp_sp
+      end
+
+      def self.new_grpSp(id, name)
+        Element.parse(<<~XML)
+          <p:grpSp #{Ns.nsdecls("a", "p", "r")}>
+            <p:nvGrpSpPr>
+              <p:cNvPr id="#{id}" name="#{CT_Picture.escape(name)}"/>
+              <p:cNvGrpSpPr/>
+              <p:nvPr/>
+            </p:nvGrpSpPr>
+            <p:grpSpPr>
+              <a:xfrm>
+                <a:off x="0" y="0"/>
+                <a:ext cx="0" cy="0"/>
+                <a:chOff x="0" y="0"/>
+                <a:chExt cx="0" cy="0"/>
+              </a:xfrm>
+            </p:grpSpPr>
+          </p:grpSp>
+        XML
+      end
+
+      # Resize this group to just contain its shapes.
+      #
+      # A group's own extents are not stored by PowerPoint as anything the
+      # caller sets; they follow from the contents. Changing a group can also
+      # change the group containing it, so this walks upward.
+      def recalculate_extents
+        return self unless nsptag == "p:grpSp"
+
+        x, y, cx, cy = child_extents
+        chOff.x = self.x = x
+        chOff.y = self.y = y
+        chExt.cx = self.cx = cx
+        chExt.cy = self.cy = cy
+        parent.recalculate_extents if parent.respond_to?(:recalculate_extents)
+        self
+      end
+
+      # The bounding box of the contained shapes, or all zeroes when empty.
+      def child_extents
+        children = shape_elements.to_a
+        return [0, 0, 0, 0] if children.empty?
+
+        min_x = children.map { |child| child.x.to_i }.min
+        min_y = children.map { |child| child.y.to_i }.min
+        max_x = children.map { |child| child.x.to_i + child.cx.to_i }.max
+        max_y = children.map { |child| child.y.to_i + child.cy.to_i }.max
+        [min_x, min_y, max_x - min_x, max_y - min_y]
+      end
+
+      def add_freeform_sp(x, y, cx, cy)
+        id = next_shape_id
+        sp = adopt_xml(CT_Shape.new_freeform_sp(id, "Freeform #{id - 1}", x, y, cx, cy))
+        insert_element_before(sp, "p:extLst")
+        sp
+      end
+
+      def add_textbox(id, name, x, y, cx, cy)
+        sp = adopt_xml(CT_Shape.new_textbox_sp(id, name, x, y, cx, cy))
+        insert_element_before(sp, "p:extLst")
+        sp
+      end
+
+      # The largest @id anywhere in the document.
+      #
+      # Ids have document scope and are not used only by shapes, so every @id
+      # counts. The minimum in practice is 1, because the `p:spTree` element
+      # itself is always id="1".
+      def max_shape_id
+        used_ids.max || 0
+      end
+
+      # The lowest unused positive @id, filling gaps.
+      #
+      # Note this differs from the shape collection's own allocator, which
+      # takes max+1; both behaviours are preserved from python-pptx.
+      def next_shape_id
+        used = used_ids
+        (1..(used.size + 1)).find { |n| !used.include?(n) }
+      end
+
+      private
+
+      def used_ids
+        xpath("//@id").filter_map do |attr|
+          value = attr.value
+          Integer(value, 10) if /\A\d+\z/.match?(value)
+        end
+      end
+
+      # A shape built from an XML literal is parsed into its own document, so
+      # it must be rebuilt inside this tree's document before insertion.
+      def adopt_xml(element)
+        return element if element.document.equal?(document)
+
+        build_from_xml(element.node.to_xml)
+      end
+    end
+  end
+end