#188

src/reader/xlsx/vml_drawing.rs

@@ -37,9 +37,9 @@ pub(crate) fn read(
                         None => {
                             worksheet
                                 .get_ole_objects_mut()
-                                .get_ole_object_mut()
+                                .get_alternate_content_mut()
                                 .get_mut(ole_index)
-                                .map(|ole_obj| ole_obj.set_shape(obj));
+                                .map(|ole_obj| ole_obj.get_choice_mut().get_ole_object_mut().set_shape(obj));
                             ole_index += 1;
                         }
                     }

src/structs.rs

@@ -417,3 +417,13 @@ pub use self::sheet_protection::*;
 
 mod workbook_protection;
 pub use self::workbook_protection::*;
+
+mod alternate_content;
+pub use self::alternate_content::*;
+
+mod choice;
+pub use self::choice::*;
+
+mod fallback;
+pub use self::fallback::*;
+

src/structs/alternate_content.rs

@@ -0,0 +1,103 @@
+use super::Choice;
+use super::Fallback;
+use super::OleObject;
+use super::EmbeddedObjectProperties;
+use super::Int32Value;
+use super::StringValue;
+use helper::const_str::MC_NS;
+use quick_xml::events::{BytesStart, Event};
+use quick_xml::Reader;
+use quick_xml::Writer;
+use reader::driver::*;
+use std::io::Cursor;
+use structs::drawing::spreadsheet::TwoCellAnchor;
+use structs::raw::RawRelationships;
+use structs::vml::Shape;
+use writer::driver::*;
+
+#[derive(Clone, Default, Debug)]
+pub struct AlternateContent {
+    choice: Choice,
+    fallback: Fallback,
+}
+
+impl AlternateContent {
+    pub fn get_choice(&self) -> &Choice {
+        &self.choice
+    }
+
+    pub fn get_choice_mut(&mut self) -> &mut Choice {
+        &mut self.choice
+    }
+
+    pub fn set_choice(&mut self, value: Choice) -> &mut Self {
+        self.choice = value;
+        self
+    }
+
+    pub fn get_fallback(&self) -> &Fallback {
+        &self.fallback
+    }
+
+    pub fn get_fallback_mut(&mut self) -> &mut Fallback {
+        &mut self.fallback
+    }
+
+    pub fn set_fallback(&mut self, value: Fallback) -> &mut Self {
+        self.fallback = value;
+        self
+    }
+
+    pub(crate) fn set_attributes<R: std::io::BufRead>(
+        &mut self,
+        reader: &mut Reader<R>,
+        e: &BytesStart,
+        relationships: &RawRelationships,
+    ) {
+        xml_read_loop!(
+            reader,
+            Event::Start(ref e) => {
+                match e.name().into_inner() {
+                    b"mc:Choice" => {
+                        let mut obj = Choice::default();
+                        obj.set_attributes(reader, e, relationships);
+                        self.set_choice(obj);
+                    }
+                    b"mc:Fallback" => {
+                        let mut obj = Fallback::default();
+                        obj.set_attributes(reader, e, relationships);
+                        self.set_fallback(obj);
+                    }
+                    _ => (),
+                }
+            },
+            Event::End(ref e) => {
+                if e.name().into_inner() == b"mc:AlternateContent" {
+                    return
+                }
+            },
+            Event::Eof => panic!("Error not find {} end element", "mc:AlternateContent")
+        );
+    }
+
+    pub(crate) fn write_to(
+        &self,
+        writer: &mut Writer<Cursor<Vec<u8>>>,
+    ) {
+        // mc:AlternateContent
+        write_start_tag(
+            writer,
+            "mc:AlternateContent",
+            vec![("xmlns:mc", MC_NS)],
+            false,
+        );
+
+        // mc:Choice
+        self.choice.write_to(writer);
+
+        // mc:Fallback
+        self.fallback.write_to(writer);
+
+        write_end_tag(writer, "mc:AlternateContent");
+    }
+}

src/structs/choice.rs

