easymacro/source/easymacro/easyshape.py

#!/usr/bin/env python3

from com.sun.star.awt import Size, Point
from .easymain import BaseObject, Paths, create_instance, dict_to_property, set_properties
from .easyuno import IOStream, get_input_stream


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(BaseObject):
    IMAGE = 'com.sun.star.drawing.GraphicObjectShape'
    MIME_TYPE = {
        'image/png': 'png',
        'image/jpeg': 'jpg',
    }

    def __init__(self, obj):
        self._obj = obj

    def __str__(self):
        return f'Shape: {self.name}'

    @property
    def obj(self):
        """Get original UNO object"""
        return self._obj

    @property
    def anchor(self):
        """Get anchor object"""
        return self.obj.Anchor
    @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"""
        data = self.obj.PropertySetInfo.Properties
        keys = [p.Name for p in data]
        values = self.obj.getPropertyValues(keys)
        data = dict(zip(keys, values))
        return data
    @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 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 == self.IMAGE

    @property
    def is_shape(self):
        return self.shape_type != self.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 type(self):
        mt = self.obj.GraphicURL.MimeType
        mime_type = self.MIME_TYPE.get(mt, mt)
        return mime_type

    @property
    def path(self):
        return self.url
    @property
    def url(self):
        url = ''
        if self.is_image:
            url = Paths.to_system(self.obj.GraphicURL.OriginURL)
        return url

    @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

    def remove(self):
        """Auto remove"""
        self.obj.Parent.remove(self.obj)
        return

    def save(self, path: str='', name: str=''):
        """Save image"""

        if not path:
            path = Paths(self.doc.URL).path
        if not name:
            name = self.name.replace(' ', '_')

        path_img = Paths.join(path, f'{name}.{self.type}')
        data = IOStream.to_bin(self.obj.GraphicStream)
        Paths.save_bin(path_img, data)

        return path_img

    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=None):
        """Clone image"""
        image = self.doc.createInstance('com.sun.star.drawing.GraphicObjectShape')
        image.Graphic = self._get_graphic()
        plus = 0
        if draw_page is None:
            draw_page = self.obj.Parent
            plus = 1000
        else:
            if hasattr(draw_page, 'obj'):
                draw_page = draw_page.obj

        draw_page.add(image)
        image.Size = self.size
        position = self.position
        position.X += plus
        position.Y += plus
        image.Position = position
        return LOShape(image)