use wincom::{ComObject, Variant};
use windows::Win32::System::Com::IDispatch;
use crate::curve::IvgCurve;
use crate::document::IvgMetadata;
use crate::layer::{IvgLayer, IvgLayers};
use crate::page::{IvgPage, IvgPages, IvgSpread, IvgSpreads};
use crate::shape::{IvgShape, IvgShapeRange, IvgShapes};
use crate::structs::{
IvgStructExportOptions, IvgStructPaletteOptions, IvgStructSaveAsOptions,
};
pub struct IvgDocument {
disp: ComObject,
}
impl IvgDocument {
pub fn new(disp: IDispatch) -> Self {
Self {
disp: ComObject::from_dispatch(disp, crate::types::IID_IDISPATCH),
}
}
pub fn from_dispatch(disp: IDispatch) -> Self {
Self::new(disp)
}
pub fn from_disp(disp: IDispatch) -> Self {
Self::new(disp)
}
pub fn raw(&self) -> &ComObject {
&self.disp
}
pub fn as_variant(&self) -> Variant {
self.disp.as_variant()
}
fn prop_string(&self, name: &str) -> Option<String> {
self.disp.get_property(name).ok()?.to_string().ok()
}
fn prop_i64(&self, name: &str) -> Option<i64> {
self.disp.get_property(name).ok()?.to_i64().ok()
}
fn prop_f64(&self, name: &str) -> Option<f64> {
self.disp.get_property(name).ok()?.to_f64().ok()
}
fn prop_bool(&self, name: &str) -> Option<bool> {
self.disp.get_property(name).ok()?.to_bool().ok()
}
fn prop_dispatch(&self, name: &str) -> Option<IDispatch> {
self.disp.get_property(name).ok()?.to_idispatch().ok()
}
fn put_i64(&self, name: &str, v: i64) -> bool {
self.disp
.set_property(name, vec![Variant::from_i64(v)])
.is_ok()
}
fn put_f64(&self, name: &str, v: f64) -> bool {
self.disp
.set_property(name, vec![Variant::from_f64(v)])
.is_ok()
}
fn put_bool(&self, name: &str, v: bool) -> bool {
self.disp
.set_property(name, vec![Variant::from_bool(v)])
.is_ok()
}
pub fn name(&self) -> Option<String> {
self.prop_string("Name")
}
pub fn file_name(&self) -> Option<String> {
self.prop_string("FileName")
}
pub fn full_file_name(&self) -> Option<String> {
self.prop_string("FullFileName")
}
pub fn file_path(&self) -> Option<String> {
self.prop_string("FilePath")
}
pub fn dirty(&self) -> Option<bool> {
self.prop_bool("Dirty")
}
pub fn set_dirty(&self, v: bool) -> bool {
self.put_bool("Dirty", v)
}
pub fn reset_dirty(&self) -> bool {
self.put_bool("Dirty", false)
}
pub fn read_only(&self) -> Option<bool> {
self.prop_bool("ReadOnly")
}
pub fn saved(&self) -> Option<bool> {
self.prop_bool("Saved")
}
pub fn version(&self) -> Option<i64> {
self.prop_i64("Version")
}
pub fn unit(&self) -> Option<i64> {
self.prop_i64("Unit")
}
pub fn set_unit(&self, unit: i32) -> bool {
self.put_i64("Unit", unit as i64)
}
pub fn reference_point(&self) -> Option<i64> {
self.prop_i64("ReferencePoint")
}
pub fn set_reference_point(&self, v: i32) -> bool {
self.put_i64("ReferencePoint", v as i64)
}
pub fn world_scale(&self) -> Option<f64> {
self.prop_f64("WorldScale")
}
pub fn set_world_scale(&self, v: f64) -> bool {
self.put_f64("WorldScale", v)
}
pub fn application(&self) -> Option<crate::app::IvgApplication> {
self.prop_dispatch("Application")
.map(crate::app::IvgApplication::from_dispatch)
}
pub fn pages(&self) -> Option<IvgPages> {
self.prop_dispatch("Pages").map(IvgPages::new)
}
pub fn active_page(&self) -> Option<IvgPage> {
self.prop_dispatch("ActivePage").map(IvgPage::new)
}
pub fn spreads(&self) -> Option<IvgSpreads> {
self.prop_dispatch("Spreads").map(IvgSpreads::new)
}
pub fn active_spread(&self) -> Option<IvgSpread> {
self.prop_dispatch("ActiveSpread").map(IvgSpread::new)
}
pub fn create_page(&self) -> Option<IvgPage> {
let args = vec![Variant::from_i64(1)];
if let Ok(v) = self.disp.invoke_method("AddPages", args) {
if let Ok(disp) = v.to_idispatch() {
return Some(IvgPage::new(disp));
}
}
self.disp
.invoke_method("CreatePage", vec![])
.ok()?
.to_idispatch()
.ok()
.map(IvgPage::new)
}
pub fn active_layer(&self) -> Option<IvgLayer> {
self.prop_dispatch("ActiveLayer").map(IvgLayer::new)
}
pub fn active_virtual_layer(&self) -> Option<IvgLayer> {
self.prop_dispatch("ActiveVirtualLayer").map(IvgLayer::new)
}
pub fn active_page_layers(&self) -> Option<IvgLayers> {
self.active_page()?.layers()
}
pub fn create_layer(&self, name: impl Into<String>) -> Option<IvgLayer> {
self.active_page()?.create_layer(name)
}
pub fn shapes(&self) -> Option<IvgShapes> {
self.prop_dispatch("Shapes").map(IvgShapes::new)
}
pub fn selection_range(&self) -> Option<IvgShapeRange> {
self.prop_dispatch("SelectionRange").map(IvgShapeRange::new)
}
pub fn active_shape(&self) -> Option<IvgShape> {
self.prop_dispatch("ActiveShape").map(IvgShape::new)
}
pub fn clear_selection(&self) -> bool {
self.disp.invoke_method("ClearSelection", vec![]).is_ok()
}
pub fn find_shape(
&self,
name: impl Into<String>,
shape_type: i32,
static_id: i32,
recursive: bool,
) -> Option<IvgShape> {
let args = vec![
Variant::from_str(&name.into()),
Variant::from_i64(shape_type as i64),
Variant::from_i64(static_id as i64),
Variant::from_bool(recursive),
];
self.disp
.invoke_method("FindShape", args)
.ok()?
.to_idispatch()
.ok()
.map(IvgShape::new)
}
pub fn find_shapes(
&self,
name: impl Into<String>,
shape_type: i32,
recursive: bool,
) -> Option<IvgShapeRange> {
let args = vec![
Variant::from_str(&name.into()),
Variant::from_i64(shape_type as i64),
Variant::from_bool(recursive),
];
self.disp
.invoke_method("FindShapes", args)
.ok()?
.to_idispatch()
.ok()
.map(IvgShapeRange::new)
}
pub fn create_curve(&self) -> Option<IvgCurve> {
let args = vec![self.as_variant()];
self.disp
.invoke_method("CreateCurve", args)
.ok()?
.to_idispatch()
.ok()
.map(IvgCurve::new)
}
pub fn convert_units(&self, value: f64, from: i32, to: i32) -> Option<f64> {
crate::geometry::units::convert_by_i32(value, from, to)
}
pub fn data_fields(&self) -> Option<crate::document::IvgDataFields> {
self.prop_dispatch("DataFields")
.map(crate::document::IvgDataFields::new)
}
pub fn metadata(&self) -> Option<IvgMetadata> {
self.prop_dispatch("Metadata").map(IvgMetadata::new)
}
pub fn save(&self) -> bool {
self.disp.invoke_method("Save", vec![]).is_ok()
}
pub fn save_as(&self, file_name: impl Into<String>) -> bool {
let Some(options) = self.application().and_then(|a| a.create_save_as_options()) else {
return false;
};
self.save_as_ex(file_name, &options)
}
pub fn save_as_ex(
&self,
file_name: impl Into<String>,
options: &IvgStructSaveAsOptions,
) -> bool {
let args = vec![
Variant::from_str(&file_name.into()),
options.as_variant(),
];
self.disp.invoke_method("SaveAs", args).is_ok()
}
pub fn close(&self) -> bool {
self.disp.invoke_method("Close", vec![]).is_ok()
}
pub fn close_without_saving(&self) -> bool {
let _ = self.reset_dirty();
self.disp.invoke_method("Close", vec![]).is_ok()
}
pub fn export(&self, file_name: impl Into<String>, filter: i32) -> bool {
let Some(app) = self.application() else {
return false;
};
let (Some(options), Some(palette)) = (
app.create_export_options(),
app.create_palette_options(),
) else {
return false;
};
self.export_with(file_name, filter, &options, &palette)
}
pub fn export_ex(
&self,
file_name: impl Into<String>,
filter: i32,
options: &IvgStructExportOptions,
) -> bool {
let Some(palette) = self
.application()
.and_then(|a| a.create_palette_options())
else {
return false;
};
self.export_with(file_name, filter, options, &palette)
}
fn export_with(
&self,
file_name: impl Into<String>,
filter: i32,
options: &IvgStructExportOptions,
palette: &IvgStructPaletteOptions,
) -> bool {
let args = vec![
Variant::from_str(&file_name.into()),
Variant::from_i32(filter),
Variant::from_i32(0), options.as_variant(),
palette.as_variant(),
];
self.disp.invoke_method("Export", args).is_ok()
}
pub fn print_out(&self) -> bool {
self.disp.invoke_method("PrintOut", vec![]).is_ok()
}
pub fn print_settings(&self) -> Option<crate::print::IvgPrnJob> {
self.disp
.invoke_method("PrintSettings", vec![])
.ok()?
.to_idispatch()
.ok()
.map(crate::print::IvgPrnJob::new)
}
pub fn pdf_settings(&self) -> Option<crate::print::IvgPdfVbaSettings> {
self.disp
.invoke_method("PDFSettings", vec![])
.ok()?
.to_idispatch()
.ok()
.map(crate::print::IvgPdfVbaSettings::new)
}
pub fn begin_command_group(&self, name: impl Into<String>) -> bool {
let args = vec![Variant::from_str(&name.into())];
self.disp.invoke_method("BeginCommandGroup", args).is_ok()
}
pub fn end_command_group(&self) -> bool {
self.disp.invoke_method("EndCommandGroup", vec![]).is_ok()
}
pub fn clear_undo_stack(&self) -> bool {
self.disp.invoke_method("ClearUndoStack", vec![]).is_ok()
}
pub fn views(&self) -> Option<crate::view::IvgViews> {
self.prop_dispatch("Views").map(crate::view::IvgViews::new)
}
pub fn windows(&self) -> Option<crate::view::IvgWindows> {
self.prop_dispatch("Windows")
.map(crate::view::IvgWindows::new)
}
pub fn grid(&self) -> Option<crate::misc::IvgGrid> {
self.prop_dispatch("Grid").map(crate::misc::IvgGrid::new)
}
pub fn rulers(&self) -> Option<crate::misc::IvgRulers> {
self.prop_dispatch("Rulers").map(crate::misc::IvgRulers::new)
}
pub fn style_sheet(&self) -> Option<crate::style::IvgStyleSheet> {
self.prop_dispatch("StyleSheet")
.map(crate::style::IvgStyleSheet::new)
}
pub fn tree_manager(&self) -> Option<crate::tree::IvgTreeManager> {
self.prop_dispatch("ActiveTreeManager")
.map(crate::tree::IvgTreeManager::new)
}
pub fn selection_info(&self) -> Option<crate::shape::IvgSelectionInformation> {
self.prop_dispatch("SelectionInfo")
.map(crate::shape::IvgSelectionInformation::new)
}
}