@@ -0,0 +1,90 @@
+use super::OleObject;
+use super::EmbeddedObjectProperties;
+use super::Int32Value;
+use super::StringValue;
+use helper::const_str::MC_NS;
+use quick_xml::events::{BytesStart, Event};
+use quick_xml::Reader;
+use quick_xml::Writer;
+use reader::driver::*;
+use std::io::Cursor;
+use structs::drawing::spreadsheet::TwoCellAnchor;
+use structs::raw::RawRelationships;
+use structs::vml::Shape;
+use writer::driver::*;
+
+#[derive(Clone, Default, Debug)]
+pub struct Choice {
+    requires: StringValue,
+    ole_object: OleObject,
+}
+
+impl Choice {
+    pub fn get_requires(&self) -> &str {
+        self.requires.get_value()
+    }
+
+    pub fn set_requires<S: Into<String>>(&mut self, value: S) -> &mut Self {
+        self.requires.set_value(value);
+        self
+    }
+
+    pub fn get_ole_object(&self) -> &OleObject {
+        &self.ole_object
+    }
+
+    pub fn get_ole_object_mut(&mut self) -> &mut OleObject {
+        &mut self.ole_object
+    }
+
+    pub fn set_ole_object(&mut self, value: OleObject) -> &mut Self {
+        self.ole_object = value;
+        self
+    }
+
+    pub(crate) fn set_attributes<R: std::io::BufRead>(
+        &mut self,
+        reader: &mut Reader<R>,
+        e: &BytesStart,
+        relationships: &RawRelationships,
+    ) {
+        set_string_from_xml!(self, e, requires, "Requires");
+        xml_read_loop!(
+            reader,
+            Event::Start(ref e) => {
+                match e.name().into_inner() {
+                    b"oleObject" => {
+                        let mut obj = OleObject::default();
+                        obj.set_attributes(reader, e, relationships);
+                        self.set_ole_object(obj);
+                    }
+                    _ => (),
+                }
+            },
+            Event::End(ref e) => {
+                if e.name().into_inner() == b"mc:Choice" {
+                    return
+                }
+            },
+            Event::Eof => panic!("Error not find {} end element", "mc:Choice")
+        );
+    }
+
+    pub(crate) fn write_to(
+        &self,
+        writer: &mut Writer<Cursor<Vec<u8>>>,
+    ) {
+        // mc:Choice
+        write_start_tag(
+            writer,
+            "mc:Choice",
+            vec![("Requires", self.requires.get_value_str())],
+            false,
+        );
+
+        // oleObject
+        self.ole_object.write_to(writer);
+
+        write_end_tag(writer, "mc:Choice");
+    }
+}

src/structs/drawing/blip.rs

@@ -9,13 +9,25 @@ use structs::raw::RawRelationships;
 use structs::MediaObject;
 use writer::driver::*;
 
+use crate::StringValue;
+
 #[derive(Clone, Default, Debug)]
 pub struct Blip {
+    embed: StringValue,
     image: MediaObject,
-    cstate: String,
+    cstate: StringValue,
 }
 
 impl Blip {
+    pub fn get_embed(&self) -> &str {
+        &self.embed.get_value()
+    }
+
+    pub fn set_embed<S: Into<String>>(&mut self, value: S) -> &mut Self {
+        self.embed.set_value(value);
+        self
+    }
+
     pub fn get_image(&self) -> &MediaObject {
         &self.image
     }
@@ -30,11 +42,11 @@ impl Blip {
     }
 
     pub fn get_cstate(&self) -> &str {
-        &self.cstate
+        &self.cstate.get_value()
     }
 
     pub fn set_cstate<S: Into<String>>(&mut self, value: S) -> &mut Self {
-        self.cstate = value.into();
+        self.cstate.set_value(value);
         self
     }
 
@@ -48,22 +60,24 @@ impl Blip {
             self.set_cstate(v);
         }
 
-        let picture_id = get_attribute(e, b"r:embed").unwrap();
-        let relationship = drawing_relationships.get_relationship_by_rid(&picture_id);
+        let embed = get_attribute(e, b"r:embed").unwrap();
+        let relationship = drawing_relationships.get_relationship_by_rid(&embed);
+        self.set_embed(&embed);
+        self.get_image_mut()
+            .set_id(&embed);
         self.get_image_mut()
             .set_image_name(relationship.get_raw_file().get_file_name());
         self.get_image_mut()
             .set_image_data(relationship.get_raw_file().get_file_data().clone());
     }
 
