OOoBasic/Generic/XTransferable

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

import uno, unohelper
import zipfile
import re
import tempfile
 
from com.sun.star.datatransfer import XTransferable
from com.sun.star.datatransfer import DataFlavor
from com.sun.star.beans import PropertyValue
 
mimetype_writer = "application/vnd.oasis.opendocument.text"
 
manifest_name = "META-INF/manifest.xml"
manifest_calc = '<manifest:file-entry manifest:media-type=' + \
    '"application/vnd.oasis.opendocument.spreadsheet" manifest:full-path="/"/>'
manifest_writer = '<manifest:file-entry manifest:media-type=' + \
    '"application/vnd.oasis.opendocument.text" manifest:full-path="/"/>'
 
content_name = "content.xml"
content_writer_starttag = '<office:text>'
content_writer_endtag = '</office:text>'
content_calc_starttag = '<office:spreadsheet>'
content_calc_endtag = '</office:spreadsheet>'
 
styles_name = "styles.xml"
settings_name = "settings.xml"
 
 
class transferable(unohelper.Base,XTransferable):
    """Keep clipboard data and provide them."""
    def __init__(self,mTypes,data):
        self.flavors = mTypes
        self.data = data
    
    def getTransferData(self,flavor):
        if not flavor: return
        mtype = flavor.MimeType
        for i,f in enumerate(self.flavors):
            if mtype == f.MimeType:
                return self.data[i]
    
    def getTransferDataFlavors(self):
        return tuple(self.flavors)
    
    def isDataFlavorSupported(self,flavor):
        if not flavor: return False
        mtype = flavor.MimeType
        for f in self.flavors:
            if mtype == f.MimeType:
                return True
        return False
 
def calc2writer():
    ctx = XSCRIPTCONTEXT.getComponentContext()
    smgr = ctx.ServiceManager
    
    # XTransferable from CurrentController
    contents = XSCRIPTCONTEXT.getDocument().getCurrentController().getTransferable()
    if not contents: return
    
    fr = DataFlavor()
    fr.MimeType = u'application/x-openoffice-embed-source-xml;' + \
        'windows_formatname="Star Embed Source (XML)"'
    if not contents.isDataFlavorSupported(fr): return
    
    data = contents.getTransferData(fr)
    
    tmp = tempfile.TemporaryFile()
    tmp.write(data.value)
    
    # open zip file and read content.xml and manifest
    f = zipfile.ZipFile(tmp,'r')
    content = f.read(content_name)
    manifest = f.read(manifest_name)
    f.close()
    
    f = zipfile.ZipFile(tmp,'w')
    
    # replace mimetype file
    f.writestr("mimetype",mimetype_writer)
 
    # edit META-INF/manifest.xml file
    f.writestr(manifest_name,manifest.replace(manifest_calc,manifest_writer))
 
    # edit content.xml file
    f.writestr(content_name,
        re.sub("<table:table-row table:style-name=\".*?\">",'<table:table-row>',
        content.replace(content_calc_starttag,content_writer_starttag
        ).replace(content_calc_endtag,content_writer_endtag)
        ))
    # setting.xml and styles.xml to empty
    f.writestr(styles_name,"")
    f.writestr(settings_name,"")
    f.close()
    
    tmp.seek(0,0)
    data = tmp.read()
    d = uno.ByteSequence(data)
    tmp.close()
    
    # sequence to input
    seq_in = ctx.ServiceManager.createInstanceWithContext(
        "com.sun.star.io.SequenceInputStream", ctx )
    seq_in.initialize((d,))
    
    doc = XSCRIPTCONTEXT.getDesktop().loadComponentFromURL(
        "private:factory/swriter","_blank",0,())
    
    cursor = doc.getText().createTextCursor()
    
    arg = PropertyValue()
    arg.Name = "InputStream"
    arg.Value = seq_in
    arg2 = PropertyValue()
    arg2.Name = "FilterName"
    arg2.Value = "writer8"
    
    cursor.insertDocumentFromURL("",(arg,arg2))
    
    seq_in.closeInput()
 
 
g_exportedScripts = calc2writer,

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

import uno
import unohelper
from com.sun.star.ui.dialogs.ExecutableDialogResults import OK as EDR_OK
from com.sun.star.ui.dialogs.TemplateDescription import \
    FILESAVE_SIMPLE as TD_FILESAVE_SIMPLE
from com.sun.star.awt.PosSize import POSSIZE as PS_POSSIZE, SIZE as PS_SIZE
 
