Changeset 297

Timestamp:

05/25/08 13:10:15 (8 months ago)

Author:

bob

Message:

 

Location:

trunk/artub

Files:

• artub.pyw (modified) (1 diff)
• debugger/glumoldebugger.py (modified) (1 diff)
• setup.py (modified) (1 diff)
• startuppage.py (modified) (7 diffs)
• tools/macosx/pythonw.c (added)
• tools/macosx/release_mac.sh (modified) (3 diffs)

trunk/artub/artub.pyw

@@ -1 @@
-execfile("artub.py")
+# Glumol - An adventure game creator
+# Copyright (C) 1998-2008  Sylvain Baubeau & Alexis Contour
+
+# This file is part of Glumol.
+
+# Glumol 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.
+
+# Glumol is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Glumol.  If not, see <http://www.gnu.org/licenses/>.
+
+#!/usr/bin/python
+# -*- coding: utf-8 -*-"
+
+__version__ = "1.0"
+
+from depplatform import get_image_path, set_sys_path
+set_sys_path()
+from configmanager import config
+
+print "Running Artub version", __version__
+import gettext
+gettext.install('artub', 'locale', unicode=1)
+import locale
+import wx
+print "Using wxPython", wx.VERSION_STRING
+
+def set_language(lang):
+    gettext.translation('artub', 'locale', languages=[lang]).install(unicode=1)
+    config["lang"] = lang
+    
+try:
+    langue = config["lang"]
+    set_language(langue)
+except:
+    try:
+        langue = wx.Locale.GetLanguageInfo(wx.Locale.GetSystemLanguage()).CanonicalName[:2]
+        set_language(langue)
+    except:
+        print "Cannot find a translation for your language. Defaulting to english"
+        config["lang"] = "en"
+
+import os
+import os.path
+import sys
+import time
+
+try: os.chdir(os.path.dirname(__file__))
+except: pass
+
+import wx.aui as PyAUI
+from artubnotebook import ArtubNotebook
+from resourceeditor import CEditorManager, AddResource
+import log
+from startuppage import StartupPage
+from toolbarmanager import ToolbarManager
+from propertiesbar import PropertiesBar
+from project import load_project, CProject
+from newproject import new_project
+from projectproperties import ProjectProperties
+from showoptions import OptionsWindow
+from debugger.glumoldebugger import ProjectDebugger
+from script import CScript, get_function_args, get_full_name, \
+                   get_class_code, make_variable_name, make_class_name 
+from glumolresource import VirtualGlumolResource
+from dialogue import CDialogue
+from glumolfont import CGlumolFont
+from glumolobject import CGlumolObject, VirtualGlumolObject
+from sound import CSound
+from animation import CAnimation, VirtualAnimation
+from inspect import getmembers, isclass
+from undoredo import undo_manager, Action
+import pypoujol
+from stackless import tasklet, run, schedule
+from redistributable import Redistributable 
+from choosename import choose_a_name
+from propertiesbar.companions import Companion
+import types
+game = None
+
+class ArtubTree(wx.TreeCtrl):
+    def __init__(self, parent, artub, style = wx.TR_HAS_BUTTONS | wx.TR_EDIT_LABELS | # Crash on Windows !!!
+                                              wx.TR_HAS_VARIABLE_ROW_HEIGHT |
+                                              wx.TR_LINES_AT_ROOT |
+                                              wx.TR_HAS_BUTTONS):
+        self.artub = artub
+        self.dying = False
+
+        tID = wx.NewId()
+        wx.TreeCtrl.__init__(self, parent, tID, style = style)
+        wx.EVT_TREE_SEL_CHANGED(self, tID, self.on_sel_changed)
+        wx.EVT_RIGHT_UP(self, self.on_default_right_up)
+        wx.EVT_KEY_DOWN(self, self.on_key_down)
+        wx.EVT_TREE_END_LABEL_EDIT(self, tID, self.on_tree_end_label_edit) # Crash on my Windows
+        
+    def add_tree_item(self, resource, parent = None):
+        if not parent:
+            data = wx.TreeItemData(resource)
+            item = self.AddRoot(resource.name, -1, -1, data)
+        else:
+            data = wx.TreeItemData(resource)
+            item = self.AppendItem(parent, resource.name, -1, -1, data)
+        resource.treeitem = item
+        return item
+        
+    def add_new_resource(self, res):
+        self.artub.project.childs.append(res)
+        data = wx.TreeItemData(res)
+        res.treeitem = self.AppendItem(self.GetRootItem(), res.name, -1, -1, data)
+        
+    def get_default_resource_menu(this):
+        class DefaultMenu(wx.Menu):
+            def __init__(self, tree):
+                wx.Menu.__init__(self)
+                this.artub.populate_resource_menu(self)
+      
+        return DefaultMenu(this)
+    
+    def on_key_down(self, evt):
+        self.artub.on_key_down(evt)
+        
+    def on_tree_end_label_edit(self, event):
+        self.artub.on_tree_end_label_edit(event)
+
+    def on_right_down(self, event):
+        return
+        
+    def on_default_right_up(self, event):
+        if not self.artub.project: return
+        self.on_right_up(event)
+        
+    def on_right_up(self, event):
+        item, flag = self.HitTest(event.GetPosition())
+        if item.IsOk() and self.GetSelection() != item:
+            self.SelectItem(item)
+        if not item.IsOk() and self.GetRootItem().IsOk():
+            item = self.GetRootItem()
+        if item.IsOk():
+            resource = self.GetItemData(item).GetData()
+            editor = self.artub.get_editor_from_resource(resource)
+            menu = None
+            if editor:
+                menu = editor.get_popup_menu(resource)
+            if not menu:
+                menu = self.get_default_resource_menu()
+            else:
+                self.artub.populate_resource_menu(menu)
+        else:
+            menu = self.get_default_resource_menu()
+        
+        self.PopupMenu(menu, event.GetPosition())
+        #event.Skip()
+        
+    def on_sel_changed(self, event):
+        if self.dying:
+            return
+        
+        item = event.GetItem()
+        if item:
+            data = self.GetItemData(item).GetData()
+            self.artub.edit_resource(data)
+            self.artub.project_frame.unselect_items()
+            #self.artub.todos.append((self.artub.nb.SetSelection, (self.artub.nb.GetPageCount() - 1,)))
+            
+class TemplatesTree(ArtubTree):
+    def __init__(self, parent, artub):
+        ArtubTree.__init__(self, parent, artub,
+                             style = wx.TR_HAS_BUTTONS |
+                             wx.TR_HAS_VARIABLE_ROW_HEIGHT |
+                             wx.TR_HIDE_ROOT |
+                             wx.TR_LINES_AT_ROOT |
+                             wx.TR_HAS_BUTTONS)
+
+    def get_default_resource_menu(this):
+        class DefaultMenu(wx.Menu):
+            def __init__(self, tree):
+                wx.Menu.__init__(self)
+                propID = wx.NewId()
+                self.Append(propID, _("Import"), _("Import"))
+                wx.EVT_MENU(self, propID, this.artub.on_import)
+
+        return DefaultMenu(this)
+
+    def find_item(self, parent, name):
+        if not parent.IsOk(): return None
+        item = self.GetFirstChild(parent)[0]
+        while item.IsOk():
+            if self.GetItemText(item) == name:
+                return item
+            item = self.GetNextSibling(item)
+        return None
+    
+    def add_template(self, resource, exec_script = True):
+        if exec_script: resource.exec_listing()
+        c = wx.GetApp().gns.getattr(resource.name)
+        item = self.GetRootItem()
+        def popo(c):
+            res = []
+            if len(c.__bases__):
+                for i in c.__bases__:
+                    if i.__name__ == "object":
+                        if not self.find_item(self.GetRootItem(), c.__name__):
+                            res.append(self.GetRootItem())
+                            return res
+                    item2 = popo(i)
+                    for j in item2:
+                        item3 = self.find_item(j, c.__name__)
+                        if item3:
+                            res.append(item3)
+                        else:
+                            res.append(self.AppendItem(j, c.__name__))
+            else:
+                res.append(self.GetRootItem())
+            return res
+        self.Refresh()
+                
+        def add_template_aux(item, bases):
+            for b in bases:
+                if type(b) == types.ListType:
+                    add_template_aux(b)
+                else:
+                    item2 = self.find_item(item, b[0].__name__)
+                    if item2:
+                        item = item2
+                    else:
+                        item = self.AppendItem(item, b[0].__name__)
+                    add_template_aux(item, b[1])
+        import inspect
+        bases = inspect.getclasstree([c])
+        l = popo(c)
+        for i in l:
+            self.SetPyData(i, resource)
+            
+    def on_new(self, event):
+        item = self.GetSelection()
+        resource = self.GetItemData(item).GetData()
+        if resource:
+            res = CGlumolObject(resource)
+            base_classes = [wx.GetApp().gns.getattr(resource.name)]
+        else:
+            res = CGlumolObject(wx.GetApp().frame.project)
+            base_classes = [wx.GetApp().gns.getattr(self.GetItemText(item))]
+        res.name = choose_a_name(_("New_") + self.GetItemText(item))
+        if not res.name: return
+        res.template = True
+        res.sync()
+        if base_classes:
+            args = get_function_args(base_classes[0].__init__)
+            args2 = get_function_args(base_classes[0].__init__, nodefaults=True)
+            if args.endswith(", extras"):
+                code = [ "def __init__(" + args[:-7] + "*extras):" ]
+                code += [ "    " + base_classes[0].__name__ + ".__init__(" + args2[:-7] + "*extras)" ]
+            else:
+                code = [ "def __init__(" + args + "):" ]
+                code += [ "    " + base_classes[0].__name__ + ".__init__(" + args2 + ")" ]
+            code += ["    self.__glumolinit__()",
+                 "def __glumolinit__(self):",
+                 "    super(" + res.name + ", self).__glumolinit__()" ]
+        else:
+            code = ["pass"]
+        self.Refresh()
+        c = res.add_class(res.name, base_classes = map(lambda x: x.__name__, base_classes), body = code)
+        res.topy()
+        res.exec_listing()
+        self.add_tree_item(res, item)
+            
+    def on_delete(self, event):
+        pass
+        
+    def on_right_up(self, event):
+        if not self.artub.project: return
+        item, flag = self.HitTest(event.GetPosition())
+        if item.IsOk():
+            resource = self.GetItemData(item).GetData()
+            class AMenu(wx.Menu):
+                def __init__(this):
+                    wx.Menu.__init__(this)
+                    propID = wx.NewId()
+                    this.Append(propID, _("New"), _("New"))
+                    wx.EVT_MENU(this, propID, self.on_new)
+                    if resource:
+                        propID = wx.NewId()
+                        this.Append(propID, _("Delete"), _("Delete"))
+                        wx.EVT_MENU(this, propID, self.on_delete)
+                            
+            menu = AMenu()
+            self.PopupMenu(menu, event.GetPosition())
+            event.Skip()
+            return
+                
+        menu = self.get_default_resource_menu()
+        self.PopupMenu(menu, event.GetPosition())
+        event.Skip()
+        
+    def populate(self, project):
+        self.DeleteAllItems()
+        root = self.AddRoot(" ")
+        item = self.AppendItem(self.GetRootItem(), "Sprite")
+        item = self.AppendItem(self.GetRootItem(), "Game")
+        item = self.AppendItem(self.GetRootItem(), "Region")
+        item = self.AppendItem(self.GetRootItem(), "Behaviour")
+        
+    def on_sel_changed(self, event):
+        if self.dying: return
+        item = event.GetItem()
+        if item:
+            resource = self.GetItemData(item).GetData()
+            if resource:
+                self.artub.edit_resource(resource, self.artub.get_editor('akiki'))
+                self.artub.project_frame.unselect_items()
+    
+class RoomTree(ArtubTree):
+    def __init__(self, parent, artub):
+        ArtubTree.__init__(self, parent, artub,
+                             style = wx.TR_HAS_BUTTONS |
+                             wx.TR_HAS_VARIABLE_ROW_HEIGHT |
+                             wx.TR_HIDE_ROOT |
+                             wx.TR_LINES_AT_ROOT |
+                             wx.TR_HAS_BUTTONS)
+        self.root = self.AddRoot(" ")
+
+    def get_default_resource_menu(self):
+        return self.artub.get_templates_menu(
+                callback = self.artub.on_new_class,
+                section = "Scene", prefix = "New ")
+        
+class SoundsTree(ArtubTree):
+    def get_default_resource_menu(this):
+        class DefaultMenu(wx.Menu):
+            def __init__(self, tree):
+                wx.Menu.__init__(self)
+                propID = wx.NewId()
+                self.Append(propID, _("New sound"), _("New sound"))
+                wx.EVT_MENU(self, propID, this.on_new_sound)
+                
+        return DefaultMenu(this)
+            
+    def on_new_sound(self, evt):
+        name = choose_a_name(_("New_sound"))
+        if not name: return
+        sound = CSound()
+        base_class = "Sound"
+        sound.name = self.artub.project.get_resource_name(name)
+        sound.listing = "class %s(%s):\n" % (sound.name, base_class)
+        sound.listing = sound.listing + "    filename = ''\n"
+        sound.listing = sound.listing + "    def __init__(self):\n"
+        sound.listing = sound.listing + "        %s.__init__(self)\n" % base_class
+        sound.listing = sound.listing + "        self.__glumolinit__()\n"
+        sound.listing = sound.listing + "    def __glumolinit__(self):\n"
+        sound.listing = sound.listing + "        super(" + sound.name + ", self).__glumolinit__()\n\n"
+        self.add_new_resource(sound)
+        self.add_new_resource(sound)
+        
+class ProjectFrame(wx.Panel):
+    name = _("Project bar")
+    def __init__(
+        self, parent, id=-1, title="", pos=wx.DefaultPosition, size=wx.DefaultSize,
+        style=wx.DEFAULT_FRAME_STYLE
+        ):
+        self.artub = artub = parent
+        wx.Panel.__init__(self, artub, -1)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        project_nb = artub.project_nb = PyAUI.AuiNotebook(self, -1, wx.DefaultPosition,
+                                              wx.DefaultSize, style = PyAUI.AUI_NB_SCROLL_BUTTONS)
+        sizer.Add(parent.project_nb, 1, wx.EXPAND)
+
+        tree = artub.tree = ArtubTree(project_nb, artub)
+        project_nb.AddPage(tree, _("Project"))
+        
+        imagelist = wx.ImageList(16, 16, True)
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("cost.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("talk.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("object.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("script.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("project.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("font.xpm"), wx.BITMAP_TYPE_XPM))
+        imagelist.Add(
+                    wx.Bitmap(get_image_path("scene.xpm"), wx.BITMAP_TYPE_XPM))
+        
+        tree.AssignImageList(imagelist)
+
+        #self.rooms = RoomTree(self.project_nb, self)
+        #self.project_nb.AddPage(self.rooms, _("Scenes"))
+
+        artub.templ_tree = TemplatesTree(project_nb, artub)
+        project_nb.AddPage(artub.templ_tree, _("Templates"))
+        
+        # self.costs = ArtubTree(self.project_nb, self)
+        # self.project_nb.AddPage(self.costs, _("Sprites"))
+
+        artub.sounds = SoundsTree(project_nb, artub)
+        project_nb.AddPage(artub.sounds, _("Sounds"))
+
+        self.SetSizer(sizer)
+
+    def get_active_tree(self):
+        return self.get_tree_list()[self.artub.project_nb.GetSelection()]
+    
+    def get_tree_list(self):
+        return [ self.artub.tree, self.artub.templ_tree, self.artub.sounds ]
+
+    def unselect_items(self, all=False):
+        if sys.platform != "win32":
+            n = 0
+            for i in [self.artub.tree, self.artub.templ_tree, self.artub.sounds]:
+                if all or (n != self.artub.project_nb.GetSelection()):
+                    i.dying = True
+                    i.UnselectAll()
+                    i.dying = False
+                n = n + 1
+
+    def on_close_window(self, evt):
+        self.manager.toggle_bar(self.menu_id)
+
+class ArtubFrame(wx.Frame, CEditorManager):
+    resource_icons = { CDialogue : 1, CAnimation : 0, CGlumolObject : 2,
+                       CProject : 4, CScript : 3, VirtualGlumolObject : 2,
+                       CGlumolFont : 5, VirtualAnimation : 0 }
+
+    def __init__(self, parent, id, title, config):
+        CEditorManager.__init__(self)
+
+        wx.Frame.__init__(self, parent, -1, title, size = (800, 600),
+                                style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
+
+        self.cwd = os.getcwd()
+        sys.path.append(self.cwd)
+        self.window = None
+        self.config = config
+        self.context = None
+        self.todos = []
+        
+        self.new_anim_id = wx.NewId()
+        self.new_scene_id = wx.NewId()
+        self.new_sprite_id = wx.NewId()
+        self.new_script_id = wx.NewId()
+        self.new_dialog_id = wx.NewId()
+        self.new_font_id = wx.NewId()
+
+        self.quitte = False
+
+        self.app = wx.GetApp()
+        self.app.artub_frame = self
+        self.app.frame = self
+
+        self.path = os.getcwd()
+        self.debugging = False
+        
+        self.metaclasses = ["BehaviourMetaClass", "SpriteMetaClass", "AnimationMetaClass", "GameMetaClass", "SceneMetaClass"]
+        
+        if __name__ != "__main__":
+            frame = wx.Frame(self, -1)
+            self.log = wx.TextCtrl(frame, -1,
+                                   style = wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
+            log.set_text_ctrl(self.log)
+            frame.Show(True)
+            
+        self._mgr = PyAUI.AuiManager()
+
+        def OnFloatingPaneClosed(window):
+            self.toolbar_manager.on_close_toolbar(window)
+            return True
+        
+        def OnPaneClosed(window):
+            self.toolbar_manager.on_close_toolbar(window)
+            return True
+        
+        self._mgr.OnFloatingPaneClosed = OnFloatingPaneClosed
+        self._mgr.OnPaneClosed = OnPaneClosed
+        
+        self._mgr.SetManagedWindow(self)
+        self._mgr.SetFlags(self._mgr.GetFlags() ^ PyAUI.AUI_MGR_ALLOW_ACTIVE_PANE)
+        self._mgr.GetArtProvider()._gradient_type = PyAUI.AUI_GRADIENT_NONE
+        
+        self.toolbar_manager = ToolbarManager(self)
+
+        greta = wx.Icon(get_image_path("greta.ico"), wx.BITMAP_TYPE_ICO)
+        self.SetIcon(greta)
+        
+        self.create_menus()
+        self.create_standard_toolbar()
+
+        self.load_plugins()
+        self.dist = Redistributable()
+
+        self.otherWin = None
+        wx.EVT_IDLE(self, self.on_idle)
+        wx.EVT_CLOSE(self, self.on_close_window)
+        wx.EVT_ICONIZE(self, self.on_iconify)
+        wx.EVT_MAXIMIZE(self, self.on_maximize)
+
+        self.Centre(wx.BOTH)
+        self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
+
+        # Shell
+        import __builtin__
+        globals()["artub"] = self
+        class MyShell(wx.py.shell.Shell):
+            def push(command, silent = False):
+                __ = __builtin__.__dict__["_"]
+                wx.py.shell.Shell.push(command, silent)
+                __builtin__.__dict__["_"] = __ 
+
+        self.shell = self.toolbar_manager.create_toolbar(MyShell,
+                            keywords = { "locals" : globals(), "introText" : "Welcome to the Glumol debugger" },
+                            infos = PyAUI.AuiPaneInfo().Name(_("Shell")).
+                            Caption(_("Shell")).Left().Float().MinSize(wx.Size(200, 100)))
+        
+        # Project frame
+        self.project_frame = self.toolbar_manager.create_toolbar(
+                                ProjectFrame,
+                                infos = PyAUI.AuiPaneInfo().Name(_("Project bar")).
+                                Caption(_("Project")).Left().
+                                MinSize(wx.Size(200,100)))
+        
+        # Notebook
+        self.nb = ArtubNotebook(self, -1, wx.CLIP_CHILDREN)
+        self._mgr.AddPane(self.nb, PyAUI.AuiPaneInfo().Name(_("Notebook")).
+                                   Caption(_("Notebook")).CenterPane())
+
+        wx.EVT_MENU_RANGE(self, wx.ID_FILE1, wx.ID_FILE9, self.on_file_history)
+
+        # Startup page
+        self.ovr = StartupPage(self.nb, -1, self)
+        self.ovr.update_recent_files()
+        self.nb.AddPage(self.ovr, _("Startup"))
+        self.ovr.Refresh()
+        
+        self.Show(True)
+
+        self.project = None
+        
+        self.debugger = ProjectDebugger(self, self)
+        
+        self.pb = self.toolbar_manager.create_toolbar(PropertiesBar,
+                      infos = PyAUI.AuiPaneInfo().Name(PropertiesBar.name).
+                      Caption(PropertiesBar.name).MinSize(wx.Size(200, 100)).Left())
+        
+        self.toolbar_manager.care_of_menu(self.windows)
+        self.SetMenuBar(self.mainmenu)
+        self.care_of_auto_load()
+        self._mgr.Update()
+        self._mgr.HideHint()
+
+    def CloseWindow(self, event):
+        self.Close()
+    
+    def on_toggle_breakpoint(self, evt):
+        self.active_editor.on_toggle_breakpoint(evt)
+    
+    def on_toggle_breakpoint_update_ui(self, evt):
+        if self.project and self.active_editor and self.active_editor.name == "akiki": evt.Enable(True) # Smart way didn't work
+        else: evt.Enable(False)
+
+    def create_standard_toolbar(self):
+        class MainToolBar(wx.ToolBar):
+            name = _("Main toolbar")
+            def __init__(
+                this, parent=None, id=-1, title = "",
+                pos = wx.DefaultPosition, size = wx.DefaultSize,
+                style = wx.TB_FLAT | wx.TB_NODIVIDER | wx.TB_DOCKABLE | wx.TB_FLAT | wx.TB_NODIVIDER | wx.TB_HORIZONTAL,
+                name = _(""),
+                value = None):
+                
+                wx.ToolBar.__init__(this, parent, id, pos, size, style | wx.TB_HORIZONTAL)
+                this.SetToolBitmapSize(wx.Size(16, 16))
+                this.AddSimpleTool(10, self.bitmaps['new2.xpm'], _("New project"), _("Create a new project"))
+                this.Bind(wx.EVT_TOOL, self.on_new, id=10)
+                this.AddSimpleTool(11, self.bitmaps['open.xpm'], _("Open a project"), _("Open a project"))
+                this.Bind(wx.EVT_TOOL, self.on_open, id=11)
+                this.AddSimpleTool(12, self.bitmaps['save.xpm'], _("Save your project"), _("Save your project"))
+                this.Bind(wx.EVT_TOOL, self.on_save, id=12)
+                this.AddSimpleTool(13, self.bitmaps['cut.xpm'], _("Cut to the clipboard"), _("Cut to the clipboard"))
+                this.AddSimpleTool(14, self.bitmaps['copy.xpm'], _("Copy to the clipboard"), _("Copy to the clipboard"))
+                this.AddSimpleTool(15, self.bitmaps['paste.xpm'], _("Paste from the clipboard"), _("Paste from the clipboard"))
+                this.AddSimpleTool(self.undoID, self.bitmaps['undo.xpm'], _("Undo last change"), _("Undo last change"))
+                this.Bind(wx.EVT_TOOL, self.undo, id=self.undoID)
+                this.AddSimpleTool(self.redoID, self.bitmaps['redo.xpm'], _("Redo last change"), _("Redo last change"))
+                this.Bind(wx.EVT_TOOL, self.undo, id=self.redoID)
+                
+                this.Realize()
+
+        self.maintoolbar = self.toolbar_manager.create_toolbar(MainToolBar,
+                           infos = PyAUI.AuiPaneInfo().Name(_("Main toolbar")).
+                           Caption(_("Main toolbar")).
+                           ToolbarPane().Top())
+                           
+    def get_bitmap(self, filename):
+        item = self.bitmaps.get(filename, None)
+        if not item:
+            return self.load_and_store_bitmap(filename)
+        else:
+            return item
+
+    def load_and_store_bitmap(self, filename):
+        bmp = wx.Bitmap(get_image_path(filename), wx.BITMAP_TYPE_XPM)
+        self.bitmaps[filename] = bmp
+        return bmp
+        
+    def create_menus(self):
+        self.mainmenu = wx.MenuBar()
+        menu = wx.Menu()
+        newID = wx.NewId()
+        self.bitmaps = {}
+        menuitem = wx.MenuItem(menu, newID, _("New project") + '\tCtrl-N', _("Create a new project"))
+        menuitem.SetBitmap(self.load_and_store_bitmap("new2.xpm"))
+        menu.AppendItem(menuitem)
+        openID = wx.NewId()
+        menuitem = wx.MenuItem(menu, openID, _("Open") + '\tCtrl-O', _("Open a project"))
+        menuitem.SetBitmap(self.load_and_store_bitmap("open.xpm"))
+        menu.AppendItem(menuitem)
+        saveID = wx.NewId()
+        menuitem = wx.MenuItem(menu, saveID, _("Save") + '\tCtrl-S', _("Save your project"))
+        menuitem.SetBitmap(self.load_and_store_bitmap("save.xpm"))
+        menu.AppendItem(menuitem)
+        saveasID = wx.NewId()
+        menuitem = wx.MenuItem(menu, saveasID, _("Save as") + '\tCtrl-Shift-S', _("Save as..."))
+        menuitem.SetBitmap(self.load_and_store_bitmap("saveas.xpm"))
+        menu.AppendItem(menuitem)
+        exitID = wx.NewId()
+        wx.App_SetMacExitMenuItemId(exitID)
+        menu.Append(exitID, _("Exit"), _("Exit Artub"))
+        self.mainmenu.Append(menu, _("File"))
+        
+        self.filehistory = wx.FileHistory()
+        self.filehistory.UseMenu(menu)
+        self.filehistory.Load(self.config)        
+        
+        wx.EVT_MENU(self, newID, self.on_new)
+        wx.EVT_MENU(self, openID, self.on_open)
+        wx.EVT_MENU(self, saveID, self.on_save)
+        wx.EVT_MENU(self, saveasID, self.on_saveas)
+        wx.EVT_MENU(self, exitID, self.on_exit)
+        
+        edit = wx.Menu()
+        undoID = wx.NewId()
+        self.undoID = undoID
+        menuitem = wx.MenuItem(menu, undoID, _("Undo") + '\tCtrl-Z', _("Undo last change"))
+        menuitem.SetBitmap(self.get_bitmap("undo.xpm"))
+        edit.AppendItem(menuitem)
+        redoID = wx.NewId()
+        self.redoID = redoID
+        menuitem = wx.MenuItem(menu, redoID, _("Redo") + '\tCtrl-Y', _("Redo last change"))
+        menuitem.SetBitmap(self.get_bitmap("redo.xpm"))
+        edit.AppendItem(menuitem)
+        cutID = wx.NewId()
+        menuitem = wx.MenuItem(menu, cutID, _("Cut") + '\tCtrl-X', _("Cut selection and put it into the clipboard"))
+        menuitem.SetBitmap(self.get_bitmap("cut.xpm"))
+        edit.AppendItem(menuitem)
+        copyID = wx.NewId()
+        menuitem = wx.MenuItem(menu, copyID, _("Copy") + '\tCtrl-C', _("Copy selection into the clipboard"))
+        menuitem.SetBitmap(self.get_bitmap("copy.xpm"))
+        edit.AppendItem(menuitem)
+        pasteID = wx.NewId()
+        self.pasteID = pasteID
+        menuitem = wx.MenuItem(menu, pasteID, _("Paste") + '\tCtrl-V', _("Paste from clipboard"))
+        menuitem.SetBitmap(self.get_bitmap("paste.xpm"))