-    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, r_id: &i32) {
+    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
         // a:blip
-        let r_id_str = format!("rId{}", r_id);
         let mut attributes: Vec<(&str, &str)> = Vec::new();
         attributes.push(("xmlns:r", REL_OFC_NS));
-        attributes.push(("r:embed", r_id_str.as_str()));
-        if !&self.cstate.is_empty() {
-            attributes.push(("cstate", &self.cstate));
+        attributes.push(("r:embed", self.embed.get_value_str()));
+        if !&self.cstate.has_value() {
+            attributes.push(("cstate", &self.cstate.get_value_str()));
         }
         write_start_tag(writer, "a:blip", attributes, false);
 

src/structs/drawing/graphic.rs

@@ -50,12 +50,12 @@ impl Graphic {
         );
     }
 
-    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, r_id: &i32) {
+    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
         // a:graphic
         write_start_tag(writer, "a:graphic", vec![], false);
 
         // a:graphicData
-        let _ = &self.graphic_data.write_to(writer, r_id);
+        let _ = &self.graphic_data.write_to(writer);
 
         write_end_tag(writer, "a:graphic");
     }

src/structs/drawing/graphic_data.rs

@@ -1,5 +1,6 @@
 // *:graphicData
 use super::charts::ChartSpace;
+use structs::StringValue;
 use helper::const_str::*;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::Reader;
@@ -12,10 +13,20 @@ use writer::driver::*;
 
 #[derive(Clone, Default, Debug)]
 pub struct GraphicData {
+    id: StringValue,
     chart_space: ChartSpace,
 }
 
 impl GraphicData {
+    pub fn get_id(&self) -> &str {
+        self.id.get_value()
+    }
+
+    pub fn set_id<S: Into<String>>(&mut self, value: S) -> &mut Self {
+        self.id.set_value(value);
+        self
+    }
+
     pub fn get_chart_space(&self) -> &ChartSpace {
         &self.chart_space
     }
@@ -39,10 +50,11 @@ impl GraphicData {
             reader,
             Event::Empty(ref e) => {
                 if e.name().into_inner() == b"c:chart" {
-                    let chart_id = get_attribute(e, b"r:id").unwrap();
+                    let id = get_attribute(e, b"r:id").unwrap();
+                    self.id.set_value_string(&id);
                     let relationship = drawing_relationships
                         .unwrap()
-                        .get_relationship_by_rid(&chart_id);
+                        .get_relationship_by_rid(&id);
                     chart::read(relationship.get_raw_file(), &mut self.chart_space);
                 }
             },
@@ -55,7 +67,7 @@ impl GraphicData {
         );
     }
 
-    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, r_id: &i32) {
+    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
         // a:graphicData
         write_start_tag(
             writer,
@@ -71,7 +83,7 @@ impl GraphicData {
             vec![
                 ("xmlns:c", DRAWINGML_CHART_NS),
                 ("xmlns:r", REL_OFC_NS),
-                ("r:id", format!("rId{}", r_id).as_str()),
+                ("r:id", self.id.get_value_str()),
             ],
             true,
         );

src/structs/drawing/spreadsheet/blip_fill.rs

@@ -113,7 +113,7 @@ impl BlipFill {
         );
     }
 
-    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, r_id: &i32) {
+    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
         // xdr:blipFill
         let mut attributes: Vec<(&str, &str)> = Vec::new();
         if self.rotate_with_shape.has_value() {
@@ -122,7 +122,7 @@ impl BlipFill {
         write_start_tag(writer, "xdr:blipFill", attributes, false);
 
         // a:blip
-        let _ = &self.blip.write_to(writer, r_id);
+        let _ = &self.blip.write_to(writer);
 
         // a:srcRect
         if let Some(v) = &self.source_rectangle {