def saveclip():
    ctx = XSCRIPTCONTEXT.getComponentContext()
    smgr = ctx.ServiceManager
    
    # from Document Object
    #contents = XSCRIPTCONTEXT.getDocument()
    
    # XTransferable from CurrentController
    #contents = XSCRIPTCONTEXT.getDocument().getCurrentController().getTransferable()
    
    # from SystemClipboard service
    sc = smgr.createInstanceWithContext(
        "com.sun.star.datatransfer.clipboard.SystemClipboard",ctx)
    contents = sc.getContents()
    
    if not contents:
        message(ctx,"Empty.")
        return
    
    fs = contents.getTransferDataFlavors()
    type_list = [f.MimeType for f in fs]
    selected = select_type(ctx,tuple(type_list))
    if selected < 0: return
    
    f = fs[selected]
    try:
        if contents.isDataFlavorSupported(f):
            
            file_url = get_fileurl(ctx,smgr)
            if not file_url: return
            
            data = contents.getTransferData(f)
            
            if isinstance(data,basestring):
                p = unohelper.fileUrlToSystemPath(file_url)
                f = open(p,'wb')
                f.write(data)
                f.flush()
                f.close()
            else:
                sfa = smgr.createInstanceWithContext(
                    "com.sun.star.ucb.SimpleFileAccess", ctx)
                out = sfa.openFileWrite(file_url)
                out.writeBytes(data)
                out.flush()
                out.closeOutput()
        else:
            message(ctx,"This kind of the content is not supported.")
    except Exception,e:
        print e
 
def select_type(ctx,types):
    smgr = ctx.ServiceManager
    dlg_model = smgr.createInstanceWithContext(
        "com.sun.star.awt.UnoControlDialogModel",ctx)
    dlg = smgr.createInstanceWithContext(
        "com.sun.star.awt.UnoControlDialog",ctx)
    dlg.setModel(dlg_model)
    dlg.setPosSize(0,0,500,200,PS_SIZE)
    list_mt = createControl(smgr,ctx,"ListBox",0,0,500,150,
        (),())
    btn_ok = createControl(smgr,ctx,"Button",420,160,80,30,
        ("Label","PushButtonType"),("~OK",1))
    btn_cancel = createControl(smgr,ctx,"Button",330,160,80,30,
        ("Label","PushButtonType"),("~Cancel",2))
    
    dlg.addControl("list_mt",list_mt)
    dlg.addControl("btn_ok",btn_ok)
    dlg.addControl("btn_cancel",btn_cancel)
    
    list_mt.addItems(types,0)
    
    dlg.setVisible(True)
    item = -1
    if dlg.execute() == EDR_OK:
        item = list_mt.getSelectedItemPos()
    
    dlg.dispose()
    return item
 
def createControl(smgr,ctx,ctype,x,y,width,height,names,values):
    ctrl = smgr.createInstanceWithContext( 
        "com.sun.star.awt.UnoControl%s" % ctype,ctx)
    ctrl_model = smgr.createInstanceWithContext( 
        "com.sun.star.awt.UnoControl%sModel" % ctype,ctx)
    ctrl_model.setPropertyValues(names,values)
    ctrl.setModel(ctrl_model)
    ctrl.setPosSize(x,y,width,height,PS_POSSIZE)
    return ctrl
 
def get_fileurl(ctx,smgr):
    fp = smgr.createInstanceWithContext( 
        "com.sun.star.ui.dialogs.FilePicker",ctx)
    fp.initialize((TD_FILESAVE_SIMPLE,))
    fp.setMultiSelectionMode(False)
    fp.appendFilter("All Files (*.*)","*.*")
    fp.setCurrentFilter("All Files (*.*)")
    
    filepath = ""
    if fp.execute() == EDR_OK:
        filepaths = fp.getFiles()
        filepath = filepaths[0]
        return filepath
    else:
        return False
 
# needs OOo 2.2 or later
def message(ctx,msg="",title=""):
    desktop = ctx.ServiceManager.createInstanceWithContext(
        "com.sun.star.frame.Desktop",ctx)
    frame = desktop.getCurrentFrame()
    win = frame.getContainerWindow()
    toolkit = win.getToolkit()
    rect = uno.createUnoStruct("com.sun.star.awt.Rectangle")
    msgbox = toolkit.createMessageBox( 
        win,rect,"messbox",1,title,msg)
    msgbox.execute()
 
 
g_exportedScripts = saveclip,