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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
|
#!/usr/bin/python
###########################################################################
# kdeapp - description #
# ------------------------------ #
# begin : Fri Jun 27 2005 #
# copyright : (C) 2005 by AUTHOR #
# email : [email protected] #
# #
###########################################################################
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
###########################################################################
from qt import *
from tdecore import *
from tdeui import *
import sys
from prefdialog import *
from kdeappview import *
description = "A KDE Application"
version = "0.1";
class KdeApp(KMainWindow):
def __init__(self):
KMainWindow.__init__(self,None,"KdeApp")
self._view = KdeAppView(self)
self._printer = None
# accept dnd
self.setAcceptDrops(True)
# tell the KMainWindow that this is indeed the main widget
self.setCentralWidget(self._view)
# then, setup our actions
self._setupActions()
# and a status bar
self.statusBar().show()
# Apply the create the main window and ask the mainwindow to
# automatically save settings if changed: window size, toolbar
# position, icon size, etc. Also to add actions for the statusbar
# toolbar, and keybindings if necessary.
self.setAutoSaveSettings()
# allow the view to change the statusbar and caption
self.connect(self._view, PYSIGNAL("signalChangeStatusbar"), self.changeStatusbar)
self.connect(self._view, PYSIGNAL("signalChangeCaption"), self.changeCaption)
def load(self,url):
target = QString()
# the below code is what you should normally do. in this
# example case, we want the url to our own. you probably
# want to use this code instead for your app
if False:
# download the contents
if KIO.NetAccess.download(url, target):
# set our caption
self.setCaption(url)
# load in the file (target is always local)
self.loadFile(target)
# and remove the temp file
KIO.NetAccess.removeTempFile(target)
self.setCaption(url.prettyURL())
self._view.openURL(url)
def _setupActions(self):
global kapp
KStdAction.openNew(self.fileNew, self.actionCollection())
KStdAction.open(self.fileOpen, self.actionCollection())
KStdAction.save(self.fileSave, self.actionCollection())
KStdAction.saveAs(self.fileSaveAs, self.actionCollection())
KStdAction.print_(self.filePrint, self.actionCollection())
KStdAction.quit(kapp.quit, self.actionCollection())
self._toolbarAction = KStdAction.showToolbar(self.optionsShowToolbar, self.actionCollection())
self._statusbarAction = KStdAction.showStatusbar(self.optionsShowStatusbar, self.actionCollection())
KStdAction.keyBindings(self.optionsConfigureKeys, self.actionCollection())
KStdAction.configureToolbars(self.optionsConfigureToolbars, self.actionCollection())
KStdAction.preferences(self.optionsPreferences, self.actionCollection())
# this doesn't do anything useful. it's just here to illustrate
# how to insert a custom menu and menu item
custom = KAction(i18n("Cus&tom Menuitem"), KShortcut(),
self.optionsPreferences,
self.actionCollection(), "custom_action")
self.createGUI()
def _saveProperties(self,config):
# the 'config' object points to the session managed
# config file. anything you write here will be available
# later when this app is restored
if not self._view.currentURL().isEmpty():
config.writeEntry("lastURL", self._view.currentURL())
def _readProperties(self,config):
# the 'config' object points to the session managed
# config file. this function is automatically called whenever
# the app is being restored. read in here whatever you wrote
# in 'saveProperties'
url = config.readPathEntry("lastURL")
if not url.isEmpty():
self._view.openURL(KURL(url))
def dragEnterEvent(self,event):
# accept uri drops only
event.accept(KURLDrag.canDecode(event))
def dropEvent(self,event):
# this is a very simplistic implementation of a drop event. we
# will only accept a dropped URL. the Qt dnd code can do *much*
# much more, so please read the docs there
urls = KURL.List()
# see if we can decode a URI.. if not, just ignore it
if KURLDrag.decode(event, urls) and not urls.isEmpty():
# okay, we have a URI.. process it
url = urls.first()
# load in the file
self.load(url)
def fileNew(self):
# this slot is called whenever the File->New menu is selected,
# the New shortcut is pressed (usually CTRL+N) or the New toolbar
# button is clicked
# create a new window
KdeApp().show()
def fileOpen(self):
# this slot is called whenever the File->Open menu is selected,
# the Open shortcut is pressed (usually CTRL+O) or the Open toolbar
# button is clicked
## this brings up the generic open dialog
#KURL url = KURLRequesterDlg::getURL(QString::null, this, i18n("Open Location") );
# standard filedialog
url = KFileDialog.getOpenURL(None, One, self, i18n("Open Location"))
if not url.isEmpty():
self._view.openURL(url)
def fileSave(self):
# this slot is called whenever the File->Save menu is selected,
# the Save shortcut is pressed (usually CTRL+S) or the Save toolbar
# button is clicked
# save the current file
pass
def fileSaveAs(self):
# this slot is called whenever the File->Save As menu is selected,
file_url = KFileDialog.getSaveURL()
if not file_url.isEmpty() and file_url.isValid():
# save your info, here
pass
def filePrint(self):
# this slot is called whenever the File->Print menu is selected,
# the Print shortcut is pressed (usually CTRL+P) or the Print toolbar
# button is clicked
if self._printer is None:
self._printer = KPrinter()
if self._printer.setup(self):
# setup the printer. with Qt, you always "print" to a
# QPainter.. whether the output medium is a pixmap, a screen,
# or paper
p = QPainter()
p.begin(self._printer)
# we let our view do the actual printing
metrics = QPaintDeviceMetrics(m_printer)
self._view.print_(p, metrics.height(), metrics.width())
# and send the result to the printer
p.end();
def optionsPreferences(self):
# popup some sort of preference dialog, here
dlg = PreferencesDialog()
if dlg.exec_loop():
# redo your settings
pass
def optionsShowToolbar(self):
# this is all very cut and paste code for showing/hiding the
# toolbar
if self._toolbarAction.isChecked():
self.toolBar().show()
else:
self.toolBar().hide()
def optionsShowStatusbar(self):
# this is all very cut and paste code for showing/hiding the
# statusbar
if self._statusbarAction.isChecked():
self.statusBar().show()
else:
self.statusBar().hide()
def optionsConfigureKeys(self):
KKeyDialog.configure(self.actionCollection())
def optionsConfigureToolbars(self):
# use the standard toolbar editor
self.saveMainWindowSettings(KGlobal.config())
def newToolbarConfig(self):
# this slot is called when user clicks "Ok" or "Apply" in the toolbar editor.
# recreate our GUI, and re-apply the settings (e.g. "text under icons", etc.)
self.createGUI()
self.applyMainWindowSettings(KGlobal.config())
def changeStatusbar(self,text):
# display the text on the statusbar
self.statusBar().message(text)
def changeCaption(self,text):
# display the text on the caption
self.setCaption(text)
options = [ ("+[URL]", "Document to open", "") ]
def main():
global kapp,version,description,options
aboutdata = KAboutData("kdeapp", "KdeApp", version, description, \
KAboutData.License_GPL, "(C) 2005 AUTHOR", None, None, "[email protected]")
aboutdata.addAuthor("AUTHOR", None, "[email protected]")
KCmdLineArgs.init(sys.argv,aboutdata)
KCmdLineArgs.addCmdLineOptions(options)
kapp = TDEApplication()
# register ourselves as a dcop client
kapp.dcopClient().registerAs(kapp.name(), False)
# see if we are starting with session management
if kapp.isRestored():
n = 1
while KMainWindow.canBeRestored(n):
KdeApp().restore(n)
n += 1
else:
# no session.. just start up normally
args = KCmdLineArgs.parsedArgs()
if args.count() == 0:
widget = KdeApp()
widget.show()
else:
i = 0
for i in range(args.count()):
widget = KdeApp()
widget.show()
widget.load(args.url(i))
args.clear()
return kapp.exec_loop()
main()
|