OOobbs2/71

  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
136
137
138
139
140
141
142
143
144
145
146
147
148

 #!
 # -*- coding: utf_8 -*-
 import uno
 import unohelper
 
 #interfaces
 from com.sun.star.awt import XContainerWindowEventHandler
 from com.sun.star.lang import XServiceInfo
 # listeners
 from com.sun.star.awt import XActionListener
 
 
 # push button listener
 class ButtonListener(unohelper.Base,XActionListener):
     DEFAULTMAXIMUM = 30000
     def __init__(self,cast,dialog):
         self.cast = cast
         self.dialog = dialog
     def disposing(self,eventObject):
         pass
     def actionPerformed(self,actionEvent):
         cmd = str(actionEvent.ActionCommand)
         if cmd == "width":
             self.dialog.getControl("nf_width").Value = self.DEFAULTMAXIMUM / 100
         elif cmd == "height":
             self.dialog.getControl("nf_height").Value = self.DEFAULTMAXIMUM / 100
         return
 
 # main class
 class DilaogHandler(unohelper.Base,XServiceInfo,XContainerWindowEventHandler):
     def __init__(self,ctx):
         self.ctx = ctx;
         self.smgr = ctx.ServiceManager
         
         self.CFGNODE = "/org.openoffice.Office.Common/Drawinglayer"
         self.cp = self.smgr.createInstanceWithContext( 
             "com.sun.star.configuration.ConfigurationProvider",self.ctx)
         node = uno.createUnoStruct("com.sun.star.beans.PropertyValue")
         node.Name = "nodepath"
         node.Value = self.CFGNODE
         self.node = node
         
         self.cfg_names = ("MaximumPaperHeight","MaximumPaperWidth")
         return
     
     #XContainerWindowEventHandler
     def callHandlerMethod(self,window,eventObject,method):
         if method == "external_event":
             try:
                 self.handleExternalEvent(window,eventObject)
             except:
                 pass
         return True
     
     #XContainerWindowEventHandler
     def getSupportedMethodNames(self):
         return ("external_event",)
     
     def supportsService(self,name):
         return False
     
     def getImplementationName(self):
         return "mytools.extensions.maximumpapersize.DilaogHandler"
     
     def getSupportedServiceNames(self):
         return ()
     
     
     def handleExternalEvent(self,window,eventName):
         if eventName == "ok":
             self.saveData(window)
         elif eventName == "back":
             self.loadData(window,"back")
         elif eventName == "initialize":
             self.loadData(window,"initialize")
         return True
     
     # load and set the data
     def loadData(self,window,ev):
         name = window.getModel().Name
         if name != "mytools_Extensions_MaximumPaperSize":
             return
         
         settings = self.configreader()
         if settings:
             cfgs = self.cfg_names
             nf_width = window.getControl("nf_width")
             nf_height = window.getControl("nf_height")
             nf_height.Value = settings[cfgs[0]] / 100
             nf_width.Value = settings[cfgs[1]] / 100
             
         if ev == "initialize":
             listener = ButtonListener(self,window)
             btn_width = window.getControl("btn_width")
             btn_height = window.getControl("btn_height")
             btn_width.ActionCommand = "width"
             btn_height.ActionCommand = "height"
             btn_width.addActionListener(listener)
             btn_height.addActionListener(listener)
         return
     
     # making the save data
     def saveData(self,window):
         name = window.getModel().Name
         if name != "mytools_Extensions_MaximumPaperSize":
             return
         nf_height = window.getControl("nf_height")
         nf_width = window.getControl("nf_width")
         settings = []
         settings.append(long(nf_height.Value * 100))
         settings.append(long(nf_width.Value * 100))
         t_settings = tuple(settings)
         
         self.configwriter(t_settings)
         return
     
     # read configuration
     def configreader(self):
         settings = {}
         try:
             ConfigReader = self.cp.createInstanceWithArguments( 
                 "com.sun.star.configuration.ConfigurationAccess",(self.node,))
             cfg_values = ConfigReader.getPropertyValues(self.cfg_names)
             
             for i in range(len(self.cfg_names)):
                 settings[self.cfg_names[i]] = cfg_values[i]
         except:
             raise
         return settings
     
     # write configuration, cfg_values: tuple
     # keep the order of the values
     def configwriter(self,cfg_values):
         try:
             ConfigWriter = self.cp.createInstanceWithArguments( 
                 "com.sun.star.configuration.ConfigurationUpdateAccess",(self.node,))
             ConfigWriter.setPropertyValues(self.cfg_names,cfg_values)
             
             ConfigWriter.commitChanges() # commits
         except:
             raise
 
 ###
 # uno implementation
 g_ImplementationHelper = unohelper.ImplementationHelper()
 g_ImplementationHelper.addImplementation(
     DilaogHandler,"mytools.MaximumPaperSize.DialogHandler",
     ("mytools.MaximumPaperSize.DialogHandler",),)
 ###