OOoPython/ARFLDescription

  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

class pmc(unohelper.Base,
    XPopupMenuController,
    XInitialization,XStatusListener,
    XDispatchProvider,
    XMenuListener,XContainerListener,XServiceInfo):
    """ PopupMenuController implemenation """
    
    def __init__(self,ctx,*args):
        """Initialization of the popupmenu controller.
		
		PopumuMenuController implemented by Py-UNO is instantiated with __init__ function 
		not initialize method of .lang.XInitialization interface.
		"""
        #args are .beans.PropertyValue|s. Frame, CommandURL and ModuleName
        self.ctx = ctx
        self.frame = None # frame of the document
        self.modname = "" # module name
        self.command = ""
        self.list_changed = False
        self.file_list = []
        self.menu = None
        self.history_list = None
        if args:
            self.initialize(args)
        if self.frame:
            self.frame.addEventListener(self)

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19

    # XInitialization
    def initialize(self,args):
        """Frame is passed as an argument at the initialization process."""
        for arg in args:
            
            if arg.Name == u'Frame':
                self.frame = arg.Value
                
            elif arg.Name == u'ModuleName':
                #self.modname = arg.Value
                if arg.Value.startswith(Mod_sdb_prefix):
                    # all database modules as OfficeDatabaseDocument
                    self.modname = Mod_Database
                elif arg.Value == Mod_Chart2:
                    self.modname = Mod_Spreadsheet
                else:
                    self.modname = arg.Value
                
            elif arg.Name == u'CommandURL':
                self.command = arg.Value

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9

IMPL_NAME = u'mytools.frame.ContextSpecificRecentFileList'
SERVICE_NAME = u'com.sun.star.frame.PopupMenuController'
 
    # XServiceInfo interface is used to identify the component by the ImplementationName.
    def supportsService(self,name):
        return (name == SERVICE_NAME)
    def getImplementationName(self):
        return IMPL_NAME
    def getSupportedServiceNames(self):
        return (SERVICE_NAME,)

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13

    # XDispatchProvider
    def queryDispatch(self,url,name,flag):
        #print "pmc: querydispatch...",url.Complete
        if url.Protocol == Protocol:
            if url.Path == Menu_Path:
                return self
        return None
    
    def queryDispatches(self,args):
        disps = []
        for arg in args:
            disps.append(
                self.queryDispatch(arg.FeatureURL,arg.FrameName,arg.SearchFlags))
        return tuple(disps)

  0
  1
  2
  3

    # XStatusListener
    def statusChanged(self,state):
        """This menu is always enabled."""
        pass

  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

    # XPopupMenuController
    def setPopupMenu(self,menu):
        """Set content of the popup menu passed by the factory."""
        if not self.frame: return
        if not menu: return
        
        self.menu = menu # keep the menu
        try:
            self.fill_menu()
        except Exception,e:
            print e
            return
        # add menu listener
        self.menu.addMenuListener(self)
        # adds container listener
        self.register_listener()
    
    def updatePopupMenu(self):
        """updatePopupMenu call."""
        #print "update pm"
        try:
            if self.list_changed:
                self.clear_menu()
                self.fill_menu()
                self.register_listener()
            self.list_changed = False
        except Exception,e:
            print e

  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

    def fill_menu(self):
        """Fill menu with entries."""
        self.file_list = []
        
        reader = self.__get_history_reader()
        
        # create history list according to the module name
        if self.modname in (Mod_StartModule,Mod_BasicIDE,Mod_Database):
            self.create_general_history(reader)
        else:
            self.file_list = create_context_spacific_history(
                    self.ctx, reader, self.modname)
        
        if not self.file_list:
            self.menu.insertItem(1,u'~No Documents.',0,1)
            self.menu.enableItem(1,False)
            return
        
        ua = self.ctx.ServiceManager.createInstanceWithContext(
            u'com.sun.star.util.UriAbbreviation', self.ctx)
        sw = string_width()
        
        urlStr = u'URL'
        entries = []
        
        if sep == chr(0x5C):
            for i,v in enumerate(self.file_list):
                
                if v[urlStr].startswith(u'file:///'):
                    syspath = self.abbreviation(
                        unicode(
                            unquote(
                            v[urlStr].encode('ascii')),'utf8'
                        )[8:].replace('/','\\'), 46, '\\')
                else:
                    
                    syspath = ua.abbreviateString(sw,46,v[urlStr])
                label = u'~%s: %s' % (i+1, syspath)
                
                self.menu.insertItem(i+1,label,0,i)
        
        else:
            for i,v in enumerate(self.file_list):
                if v[urlStr].startswith(u'file:///'):
                    syspath = uno.fileUrlToSystemPath(
                        ua.abbreviateString(sw,46,v[urlStr]))
                else:
                    syspath = ua.abbreviateString(sw,46,v[urlStr])
                label = u'~%s: %s' % (i+1, syspath)
                
                self.menu.insertItem(i+1,label,0,i)

  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

