> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
> """Shows how to use the dSplitter
> """
> #node: Basic controls/dSplitter
> import dabo
> dabo.ui.loadUI("wx")
>
>
> class tSplitter(dabo.ui.dSplitter):
> def __init__(self, *args, **kwargs):
> kwargs["createPanes"] = True
> super(tSplitter, self).__init__(*args, **kwargs)
>
> def initProperties(self):
> self.Width = 250
> self.Height = 200
> self.MinimumPanelSize = 20
>
> def afterInit(self):
> self.Panel1.Sizer = dabo.ui.dSizer()
> self.Panel2.Sizer = dabo.ui.dSizer()
>
> self.edit1 = dabo.ui.dEditBox(self.Panel1)
> self.edit2 = dabo.ui.dEditBox(self.Panel2)
>
> self.Panel1.Sizer.append1x(self.edit1)
> self.Panel2.Sizer.append1x(self.edit2)
>
> def onSashDoubleClick(self, evt):
> if not dabo.ui.areYouSure("Remove the sash?"):
> evt.stop()
>
> class TestPanel(dabo.ui.dPanel):
> def afterInit(self):
> self.Sizer = dabo.ui.dSizer()
> self.mySplitter = tSplitter(self, Orientation="v")
> self.Sizer.append1x(self.mySplitter)
>
> class TestForm(dabo.ui.dForm):
> def afterInit(self):
> pnl = self.addObject(TestPanel)
> self.Sizer.append1x(pnl)
>
>
> def runTest():
> app = dabo.dApp()
> app.MainFormClass = TestForm
> app.start()
>
>
> if __name__ == "__main__":
> runTest()
> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OK, after I made the same changes to the Editor, it made it slightly
better, however, I have to right click and 'switch orientation' for it
to show correctly. Otherwise, the dEditor part doesnt even show.
here is the code:
#!/usr/bin/env python
import sys
import os, os.path
import keyword
import code
import inspect
import subprocess
import dabo
import dabo.dEvents as dEvents
from dabo.dLocalize import _
import dabo.dConstants as kons
if __name__ == "__main__":
dabo.ui.loadUI("wx")
class _dSplitterEPage(dabo.ui.dSplitter):
def __init__(self, *args, **kwargs):
kwargs["createPanes"] = True
super(_dSplitterEPage, self).__init__(*args, **kwargs)
def initProperties(self):
self.Width = 250
self.Height = 200
self.MinimumPanelSize = 20
def afterInit(self):
import random
import dabo.dColors as dColors
self.Panel1.BackColor =
random.choice(dColors.colorDict.values())
self.Panel2.BackColor =
random.choice(dColors.colorDict.values())
def onSashDoubleClick(self, evt):
evt.stop()
def _onContextMenu(self, evt):
evt.stop()
class EditorPage(dabo.ui.dPage):
def initProperties(self):
self.p = None
self.outputText = ""
def afterInit(self):
self.splitter = _dSplitterEPage(self, Orientation = "h")
self.splitter.Panel1.Sizer = dabo.ui.dSizer()
self.splitter.Panel2.Sizer = dabo.ui.dSizer()
self.editor = dabo.ui.dEditor(self.splitter.Panel1)
self.output = dabo.ui.dEditBox(self.splitter.Panel2)
#self.output.Enabled = False
self.splitter.Panel1.Sizer.append1x(self.editor)
self.splitter.Panel2.Sizer.append1x(self.output)
self.Sizer = dabo.ui.dSizer()
self.Sizer.append1x(self.splitter)
self.updateTimer = dabo.ui.dCallEvery(self, self.outputUpdate,
1000)
self.layout()
self.editor.setFocus()
self.editor.bindEvent(dEvents.TitleChanged, self.onTitleChanged)
self.editor.bindEvent(dEvents.MouseRightClick,
self.Form.onEditorRightClick)
# Set the initial title
dabo.ui.callAfter(self.onTitleChanged, None)
def outputUpdate(self):
if not self.p is None:
#need a nonblocking way of getting stdout and stderr
self.outputText = self.outputText +
self.p.stdout.read() +
self.p.stderr.read()
if not self.p.poll() is None:
self.p = None
self.output.Value = self.outputText
def onTitleChanged(self, evt):
title = self.editor._title
self.Caption = title
self.Form.onTitleChanged(evt)
def onPageEnter(self, evt):
self.editor.setFocus()
def onPageLeave(self, evt):
self.editor.setInactive()
class EditorPageFrame(dabo.ui.dPageFrame):
def beforeInit(self):
self.PageClass = EditorPage
def checkChanges(self):
"""Cycle through the pages, and if any contain unsaved changes,
ask the user if they should be saved. If they cancel,
immediately
stop and return False. If they say yes, save the contents.
Unless
they cancel, close each page.
"""
ret = True
for pg in self.Pages[::-1]:
ed = pg.editor
ret = ed.checkChangesAndContinue()
if not ret:
break
# self.PageCount -= 1
return ret
def findEditor(self, pth, selectIt=False):
"""Returns the editor that is editing the specified file. If
there
is no matching editor, returns None. If selectIt is True, makes
that
editor the active editor.
"""
ret = None
for pg in self.Pages:
if pg.editor._fileName == pth:
ret = pg.editor
if selectIt:
self.SelectedPage = pg
return ret
def editFile(self, pth, selectIt=False):
ret = self.findEditor(pth, selectIt)
if ret is None:
# Create a new page
pg = self.getBlankPage(True)
pg.editor.openFile(pth)
self.SelectedPage = pg
ret = pg
return ret
def getBlankPage(self, create=False):
"""Returns the first page that is not associated with a file,
and which has not been modified. If no such page exists, and
the 'create' parameter is True, a new blank page is created
and returned. Otherwise, returns None.
"""
ret = None
for pg in self.Pages:
ed = pg.editor
if ed._title.strip() == ed._newFileName.strip():
ret = pg
break
if ret is None and create:
self.PageCount += 1
ret = self.Pages[-1]
return ret
def closeEditor(self, ed=None):
if ed is None:
ed = self.SelectedPage.editor
ret = ed.checkChangesAndContinue()
if ret is not False:
pg = ed.Parent
self.removePage(pg)
return ret
def newEditor(self):
return self.getBlankPage(True)
def selectByCaption(self, cap):
pgs = [pg for pg in self.Pages
if pg.Caption == cap]
if pgs:
pg = pgs[0]
else:
dabo.errorLog.write(_("No matching page for %s") % cap)
return
self.SelectedPage = pg
pg.editor.setFocus()
def edFocus(self):
self.SelectedPage.editor.setFocus()
def _getCurrentEditor(self):
try:
return self.SelectedPage.editor
except:
return None
def _getTitle(self):
try:
ret = self.SelectedPage.Caption
except:
ret = ""
return ret
CurrentEditor = property(_getCurrentEditor, None, None,
_("References the currently active editor (dEditor)"))
Title = property(_getTitle, None, None,
_("Title of the active page (str)") )
class EditorForm(dabo.ui.dForm):
def afterInit(self):
self.AutoUpdateStatusText = False
self.StatusText = ""
pnl = dabo.ui.dPanel(self)
self.Sizer.append1x(pnl)
pnl.Sizer = dabo.ui.dSizer("v")
self._lastPath = os.getcwd()
super(EditorForm, self).afterInit()
self.Caption = "Dabo Editor"
self.funcButton = dabo.ui.dImage(pnl, ScaleMode="Clip",
Size=(22,22))
self.funcButton.Picture =
dabo.ui.imageFromData(funcButtonData())
self.funcButton.bindEvent(dEvents.MouseLeftDown,
self.onFuncButton)
self.bmkButton = dabo.ui.dImage(pnl, ScaleMode="Clip",
Size=(22,22))
self.bmkButton.Picture = dabo.ui.imageFromData(bmkButtonData())
self.bmkButton.bindEvent(dEvents.MouseLeftDown,
self.onBmkButton)
btnSizer = dabo.ui.dSizer("H", Spacing=4)
btnSizer.append(self.funcButton)
btnSizer.append(self.bmkButton)
pnl.Sizer.append(btnSizer, border=4)
self.pgfEditor = EditorPageFrame(pnl, TabPosition="Top")
self.pgfEditor.bindEvent(dEvents.PageChanged,
self.onEditorPageChanged)
pnl.Sizer.append1x(self.pgfEditor)
self.layout()
if self.CurrentEditor:
self.CurrentEditor.setFocus()
self.fillMenu()
def onFuncButton(self, evt):
evt.stop()
flist = self.CurrentEditor.getFunctionList(True)
pop = dabo.ui.dMenu()
for nm, pos in flist:
prompt = nm
if nm.startswith("def "):
prompt = " - %s" % nm[4:]
itm = pop.append(prompt, bindfunc=self.onFunctionPop)
itm.textPosition = pos
self.showContextMenu(pop)
del pop
def onFunctionPop(self, evt):
ed = self.CurrentEditor
pos = evt.menuItem.textPosition
currLine = ed.LineNumber
newLine = ed.LineFromPosition(pos)
if newLine > currLine:
ed.moveToEnd()
ed.LineNumber = newLine
def onEditorRightClick(self, evt):
ed = self.CurrentEditor
pos = evt.mousePosition
pp = ed.PositionFromPointClose(*pos)
if pp < 0:
# They clicked outside of the text area of the line.
Find
# a position just to the right of the margin
lpos = ed.getMarginWidth()
pp = ed.PositionFromPointClose(lpos, pos[1])
if pp < 0:
# This is a totally blank line. Nothing can be done
return
ln = ed.LineFromPosition(pp)
ed.LineNumber = ln
self.onBmkButton(evt)
def onBmkButton(self, evt):
evt.stop()
ed = self.CurrentEditor
bmkList = ed.getBookmarkList()
pop = dabo.ui.dMenu()
currBmk = ed.getCurrentLineBookmark()
if not currBmk:
pop.append(_("Set Bookmark..."), bindfunc=self.onSetBmk)
else:
pop.append(_("Clear Bookmark..."),
bindfunc=self.onClearBmk)
if bmkList:
pop.append(_("Clear All Bookmarks"),
bindfunc=self.onClearAllBmk)
pop.appendSeparator()
for nm in bmkList:
itm = pop.append(nm,
bindfunc=self.onBookmarkPop)
self.showContextMenu(pop)
del pop
def onBookmarkPop(self, evt):
"""Navigate to the chosen bookmark."""
self.CurrentEditor.findBookmark(evt.prompt)
def onSetBmk(self, evt):
"""Need to ask the user for a name for this bookmark."""
nm = dabo.ui.getString(message="Name for this bookmark:",
caption="New Bookmark")
if not nm:
# User canceled
return
ed = self.CurrentEditor
if nm in ed.getBookmarkList():
msg = _("There is already a bookmark named '%s'.
Creating a new bookmark "
"with the same name will delete the old
one. Are you sure you want "
"to do this?") % nm
answer = dabo.ui.areYouSure(message=msg,
title=_("Duplicate Name"),
defaultNo=True, cancelButton=False)
print "ANS", answer, type(answer)
self.CurrentEditor.setBookmark(nm)
def onClearBmk(self, evt):
"""Clear the current bookmark."""
ed = self.CurrentEditor
bmk = ed.getCurrentLineBookmark()
if bmk:
ed.clearBookmark(bmk)
def onClearAllBmk(self, evt):
"""Remove all the bookmarks."""
self.CurrentEditor.clearAllBookmarks()
def onEditorPageChanged(self, evt):
self.onTitleChanged(evt)
def beforeClose(self, evt):
return self.pgfEditor.checkChanges()
def onDocumentationHint(self, evt):
# Eventually, a separate IDE window can optionally display help
contents
# for the object. For now, just print the longdoc to the
infolog.
dabo.infoLog.write("Documentation Hint received:\n\n%s" %
evt.EventData["longDoc"])
def onTitleChanged(self, evt):
self.Caption = _("Dabo Editor: %s") % self.pgfEditor.Title
def fillMenu(self):
mb = self.MenuBar
fileMenu = mb.getMenu("File")
editMenu = mb.getMenu("Edit")
runMenu = dabo.ui.dMenu(Caption="&Run")
mb.insertMenu(2, runMenu)
viewMenu = mb.getMenu("View")
dIcons = dabo.ui.dIcons
fileMenu.prependSeparator()
fileMenu.prepend("Save &As\tCtrl+Shift+S",
bindfunc=self.onFileSaveAs, bmp="saveAs",
help="Save under a different file name")
fileMenu.prepend("&Save\tCtrl+S", bindfunc=self.onFileSave,
bmp="save",
help="Save file")
cPos = fileMenu.getItemIndex("Close Window")
if cPos is not None:
fileMenu.remove(cPos)
fileMenu.prepend("&Close Editor\tCtrl+W",
bindfunc=self.onFileClose,
bmp="close",
help="Close file")
fileMenu.prepend("&Open\tCtrl+O", bindfunc=self.onFileOpen,
bmp="open",
help="Open file")
fileMenu.prepend("&New\tCtrl+N", bindfunc=self.onFileNew,
bmp="new",
help="New file")
editMenu.appendSeparator()
editMenu.append("&Jump to line...\tCtrl+J",
bindfunc=self.onEditJumpToLine,
bmp="", help="Jump to line")
editMenu.appendSeparator()
editMenu.append("Co&mment Line\tCtrl+M",
bindfunc=self.onCommentLine,
bmp="", help="Comment out selection")
editMenu.append("&Uncomment Line\tCtrl+Shift+M",
bindfunc=self.onUncommentLine, bmp="",
help="Uncomment selection")
editMenu.appendSeparator()
editMenu.append("&Word Wrap\tCtrl+Shift+W",
bindfunc=self.onWordWrap,
bmp="", help="Toggle WordWrap",
menutype="check")
mnit = editMenu.append("S&yntax Coloring\tCtrl+Shift+Y",
bindfunc=self.onSyntaxColoring,
bmp="", help="Toggle Syntax Coloring")
runMenu.append("&Run Script\tF7", bindfunc=self.onRunScript,
bmp="", help="Run Script")
fontMenu = dabo.ui.dMenu(Caption="Font")
mb.insertMenu(3, fontMenu)
fonts = dabo.ui.getAvailableFonts()
fontMenu.append("Set Font Size", bindfunc=self.onFontSize,
help="Set Default Font Size")
fontMenu.appendSeparator()
fontMenu.append("Zoom &In\tCtrl++", bindfunc=self.onViewZoomIn,
bmp="zoomIn", help="Zoom In")
fontMenu.append("&Normal Zoom\tCtrl+/",
bindfunc=self.onViewZoomNormal,
bmp="zoomNormal", help="Normal Zoom")
fontMenu.append("Zoom &Out\tCtrl+-",
bindfunc=self.onViewZoomOut,
bmp="zoomOut", help="Zoom Out")
fontMenu.appendSeparator()
for font in fonts:
fontMenu.append(font, bindfunc=self.onFontSelection)
vp = mb.getMenuIndex("Font")
edtMenu = mb.insert(vp+1, "Editors")
mb.remove(mb.getMenuIndex("View"))
# bind the hotkeys
self.bindKey("alt+Left", self.onPrevPg)
self.bindKey("alt+Right", self.onNextPg)
self.bindKey("alt+shift+Left", self.onMoveLeft)
self.bindKey("alt+shift+Right", self.onMoveRight)
def onFontSelection(self, evt):
"""The user selected a font face for the editor."""
face = evt.EventObject.Caption
self.CurrentEditor.changeFontFace(face)
def onFontSize(self, evt):
"""Change the default font size for the editor."""
val = dabo.ui.getInt("Select new font size", "Font Size",
self.CurrentEditor._fontSize)
if val is not None:
self.CurrentEditor.changeFontSize(val)
def onMenuOpen(self, evt):
"""Currently this never fires under Windows."""
mn = evt.menuObject
prm = evt.prompt
if prm == "Editors":
mn.clear()
for pg in self.pgfEditor.Pages:
prmpt = pg.editor._title
mn.append(prmpt,
bindfunc=self.onEditorSelected, help="Select %s" % prmpt)
def onEditorSelected(self, evt):
"""Called when a menuitem in the Editors menu is chosen."""
cap = evt.EventObject.Caption
self.pgfEditor.selectByCaption(cap)
def onFileNew(self, evt):
target = self.pgfEditor.newEditor()
target.setFocus()
def onFileOpen(self, evt):
fileName = self.CurrentEditor.promptForFileName(prompt="Open",
path=self._lastPath)
if fileName is not None:
self._lastPath = os.path.split(fileName)[0]
self.openFile(fileName)
def onMRUSelection(cls, evt):
"""This needs to be a classmethod, since the form
that originally opens a file path might get closed, and
if we bound the MRU action to an instance method, it
would barf. So we make this a classmethod, and pass
the call to the first EditorForm instance we can find.
"""
pth = " ".join(evt.prompt.split(" ")[1:])
# Find the topmost form that is an EditorForm
app = dabo.dAppRef
try:
app.ActiveForm.openFile(pth)
except:
# Call the first available EditorForm
edf = [frm for frm in app.uiForms
if isinstance(frm, EditorForm)][0]
edf.openFile(pth)
onMRUSelection = classmethod(onMRUSelection)
def openFile(self, pth):
"""Open the selected file, if it isn't already open. If it is,
bring its Editor to the front.
"""
# Add to the MRU list
fm = self.MenuBar.getMenu("File")
self.Application.addToMRU(fm, pth, self.onMRUSelection)
target = self.pgfEditor.editFile(pth, True)
return target
def onFileSave(self, evt):
self.CurrentEditor.saveFile()
def onFileClose(self, evt):
self.pgfEditor.closeEditor()
if self.pgfEditor.PageCount == 0:
self.release()
evt.stop()
def onFileSaveAs(self, evt):
fname = self.CurrentEditor.promptForSaveAs()
if fname:
self.CurrentEditor.saveFile(fname)
def onEditJumpToLine(self, evt):
class LineNumberDlg(dabo.ui.dOkCancelDialog):
def addControls(self):
self.Caption = _("Jump To Line")
self.lblLine = dabo.ui.dLabel(self,
Caption=_("Line Number:"))
self.txtLine = dabo.ui.dTextBox(self,
SelectOnEntry=True)
hs = dabo.ui.dSizer("h")
hs.append(self.lblLine, valign="middle")
hs.append(self.txtLine, valign="middle")
self.Sizer.append(hs, 1, halign="center")
self.layout()
#- # Map escape key to cancelbutton:
#- self.bindKey("esc", self.onCancel)
#- # Map enter key to accept button:
#- self.bindKey("enter", self.onAccept)
currEditor = self.CurrentEditor
dlg = LineNumberDlg(self)
dlg.txtLine.Value = currEditor.LineNumber + 1
dlg.txtLine.Min = 1
dlg.txtLine.Max = currEditor.LineCount
dlg.Centered = dlg.Modal = True
dlg.AutoSize = False
dlg.show()
if dlg.Accepted:
currEditor.LineNumber = dlg.txtLine.Value - 1
dlg.release()
def onCommentLine(self, evt):
if self.CurrentEditor:
self.CurrentEditor.onCommentLine(evt)
def onUncommentLine(self, evt):
if self.CurrentEditor:
self.CurrentEditor.onUncommentLine(evt)
def onRunScript(self, evt):
""" Save the script to temp dir, and run it."""
#pkm: this isn't finished, just a quick stab. os.system() is
inadequate
# because it blocks. Need to use something like
os.popen2(). And on
# Mac the command needs to be "pythonw" instead of
"python". Also,
# stderr and stdout should be captured and displayed in a
"terminal"
# window.
ed = self.CurrentEditor
txt = ed.Text
fname = os.tmpnam()
f = open(fname, "w")
f.write(txt)
f.close()
#os.system("python %s" % fname)
#os.remove(fname)
#The Echo hack:
self.pgfEditor.SelectedPage.outputText = ""
self.pgfEditor.SelectedPage.p = subprocess.Popen("pythonw %s" %
fname,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def onViewZoomIn(self, evt):
ed = self.CurrentEditor
ed.increaseTextSize()
self.Application.setUserSetting("editor.zoom", ed.ZoomLevel)
def onViewZoomNormal(self, evt):
ed = self.CurrentEditor
ed.restoreTextSize()
self.Application.setUserSetting("editor.zoom", ed.ZoomLevel)
def onViewZoomOut(self, evt):
ed = self.CurrentEditor
ed.decreaseTextSize()
self.Application.setUserSetting("editor.zoom", ed.ZoomLevel)
def onWordWrap(self, evt):
self.CurrentEditor.toggleWordWrap()
def onSyntaxColoring(self, evt):
self.CurrentEditor.toggleSyntaxColoring()
def onPrevPg(self, evt):
self.pgfEditor.cyclePages(-1)
self.pgfEditor.edFocus()
def onNextPg(self, evt):
self.pgfEditor.cyclePages(1)
self.pgfEditor.edFocus()
def onMoveLeft(self, evt):
"""Move the selected page over one to the left in the
pageframe. If it is already the leftmost, move it to the
end of the right side.
"""
pgf = self.pgfEditor
pg = pgf.SelectedPage
pos = pgf.Pages.index(pg)
if pos == 0:
# First page; move it to the end
newPos = pgf.PageCount - 1
else:
newPos = pos - 1
pgf.movePage(pos, newPos)
def onMoveRight(self, evt):
"""Move the selected page over one to the right in the
pageframe. If it is already the rightmost, move it to the
first position on the left.
"""
pgf = self.pgfEditor
pg = pgf.SelectedPage
pos = pgf.Pages.index(pg)
if pos == (pgf.PageCount - 1):
# Last page; move it to the beginning
newPos = 0
else:
newPos = pos + 1
pgf.movePage(pos, newPos)
def _getCurrentEditor(self):
return self.pgfEditor.CurrentEditor
CurrentEditor = property(_getCurrentEditor, None, None,
_("References the currently active editor (dEditor)"))
def funcButtonData():
return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x02\'[EMAIL PROTECTED] $J\xf4Z*()\xa8h\x80\x8e\
\x03 ([EMAIL PROTECTED] R\x02\x9b\xec/&\
\xcf\xec\x07=\x17Q\xe4\xb5g\xed\x99\x1d\xb3\xd9l\xe8\x8f0\xc6\x10\x91\xf7>\
\xccx\xef?\xf2BD\x8b\xc5\xa2Z\xad\xea\x81\xd6\x85\xd5aR\x11\x1f\x8f\xc7v\xbb\
\x15"\xba\xdf\xef\xcc\x8cjc\x8c\xd6}\xa3\xe8\xe5\xc6\x18\xe7\\\x92$\xe5\x14\
\xd7\xeb5\xcb2k-\x80P]\x14\x05\x11\x89\x88s\xce{\x8f\xd3\xa2(p\x9a\xe7\xb9s.\
M\xd3\x12"\x8a"\x11\xa9T*\xd6Z\xe7\x9c\xb5\xd6{_\x14\x053\x03\x05p\xc6\x18d\
\x8c1Q\x14=\x9f\xcf7\x84\x88`~f\xb6\xd6\x02\x82\x99\x9b\xcd&v\xbe\\.X\x81\
\x99\xbd\xf7\xd8\x85\x99E\xa4\x84 \xa2J\xa5\x12E\x911\xc6Z\x8b]\xea\xf5:\x11\
\xed\xf7{":\x1e\x8f\xbd^/\xa4&\xcfs\xb4\x10\x91h\x1b\xbe\x1f\x9c\x13Q\xbf\
\xdf\x0fY\x04\n\xe8D\x8b(U\x98*$\x1f\x11r\xacL333\xe7y\xee\xbd\xff\x94\x00=\
[EMAIL PROTECTED] \xf6\
[EMAIL PROTECTED]
\xd7\xcb)k\xa2\xe3A\xd1O\x9f\x10i\xb3\x12d\x8c\x11\xb1\xce\xbd\xde\x1eQ!B\
\xd94>\x9e|\x08\xfd^\x04\x0cA\x11f\x8e\xe3X\x89P\x08\n\xac\t\x11\xbd\xf7\xce\
9"*Y\x80\x1c )M\xd3\xd3\xe9\x84\xfe\xd1h\x04\n\xa7\xd3i\xab\xd5\x8a\xe3\xb8\
\xd5j\xcdf30\x8a\xc5E\xa7\x02\x17\xb8\xaa\xddn\xb7\xdb\xed\xf0\xda\xe5ry>\
\x9f\xb3,k4\x1a\xcb\xe5\x12\xf7\x95\x04+\x91\x18\x01\x1b\xf1o \x1fEQ\xb7\xdb\
]\xaf\xd7???\xab\xd5\xaa\xd3\xe9\xc0\rX\xb04\x98\x88 \xab\x14~K3\x1c\x0e/\
\x97\xcbx<\xa6_\x8f\xfdg\xb3\xa2(\xd4\xdd:|\xe8\x17\x80\xce\xe7s5\xbe\xf7>\
\xcfs"\x12\xfc%I\xe2\x9c\xfbxW\xdf\x02\x87\x91e\xd9\xf3\xf9,!v\xbb\xdd_u\xdf\
\xf1m\xe5\x7f\xd0\xdbI\xf9\xcd\xb6\xabn\x00\x00\x00\x00IEND\xaeB`\x82'
def bmkButtonData():
return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x02\x7fIDAT8\x8duT\xbbJ,A\x10\xad\xee\xae\xdeUaDA\x84\xc5H\x19\xfc\x00A\xff\
BL\x0c\x16\x0c\x84\xf5\x01F\x1bh*\x88\x9f`.F~\x83b&\x08\xfe\x82\x82\xf1dF\
\xce\xa2=\xb7\xbb\xeb\x06gn9w\xbd\xb7\x83a\xa6\xab\xfa\xf4\xa9s\xaa\xc6\\^^\
\xd2\x7f\x961\x86\x88D\xa4\xbb#"S\xfbLD\'\'\'\x8b\x8b\x8b\x1a\xd0\xbcnvwS\
\x11\xeb\xba\xbe\xba\xbab"\xfa\xf8\xf8\xb0\xd6"\xdb\x18\xa3y?Q\xf4rcL\x8cq2\
\x99\xb4,\xde\xdf\xdfC\x08\xce9\x00!;\xe7LD\xcc\x1cc\x14\x11Ds\xce\x88\xa6\
\x94b\x8c___-\x84\xf7\x9e\x99{\xbd\x9es.\xc6\xe8\x9c\x13\x91\x9cs\xd349gf\
\xb6\xd6\xe2f}\xf1\xde7M\xf3\r\xc1\xcc\xe0o\xadu\xce\x01"\xa5\xd4\xef\xf7\
\xb5\x1c"\x02\x11\x11\xc1\xa7\xb5\x96\x99[\x08"\xea\xf5z\xde{c\x8csn0\x18\
\xe4\x9c\xcb\xb2|~~F\xcd\x1b\x1b\x1bUU-,,[EMAIL PROTECTED]
\x91\xc51<\xb1\x00\xfa\xf6\xf6\xf6\xf8\xf8HDwwwUU\xb5\xfe1;\xe7\x98\x19\xc4q\
\xd0\xaaT\x08\xa3Z\xef\xfd\xf2\xf2\xf2\xcd\xcd\r3___\xaf\xac\xac\x00\x02i(\
\xd9Z\x9bR\x12\x91i\x0b4\xf5\xe0\xe0\xe0\xfe\xfe\xfe\xe1\xe1\xe1\xe9\xe9\xe9\
\xf8\xf8\xb8\xdbl\xea]\xab \x02\xe0\xa6,\x88h\x7f\x7f\x9f\x99G\xa3QQ\x14\xc3\
\xe1P\xa1q\x0c\x99\xad\x16\x08h\xcf(\xc4\xd2\xd2\xd2\xee\xeen]\xd7{{{EQ(\x8b\
?\r\xf2\xdd\xa9\xac\xf4\xe0\xa8\xd6\xc2\xccgggkkk\xc3\xe1\x10\xe6i\xa61\x86\
\xd9\xc5\xf8\xeb{F\xb4\xa9\xa7F`uu\xf5\xf4\xf4\x94\x88\x9a\xa6\xd1B\xbaz\xa1\
\x90\x16\x1eV!P\xd7u\x08\x01}%"!\x84\xa2(>??\x15\x1d&\x8aH\x8c\xb1\xd5\x02\
\xed\xacR\xcf\xcc\xcc\xcc\xcf\xcf\xa3s\xfa\xfd\xfe\xec\xec\xac1f4\x1a\x95e97\
7W\x96\xe5\xe1\xe1\xa1\xf6\xd17\x0b\xf8\x0cl\xd4\xd5%,"\xe3\xf1\xf8\xf5\xf55\
\x840\x18\x0c\xc6\xe31\xeek\x1dP!AAg,\xe7\x9cR\xca9;\xe7\xbc\xf7[[[\x17\x17\
\x17\xeb\xeb\xeb\xe7\xe7\xe7\x9b\x9b\x9b\x98\x06\xdc\xd4\x0e\x183c\xb7\xab\
\xfc\xd4\xda\xde\xde\xae\xaajggG\xdb\xf4\xaf1\xc3\xb5]\xc1\xa7\x0c\x02\xe8\
\xd1\xd1\x11TC(\xa5DD\x8c\xb7\xc9d\x12c\xecBP\xe7O\xf5\xcf\x15B\x80\xd9,"\
\xb7\xb7\xb7\xff\xcb\xfb\xb9\xa6z\x87\x88~\x03!\x94ZC\xeb\xb8\xaf\xa0\x00\
\x00\x00\x00IEND\xaeB`\x82'
def main():
files = sys.argv[1:]
app = dabo.dApp()
app.setAppInfo("appName", "Dabo Editor")
app.setAppInfo("appShortName", "DaboEditor")
app.MainFormClass = None
app.setup()
frm = EditorForm()
frm.onFileNew(None)
for file in files:
frm.openFile(file)
frm.show()
app.start()
if __name__ == "__main__":
main()
--
-Echo
_______________________________________________
Post Messages to: [email protected]
Subscription Maintenance: http://leafe.com/mailman/listinfo/dabo-users
