#!/usr/bin/python ########################################################################### # kdeapp - description # # ------------------------------ # # begin : Fri Jun 27 2005 # # copyright : (C) 2005 by AUTHOR # # email : your@email.com # # # ########################################################################### # # # 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 PyTQt.tqt import * from tdecore import * from tdeui import * import sys from prefdialog import * from kdeappview import * description = "A KDE Application" version = "0.1"; class KdeApp(TDEMainWindow): def __init__(self): TDEMainWindow.__init__(self,None,"KdeApp") self._view = KdeAppView(self) self._printer = None # accept dnd self.setAcceptDrops(True) # tell the TDEMainWindow 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 = TQString() # 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 TDEIO.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 TDEIO.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 = TDEAction(i18n("Cus&tom Menuitem"), TDEShortcut(), 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 TQt 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(TQString::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 TQt, you always "print" to a # TQPainter.. whether the output medium is a pixmap, a screen, # or paper p = TQPainter() p.begin(self._printer) # we let our view do the actual printing metrics = TQPaintDeviceMetrics(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(TDEGlobal.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(TDEGlobal.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 = TDEAboutData("kdeapp", "KdeApp", version, description, \ TDEAboutData.License_GPL, "(C) 2005 AUTHOR", None, None, "your@email.com") aboutdata.addAuthor("AUTHOR", None, "your@email.com") TDECmdLineArgs.init(sys.argv,aboutdata) TDECmdLineArgs.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 TDEMainWindow.canBeRestored(n): KdeApp().restore(n) n += 1 else: # no session.. just start up normally args = TDECmdLineArgs.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()