def create_context_spacific_history(ctx,reader,modname):
    """Context specific history."""
    # make a module specific list
    iFlag = 0x1
    eFlag = 0x8 + 0x1000 + 0x40000
    
    filter_list = get_filter_list(ctx,modname,iFlag,eFlag)
    
    if not filter_list.has_key(modname):
        # not found
        return create_general_history(reader)
    
    file_list = []
    
    # size of the list
    pk_size = reader.getPropertyValue(u'PickListSize')
    
    # module specific filter names
    if modname == Mod_Global:
        # GlobalDocument: Global + Text
        Global_filters = Set(filter_list.get(Mod_Global,[]))
        Text_filters = Set(filter_list.get(Mod_Text,[]))
        mod_filters = Global_filters | Text_filters
    else:
        mod_filters = Set(filter_list[modname])
    
    filterName = u'Filter'
    urlStr = u'URL'
    
    # "List" does not list stored file. So, get files form "PickList" and 
    # complement remains from "List".
    
    # PickList keeps Recent Files entries.
    pk_list = reader.getPropertyValue(u'PickList')
    
    if pk_list.hasElements():
        for name in pk_list.getElementNames():
            
            pk = pk_list.getByName(name)
            fl = pk.getPropertyValue(filterName)
            
            # check the filter
            if fl in mod_filters:
                element = {}
                element[urlStr] = pk.getPropertyValue(urlStr)
                element[filterName] = fl
                
                file_list.append(element)
    
    # List keeps all file histories.
    hist_list = reader.getPropertyValue(u'List')
    
    if hist_list.hasElements():
        for name in hist_list.getElementNames():
            
            hist = hist_list.getByName(name)
            fl = hist.getPropertyValue(filterName)
            
            if fl in mod_filters:
                element = {}
                element[urlStr] = hist.getPropertyValue(urlStr)
                element[filterName] = fl
                
                if not element in file_list:
                    file_list.append(element)
                
                if len(file_list) >= pk_size: break
    return file_list

  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

def get_filter_info(descs):
    docService = u'DocumentService'
    filterName = u'Name'
    service = ""
    name = ""
    
    for desc in descs:
        if desc.Name == docService:
            service = desc.Value
        elif desc.Name == filterName:
            name = desc.Value
    return service,name
 
 
def get_filter_list(ctx,mod="",iFlag=0,eFlag=0):
    """Get filter list from FilterFactory.
	
	Returned filters are categorized in their module.
	filer_list["com.sun.star.sheet.SpreadsheetDocument": ["calc8", "..."], "": ... ]
	"""
    ff = ctx.ServiceManager.createInstanceWithContext(
        u'com.sun.star.document.FilterFactory' ,ctx)
    que = u'getSortedFilterList():module=%s:iflags=%s:eflags=%s' % (mod,iFlag,eFlag)
    filters = ff.createSubSetEnumerationByQuery(que)
    
    filter_list = {}
    
    get_info = get_filter_info
    
    while filters.hasMoreElements():
        fl = filters.nextElement()
        service,name = get_info(fl)
        if filter_list.has_key(service):
            filter_list[service].append(name)
        else:
            filter_list[service] = [name]
    
    return filter_list

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9

    # XContainerListener
    def elementInserted(self,ev):
        self.list_changed = True
        self.unregister_listener()
    def elementRemoved(self,ev):
        self.list_changed = True
        self.unregister_listener()
    def elementReplaced(self,ev):
        self.list_changed = True
        self.unregister_listener()

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12

    # XMenuListener
    def hihglight(self,ev):
        pass
    def activate(self,ev):
        pass
    def deactivate(self,ev):
        pass
    def select(self,ev):
        menu_id = ev.MenuId
        if menu_id <= 0: return
        
        if self.file_list and len(self.file_list) < menu_id -1:
            self.open_file( self.file_list[menu_id -1] )

  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

    def open_file(self,entry):
        """Open file with dispatch."""
        if not self.frame: return
        
        url = URL()
        url.Complete = u'.uno:Open'
        #print entry["URL"],entry["Filter"]
        transformer = self.ctx.ServiceManager.createInstanceWithContext(
            u'com.sun.star.util.URLTransformer', self.ctx)
        d,url = transformer.parseStrict(url)
        
        arg1 = create_PropertyValue(u'Referer', u'private:user')
        arg2 = create_PropertyValue(u'AsTemplate',False)
        arg3 = create_PropertyValue(u'FilterName',entry[u'Filter'])
        arg4 = create_PropertyValue(u'SynchronMode',False)
        arg5 = create_PropertyValue(u'URL',entry[u'URL'])
        arg6 = create_PropertyValue(u'FrameName',u'_default')
        args = (arg1,arg2,arg3,arg4,arg5,arg6)
        
        desktop = self.ctx.ServiceManager.createInstanceWithContext(
            u'com.sun.star.frame.Desktop', self.ctx)
        
        disp = desktop.queryDispatch(url,u'_self',0)
        
        if disp:
            disp.dispatch(url,args)