OOoPython/PopupMenu

  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
128
129
130
131
132
133
134
135

#!
# -*- coding: utf_8 -*-
 
import uno
import unohelper
 
 
from com.sun.star.awt import XMenuListener
from com.sun.star.frame import XPopupMenuController, XDispatchProvider, \
    XStatusListener
from com.sun.star.lang import XInitialization, XServiceInfo, \
    XComponent
 
 
Protocol = "mytools.frame:"
IMPL_NAME = "mytools.frame.PMC"
SERVICE_NAME = "com.sun.star.frame.PopupMenuController"
 
 
class pmc(unohelper.Base,XPopupMenuController,
    XInitialization,XStatusListener,
    XDispatchProvider,XComponent,XServiceInfo,XMenuListener):
    """ PopupMenuController implemenation """
    
    def __init__(self,ctx,*args):
        """ initialization of the popupmenu controller 
			args are .beans.PropertyValue|s. Frame, CommandURL and ModuleName
		"""
        print "pmc: init"
        print "pmc: arg",str(len(args))
        self.ctx = ctx
        self.frame = None
        if args:
            self.initialize(args)
        return
    
    
    # XInitialization
    def initialize(self,args):
        """ frame is passed as an argument at the initialization process
			XDispatchProvider is instantiated for each frame """
        for arg in args:
            print arg.Name
            if arg.Name == "Frame":
                self.frame = arg.Value
            #elif arg.Name == "ModuleName":
            #    self.modname = arg.Value
            #elif arg.Name == "CommandURL":
            #    self.command = arg.Value
        return
    
    # XServiceInfo is needed by the DispatchProvider service
    def supportsService(self,name):
        return (name == SERVICE_NAME)
    
    def getImplementationName(self):
        return IMPL_NAME
    
    def getSupportedServiceNames(self):
        return (SERVICE_NAME,)
    
    
    # XDispatchProvider
    def queryDispatch(self,url,name,flag):
        print "pmc: querydispatch...",url.Complete
        if url.Protocol == Protocol:
            if url.Path == "PMC":
                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)
    
    
    # XStatusListener
    def statusChanged(self,state):
        pass
    
    # XComponent
    def dispose(self):
        self.frame = None
    
    def addEventListener(self,l):
        pass
    
    def removeEventListener(self,l):
        pass
    
    # XPopupMenuController
    def setPopupMenu(self,menu):
        print "pmc: setPopupMenu.."
        if not menu: return
        menu.insertItem(1,"pmc",0,0)
        menu.addMenuListener(self)
    
    def updatePopupMenu(self):
        pass
    
    
    def disposing(self,ev):
        pass
    
    # XMenuListener
    def hihglight(self,ev):
        pass
    def activate(self,ev):
        pass
    def deactivate(self,ev):
        pass
    
    def select(self,ev):
        message(self.frame,"PopupMenuController Demo.")
        
 
 
# needs OOo 2.2 or later
def message(frame,msg="",title=""):
    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_ImplementationHelper = unohelper.ImplementationHelper()
g_ImplementationHelper.addImplementation(
    pmc,
    IMPL_NAME,
    (SERVICE_NAME,),)