You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
281 lines
10 KiB
281 lines
10 KiB
#!/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()
|