387 lines
9.3 KiB
Python
387 lines
9.3 KiB
Python
#!/usr/bin/env python3
|
|
|
|
from typing import Any
|
|
|
|
from com.sun.star.awt import Size, Point
|
|
from .easymain import (
|
|
BaseObject, Paths,
|
|
create_instance, dict_to_property, log, set_properties, get_properties
|
|
)
|
|
from .easyuno import (
|
|
BaseObjectProperties,
|
|
IOStream,
|
|
get_input_stream)
|
|
|
|
|
|
IMAGE = 'com.sun.star.drawing.GraphicObjectShape'
|
|
|
|
MIME_TYPE = {
|
|
'image/png': 'png',
|
|
'image/jpeg': 'jpg',
|
|
'image/svg': 'svg',
|
|
}
|
|
|
|
TYPE_MIME = {
|
|
'svg': 'image/svg',
|
|
'png': 'image/png',
|
|
'jpg': 'image/jpeg',
|
|
}
|
|
|
|
|
|
class LOShapes(object):
|
|
_type = 'ShapeCollection'
|
|
|
|
def __init__(self, obj):
|
|
self._obj = obj
|
|
|
|
def __len__(self):
|
|
return self.obj.Count
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_value, traceback):
|
|
pass
|
|
|
|
def __iter__(self):
|
|
self._index = 0
|
|
return self
|
|
|
|
def __next__(self):
|
|
try:
|
|
s = self.obj[self._index]
|
|
shape = LOShape(s)
|
|
except IndexError:
|
|
raise StopIteration
|
|
|
|
self._index += 1
|
|
return shape
|
|
|
|
def __str__(self):
|
|
return 'Shapes'
|
|
|
|
@property
|
|
def obj(self):
|
|
return self._obj
|
|
|
|
|
|
class LOShape(BaseObjectProperties):
|
|
|
|
def __init__(self, obj):
|
|
super().__init__(obj)
|
|
|
|
def __str__(self):
|
|
return f'Shape: {self.name}'
|
|
|
|
@property
|
|
def sheet(self):
|
|
return self.anchor
|
|
@sheet.setter
|
|
def sheet(self, value):
|
|
self.anchor = value
|
|
@property
|
|
def cell(self):
|
|
return self.anchor
|
|
@cell.setter
|
|
def cell(self, value):
|
|
self.anchor = value
|
|
@property
|
|
def anchor(self):
|
|
from .easycalc import LOCalcSheet, LOCalcRange
|
|
TYPE_ANCHOR = {
|
|
'ScTableSheetObj': LOCalcSheet,
|
|
'ScCellObj': LOCalcRange,
|
|
}
|
|
"""Get anchor object"""
|
|
obj = self.obj.Anchor
|
|
implementation = obj.ImplementationName
|
|
if implementation in TYPE_ANCHOR:
|
|
obj = TYPE_ANCHOR[implementation](obj)
|
|
else:
|
|
log.debug(implementation)
|
|
return obj
|
|
@anchor.setter
|
|
def anchor(self, obj):
|
|
if hasattr(obj, 'obj'):
|
|
obj = obj.obj
|
|
self.obj.Anchor = obj
|
|
return
|
|
|
|
@property
|
|
def resize_with_cell(self):
|
|
"""If resize with cell"""
|
|
return self.obj.ResizeWithCell
|
|
@resize_with_cell.setter
|
|
def resize_with_cell(self, value):
|
|
self.obj.ResizeWithCell = value
|
|
return
|
|
|
|
@property
|
|
def properties(self):
|
|
"""Get all properties"""
|
|
return get_properties(self.obj)
|
|
@properties.setter
|
|
def properties(self, values):
|
|
set_properties(self.obj, values)
|
|
|
|
@property
|
|
def shape_type(self):
|
|
"""Get type shape"""
|
|
return self.obj.ShapeType
|
|
@property
|
|
def type(self):
|
|
value = ''
|
|
if hasattr(self.obj, 'CustomShapeGeometry'):
|
|
for p in self.obj.CustomShapeGeometry:
|
|
if p.Name == 'Type':
|
|
value = p.Value
|
|
break
|
|
else:
|
|
value = self.shape_type
|
|
return value
|
|
|
|
@property
|
|
def name(self):
|
|
"""Get name"""
|
|
return self.obj.Name
|
|
@name.setter
|
|
def name(self, value):
|
|
self.obj.Name = value
|
|
|
|
@property
|
|
def is_image(self):
|
|
return self.shape_type == IMAGE
|
|
|
|
@property
|
|
def is_shape(self):
|
|
return self.shape_type != IMAGE
|
|
|
|
@property
|
|
def size(self):
|
|
s = self.obj.Size
|
|
return s
|
|
@size.setter
|
|
def size(self, value):
|
|
self.obj.Size = value
|
|
|
|
@property
|
|
def width(self):
|
|
"""Width of shape"""
|
|
s = self.obj.Size
|
|
return s.Width
|
|
@width.setter
|
|
def width(self, value):
|
|
s = self.size
|
|
s.Width = value
|
|
self.size = s
|
|
|
|
@property
|
|
def height(self):
|
|
"""Height of shape"""
|
|
s = self.obj.Size
|
|
return s.Height
|
|
@height.setter
|
|
def height(self, value):
|
|
s = self.size
|
|
s.Height = value
|
|
self.size = s
|
|
|
|
@property
|
|
def position(self):
|
|
return self.obj.Position
|
|
@property
|
|
def x(self):
|
|
"""Position X"""
|
|
return self.position.X
|
|
@x.setter
|
|
def x(self, value):
|
|
self.obj.Position = Point(value, self.y)
|
|
|
|
@property
|
|
def y(self):
|
|
"""Position Y"""
|
|
return self.position.Y
|
|
@y.setter
|
|
def y(self, value):
|
|
self.obj.Position = Point(self.x, value)
|
|
|
|
@property
|
|
def possize(self):
|
|
data = {
|
|
'Width': self.size.Width,
|
|
'Height': self.size.Height,
|
|
'X': self.position.X,
|
|
'Y': self.position.Y,
|
|
}
|
|
return data
|
|
@possize.setter
|
|
def possize(self, value):
|
|
self.obj.Size = Size(value['Width'], value['Height'])
|
|
self.obj.Position = Point(value['X'], value['Y'])
|
|
|
|
@property
|
|
def string(self):
|
|
return self.obj.String
|
|
@string.setter
|
|
def string(self, value):
|
|
self.obj.String = value
|
|
|
|
@property
|
|
def title(self):
|
|
return self.obj.Title
|
|
@title.setter
|
|
def title(self, value):
|
|
self.obj.Title = value
|
|
|
|
@property
|
|
def description(self):
|
|
return self.obj.Description
|
|
@description.setter
|
|
def description(self, value):
|
|
self.obj.Description = value
|
|
|
|
@property
|
|
def in_background(self):
|
|
return self.obj.LayerID
|
|
@in_background.setter
|
|
def in_background(self, value):
|
|
self.obj.LayerID = value
|
|
|
|
@property
|
|
def layerid(self):
|
|
return self.obj.LayerID
|
|
@layerid.setter
|
|
def layerid(self, value):
|
|
self.obj.LayerID = value
|
|
|
|
@property
|
|
def mime_type(self):
|
|
mt = self.obj.GraphicURL.MimeType
|
|
mime_type = MIME_TYPE.get(mt, mt)
|
|
return mime_type
|
|
|
|
@property
|
|
def path(self):
|
|
return self.url
|
|
@property
|
|
def url(self):
|
|
if self.is_image:
|
|
url = Paths.to_system(self.obj.GraphicURL.OriginURL)
|
|
else:
|
|
url = self.obj.FillBitmapName
|
|
return url
|
|
@url.setter
|
|
def url(self, value):
|
|
self.obj.FillBitmapURL = Paths.to_url(value)
|
|
|
|
@property
|
|
def visible(self):
|
|
return self.obj.Visible
|
|
@visible.setter
|
|
def visible(self, value):
|
|
self.obj.Visible = value
|
|
|
|
@property
|
|
def doc(self):
|
|
return self.obj.Parent.Forms.Parent
|
|
|
|
@property
|
|
def text_box(self):
|
|
return self.obj.TextBox
|
|
@text_box.setter
|
|
def text_box(self, value):
|
|
self.obj.TextBox = value
|
|
|
|
@property
|
|
def text_box_content(self):
|
|
return self.obj.TextBoxContent
|
|
# ~ @property
|
|
# ~ def text_box_content(self):
|
|
# ~ controller = self.doc.CurrentController
|
|
# ~ vc = controller.ViewCursor
|
|
# ~ tbx = self.obj.TextBoxContent
|
|
# ~ vc.gotoRange(tbx.Start, False)
|
|
# ~ vc.gotoRange(tbx.End, True)
|
|
# ~ text = controller.getTransferable()
|
|
# ~ return text
|
|
|
|
def get_path(self, path: str='', name: str='', mime_type: str=''):
|
|
if not path:
|
|
path = Paths(self.doc.URL).path
|
|
if not name:
|
|
name = self.name.replace(' ', '_')
|
|
if mime_type:
|
|
file_name = f'{name}.{mime_type}'
|
|
else:
|
|
if self.is_image:
|
|
file_name = f'{name}.{self.mime_type}'
|
|
else:
|
|
file_name = f'{name}.svg'
|
|
path = Paths.join(path, file_name)
|
|
return path
|
|
|
|
def select(self):
|
|
controller = self.doc.CurrentController
|
|
controller.select(self.obj)
|
|
return
|
|
|
|
def remove(self):
|
|
"""Auto remove"""
|
|
self.obj.Parent.remove(self.obj)
|
|
return
|
|
|
|
def export(self, path: str=''):
|
|
if not path:
|
|
path = self.get_path()
|
|
mime_type = Paths(path).ext
|
|
options = {
|
|
'URL': Paths.to_url(path),
|
|
'MimeType': TYPE_MIME.get(mime_type, mime_type)}
|
|
args = dict_to_property(options)
|
|
export = create_instance('com.sun.star.drawing.GraphicExportFilter')
|
|
export.setSourceDocument(self.obj)
|
|
export.filter(args)
|
|
return path
|
|
|
|
def save(self, path: str=''):
|
|
"""Save image"""
|
|
if not path:
|
|
path = self.get_path()
|
|
|
|
if self.is_image:
|
|
data = IOStream.to_bin(self.obj.GraphicStream)
|
|
Paths.save_bin(path, data)
|
|
else:
|
|
self.export(path)
|
|
|
|
return path
|
|
|
|
def _get_graphic(self):
|
|
stream = self.obj.GraphicStream
|
|
buffer = IOStream.output()
|
|
_, data = stream.readBytes(buffer, stream.available())
|
|
stream = get_input_stream(data)
|
|
gp = create_instance('com.sun.star.graphic.GraphicProvider')
|
|
properties = dict_to_property({'InputStream': stream})
|
|
graphic = gp.queryGraphic(properties)
|
|
return graphic
|
|
|
|
def clone(self, draw_page: Any=None, x: int=1000, y: int=1000):
|
|
"""Clone image"""
|
|
image = self.doc.createInstance('com.sun.star.drawing.GraphicObjectShape')
|
|
image.Graphic = self._get_graphic()
|
|
if draw_page is None:
|
|
draw_page = self.obj.Parent
|
|
else:
|
|
if hasattr(draw_page, 'obj'):
|
|
draw_page = draw_page.obj
|
|
|
|
draw_page.add(image)
|
|
image.Size = self.size
|
|
position = self.position
|
|
position.X += x
|
|
position.Y += y
|
|
image.Position = position
|
|
return LOShape(image)
|
|
|