Ejemplo n.º 1
0
    def __init__(self):
        """
        Initialise utility, status/menu/tool bar, tabs, ctrl panel + bindings.
        """
        wx.Frame.__init__(self, None, title=_("Untitled") + u" - %s" % self.title)
        self.util = Utility(self)

        meta.find_transparent()  # important
        logger.info("Transparency supported: %s", meta.transparent)
        
        if meta.transparent:
            try:
                x = self.util.items.index(Highlighter)
            except ValueError:
                self.util.items.insert(1, Highlighter)

        self.can_paste = check_clipboard()
        self.process = None
        self.pid = None
        self.dialog = None
        self.convert_cancelled = False
        self.shape_viewer_open = False
        self.help = None
        self.hotkey_pressed = False  # for hotkey timer
        self.hotkey_timer = None
        self.tab_count = 1
        self.tab_total = 1
        self.current_tab = 0
        self.closed_tabs = []
        self.hotkeys = []

        style = (fnb.FNB_X_ON_TAB | fnb.FNB_NO_X_BUTTON | fnb.FNB_VC8 |
                 fnb.FNB_DROPDOWN_TABS_LIST | fnb.FNB_MOUSE_MIDDLE_CLOSES_TABS |
                 fnb.FNB_NO_NAV_BUTTONS)

        self.control = ControlPanel(self)
        self.tabs = fnb.FlatNotebook(self, agwStyle=style)
        self.canvas = Canvas(self.tabs, self, (Config().default_width(), Config().default_height()))
        self.panel = SidePanel(self)

        self.thumbs = self.panel.thumbs
        self.notes = self.panel.notes
        self.tabs.AddPage(self.canvas, _("Sheet") + u" 1")

        box = wx.BoxSizer(wx.HORIZONTAL)  # position windows side-by-side
        box.Add(self.control, 0, wx.EXPAND)
        box.Add(self.tabs, 1, wx.EXPAND)
        box.Add(self.panel, 0, wx.EXPAND)
        self.SetSizer(box)
        self.SetSizeWH(800, 600)

        if os.name == "posix":
            self.canvas.SetFocus()  # makes EVT_CHAR_HOOK trigger
        if 'mac' != os.name:
            self.Maximize(True)

        self.paste_check_count = PASTE_CHECK_COUNT - 1
        wx.UpdateUIEvent.SetUpdateInterval(75)
        #wx.UpdateUIEvent.SetMode(wx.UPDATE_UI_PROCESS_SPECIFIED)

        self.SetIcon(icon.getIcon())
        self.SetExtraStyle(wx.WS_EX_PROCESS_UI_UPDATES)
        self.SetDropTarget(CanvasDropTarget())
        self.statusbar = self.CreateStatusBar()
        self._print = Print(self)

        self.filehistory = wx.FileHistory(8)
        self.config = wx.Config()
        self.load_history_file()
        self.filehistory.Load(self.config)

        self.menu = Menu(self)
        self.toolbar = self.CreateToolBar() 
        Toolbar.configure(self.toolbar, self.can_paste)
        self.SetMenuBar(self.menu.menu)
        self.set_menu_from_config()
        self.do_bindings()
        self.find_help()
        
        pub.sendMessage('thumbs.update_current')
        self.update_panels(True)
        wx.CallAfter(self.UpdateWindowUI)
Ejemplo n.º 2
0
class GUI(wx.Frame):
    """
    This class contains a ControlPanel, a Canvas frame and a SidePanel
    and manages their layout with a wx.BoxSizer.  A menu, toolbar and associated
    event handlers call the appropriate functions of other classes.
    """
    title = u"Whyteboard"
    LoadEvent, LOAD_DONE_EVENT = wx.lib.newevent.NewEvent()

    def __init__(self):
        """
        Initialise utility, status/menu/tool bar, tabs, ctrl panel + bindings.
        """
        wx.Frame.__init__(self, None, title=_("Untitled") + u" - %s" % self.title)
        self.util = Utility(self)

        meta.find_transparent()  # important
        logger.info("Transparency supported: %s", meta.transparent)
        
        if meta.transparent:
            try:
                x = self.util.items.index(Highlighter)
            except ValueError:
                self.util.items.insert(1, Highlighter)

        self.can_paste = check_clipboard()
        self.process = None
        self.pid = None
        self.dialog = None
        self.convert_cancelled = False
        self.shape_viewer_open = False
        self.help = None
        self.hotkey_pressed = False  # for hotkey timer
        self.hotkey_timer = None
        self.tab_count = 1
        self.tab_total = 1
        self.current_tab = 0
        self.closed_tabs = []
        self.hotkeys = []

        style = (fnb.FNB_X_ON_TAB | fnb.FNB_NO_X_BUTTON | fnb.FNB_VC8 |
                 fnb.FNB_DROPDOWN_TABS_LIST | fnb.FNB_MOUSE_MIDDLE_CLOSES_TABS |
                 fnb.FNB_NO_NAV_BUTTONS)

        self.control = ControlPanel(self)
        self.tabs = fnb.FlatNotebook(self, agwStyle=style)
        self.canvas = Canvas(self.tabs, self, (Config().default_width(), Config().default_height()))
        self.panel = SidePanel(self)

        self.thumbs = self.panel.thumbs
        self.notes = self.panel.notes
        self.tabs.AddPage(self.canvas, _("Sheet") + u" 1")

        box = wx.BoxSizer(wx.HORIZONTAL)  # position windows side-by-side
        box.Add(self.control, 0, wx.EXPAND)
        box.Add(self.tabs, 1, wx.EXPAND)
        box.Add(self.panel, 0, wx.EXPAND)
        self.SetSizer(box)
        self.SetSizeWH(800, 600)

        if os.name == "posix":
            self.canvas.SetFocus()  # makes EVT_CHAR_HOOK trigger
        if 'mac' != os.name:
            self.Maximize(True)

        self.paste_check_count = PASTE_CHECK_COUNT - 1
        wx.UpdateUIEvent.SetUpdateInterval(75)
        #wx.UpdateUIEvent.SetMode(wx.UPDATE_UI_PROCESS_SPECIFIED)

        self.SetIcon(icon.getIcon())
        self.SetExtraStyle(wx.WS_EX_PROCESS_UI_UPDATES)
        self.SetDropTarget(CanvasDropTarget())
        self.statusbar = self.CreateStatusBar()
        self._print = Print(self)

        self.filehistory = wx.FileHistory(8)
        self.config = wx.Config()
        self.load_history_file()
        self.filehistory.Load(self.config)

        self.menu = Menu(self)
        self.toolbar = self.CreateToolBar() 
        Toolbar.configure(self.toolbar, self.can_paste)
        self.SetMenuBar(self.menu.menu)
        self.set_menu_from_config()
        self.do_bindings()
        self.find_help()
        
        pub.sendMessage('thumbs.update_current')
        self.update_panels(True)
        wx.CallAfter(self.UpdateWindowUI)

    def do_bindings(self):
        """
        Performs event binding.
        """
        logger.debug("Beginning frame event bindings")
        self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_CHANGED, self.on_change_tab)
        self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU, self.tab_popup)
        self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_DROPPED, self.on_drop_tab)
        self.Bind(self.LOAD_DONE_EVENT, self.on_done_load)
        self.Bind(wx.EVT_CHAR_HOOK, self.hotkey)
        self.Bind(wx.EVT_CLOSE, self.on_exit)
        self.Bind(wx.EVT_END_PROCESS, self.on_end_process)  # end pdf conversion
        self.menu.bindings()

        topics = {'shape.add': self.shape_add,
                  'shape.popup': self.shape_popup,
                  'shape.selected': self.shape_selected,
                  'canvas.capture_mouse': self.capture_mouse,
                  'canvas.change_tool': self.pubsub_change_tool,
                  'canvas.paste_image': self.paste_image,
                  'canvas.paste_text': self.paste_text,
                  'canvas.release_mouse': self.release_mouse,
                  'gui.mark_unsaved': self.mark_unsaved,
                  'gui.open_file': self.open_file,
                  'media.create_panel': self.make_media_panel,
                  'text.show_dialog': self.show_text_dialog}
        [pub.subscribe(value, key) for key, value in topics.items()]

        logger.debug("Setting up tool hotkeys")
        self.hotkeys = [x.hotkey for x in self.util.items]
        ac = []
        if os.name == "nt":
            for x, item in enumerate(self.util.items):
                hotkey_event = lambda evt, y = x + 1, k = item.hotkey: self.on_change_tool(evt, y, key=k)
                _id = wx.NewId()
                ac.append((wx.ACCEL_NORMAL, ord(item.hotkey.upper()), _id))
                self.Bind(wx.EVT_MENU, hotkey_event, id=_id)
        else:
            ac = [(wx.ACCEL_CTRL, ord(u'\t'), ID_NEXT),
                  (wx.ACCEL_CTRL | wx.ACCEL_SHIFT, ord(u'\t'), ID_PREV) ]

        tbl = wx.AcceleratorTable(ac)
        self.SetAcceleratorTable(tbl)


    def set_menu_from_config(self):
        """
        Sets up the program's initial menu state from the config parameters
        """
        values = {ID_TOOLBAR: u'toolbar', ID_STATUSBAR: u'statusbar',
                ID_TOOL_PREVIEW: u'tool_preview', ID_COLOUR_GRID: u'colour_grid'}
        for _id, config_key in values.items():
            if getattr(Config(), config_key)():
                self.menu.check(_id, True)
            else:
                getattr(self, u"on_" + config_key)(None, False)


    def shape_selected(self, shape):
        """
        Shape getting selected (by Select tool)
        """
        self.canvas.select_shape(shape)
        change = (shape.background == wx.TRANSPARENT)
        self.util.transparent = change
        self.control.transparent.SetValue(change)

    def make_media_panel(self, size, media):
        media.mc = MediaPanel(self.canvas, size, media)

    def release_mouse(self):
        self.canvas.release_mouse()

    def shape_popup(self, shape):
        logger.debug("Showing pop up for %s", shape)
        self.PopupMenu(ShapePopup(self.canvas, self, shape))

    def capture_mouse(self):
        self.canvas.capture_mouse()

    def shape_add(self, shape):
        self.canvas.add_shape(shape)

    def on_save(self, event=None):
        """
        Saves file if filename is set, otherwise calls 'save as'.
        """
        logger.debug("Saving file.")
        if not self.util.filename:  # no wtbd file active, prompt for location
            logger.info("Prompting for filename")
            self.on_save_as()
        else:
            self.util.save_file()


    def on_save_as(self, event=None):
        """
        Prompts for the filename and location to save to.
        """
        wildcard = _("Whyteboard file ") + u"(*.wtbd)|*.wtbd"
        _dir = Config().get('last_opened_dir') or u""
        _file = self.util.filename
        if not _file:
            _file = u""
            
        name = file_dialog(self, _("Save Whyteboard As..."),
                           wx.SAVE | wx.OVERWRITE_PROMPT, wildcard, _dir, _file)
        if name:
            if not os.path.splitext(name)[1]:  # no file extension
                name += u'.wtbd'

            if is_save_file(name):
                self.util.filename = name
                self.on_save()


    def on_open(self, event=None, text=None):
        """
        Opens a file, sets Utility's temp. file to the chosen file, prompts for
        an unsaved file and calls do_open().
        text is img/pdf/ps for the "import file" menu item
        """
        wildcard = meta.dialog_wildcard
        if text == u"img":
            wildcard = wildcard[wildcard.find(_(u"Image Files")) :
                                wildcard.find(u"|" + _(u'Whyteboard files')) ]  # image to page
        elif text:
            wildcard = wildcard[wildcard.find(u"PDF/PS/SVG") :
                                wildcard.find(u"*.SVG|")]  # page descriptions

        _dir = Config().get('last_opened_dir') or u""

        filename = file_dialog(self, _("Open file..."), wx.OPEN, wildcard, _dir)
        if filename:
            self.open_file(filename)


    def open_file(self, filename):
        if filename:
            if is_save_file(filename):
                logger.debug("File open with unsaved changes, prompting for save")
                self.prompt_for_save(self.do_open, args=[filename])
            else:
                self.do_open(filename)


    def do_open(self, filename):
        """
        Updates the appropriate variables in the utility class and loads
        the selected file.
        """
        logger.info("Opening file [%s]", filename)
        self.filehistory.AddFileToHistory(filename)
        self.filehistory.Save(self.config)
        self.config.Flush()
        self.util.save_last_path(filename)

        if is_save_file(filename):
            self.util.load_wtbd(filename)
        else:
            self.util.temp_file = filename
            self.util.load_file()


    def on_export_pdf(self, event=None):
        """
        Exports the all the sheets as a PDF. Must first export all sheets as
        imgages, convert to PDF (displaying a progress bar) and then remove
        all the temporary files
        """
        if not self.util.im_location:
            self.util.prompt_for_im()
        if not self.util.im_location:
            return
        filename = file_dialog(self, _("Export data to..."),
                               wx.SAVE | wx.OVERWRITE_PROMPT, u"PDF (*.pdf)|*.pdf")

        if filename:
            ext = os.path.splitext(filename)[1]
            if not ext:  # no file extension
                filename += u'.pdf'
            elif ext.lower() != u".pdf":
                wx.MessageBox(_("Invalid filetype to export as:") + u" .%s" % ext,
                              u"Whyteboard")
                return

            names = []
            canvas = self.canvas
            for x in range(self.tab_count):
                self.canvas = self.tabs.GetPage(x)
                name = u"%s-tempblahhahh-%s-.jpg" % (filename, x)
                names.append(name)
                self.util.export(name)
            self.canvas = canvas

            self.process = wx.Process(self)
            files = ""
            for x in names:
                files += u'"%s" ' % x  # quote filenames for windows

            cmd = u'%s -define pdf:use-trimbox=true %s"%s"' % (self.util.im_location, files, filename)
            self.pid = wx.Execute(cmd, wx.EXEC_ASYNC, self.process)
            self.show_progress_dialog(_("Converting..."), True, True)

            [os.remove(x) for x in names]



    def on_export(self, event=None):
        """Exports the current sheet as an image, or all as a PDF."""
        filename = self.export_prompt()
        if filename:
            self.util.export(filename)


    def on_export_all(self, event=None):
        """
        Iterate over the chosen filename, add a numeric value to each path to
        separate each sheet's image.
        """
        filename = self.export_prompt()
        if filename:
            name = os.path.splitext(filename)
            canvas = self.canvas
            for x in range(self.tab_count):
                self.canvas = self.tabs.GetPage(x)
                self.util.export(u"%s-%s%s" % (name[0], x + 1, name[1]))
            self.canvas = canvas


    def on_export_preferences(self, event=None):
        """
        Copies the user's preferences file to another file.
        """
        if not os.path.exists(Config().filename()):
            wx.MessageBox(_("You have not set any preferences"), _("Export Error"))
            return
        wildcard = _("Whyteboard Preference Files") + u" (*.pref)|*.pref"

        filename = file_dialog(self, _("Export preferences to..."),
                               wx.SAVE | wx.OVERWRITE_PROMPT, wildcard)
        if filename:
            if not os.path.splitext(filename)[1]:
                filename += u".pref"
            shutil.copy(os.path.join(get_home_dir(), u"user.pref"), filename)



    def update_config(self, new_config):
        old_config = Config().config
        if new_config['language'] != old_config['language']:
            wx.MessageBox(_("Whyteboard will be translated into %s when restarted")
                          % _(new_config['language']), u"Whyteboard")
            
        if 'default_font' in new_config:
            if new_config['default_font'] and not self.util.font:
                self.util.font = wx.FFont(1, wx.FONTFAMILY_DEFAULT)
                self.util.font.SetNativeFontInfoFromString(new_config['default_font'])

        # Toggles the items under "View" menu. Ignore the colour grid for now
        for menu_item in ['statusbar', 'toolbar', 'tool_preview']:
            method = getattr(self, "on_" + menu_item)
            if new_config[menu_item]:
                method(None, True)
            else:
                method(None, False)

        new_config.write()
        Config().config = new_config

        if new_config['bmp_select_transparent'] != old_config['bmp_select_transparent']:
            self.canvas.copy = None

        if not new_config['tool_preview']:
            self.control.preview.Hide()
        else:
            self.control.preview.Show()
            pub.sendMessage('gui.preview.refresh')

        wx.CallAfter(self.on_colour_grid, None, new_config['colour_grid'])

        #  too lazy to check if each colour has changed - just remake it
        self.canvas.redraw_all()
        self.control.grid.Clear(True)
        self.control.make_colour_grid()
        self.control.grid.Layout()



    def on_import_preferences(self, event=None):
        """
        Imports a preference file. Backs up the user's current preference file
        into a directory, with a timestamp on the filename
        """
        logger.debug("Prompting to import preferences")
        wildcard = _("Whyteboard Preference Files") + u" (*.pref)|*.pref"

        filename = file_dialog(self, _("Import Preferences From..."), wx.OPEN,
                               wildcard, get_home_dir())

        if filename:
            Config().init(filename)
            _dir = os.path.join(get_home_dir(), u"pref-bkup")

            if not os.path.isdir(_dir):
                os.makedirs(_dir)

            home = os.path.join(get_home_dir(), u"user.pref")
            if os.path.exists(home):
                stamp = time.strftime(u"%d-%m-%Y_%H-%M_%S")
                logger.debug("Renaming old preferences file to [%s]", stamp)
                os.rename(home, os.path.join(_dir, stamp + u".user.pref"))
                
            config = Config().clone()
            config.init(filename)
            self.update_config(config.config)
        
        
    def on_reload_preferences(self, event):
        logger.debug("Reloading preference file")
        Config().init()


    def export_prompt(self):
        """
        Find out the filename to save to
        """
        val = None  # return value
        wildcard = (u"PNG (*.png)|*.png|JPEG (*.jpg, *.jpeg)|*.jpeg;*.jpg|" +
                    u"BMP (*.bmp)|*.bmp|TIFF (*.tiff)|*.tiff")

        filename = file_dialog(self, _("Export data to..."),
                           wx.SAVE | wx.OVERWRITE_PROMPT, wildcard)
        if filename:
            _name = os.path.splitext(filename)[1].replace(u".", u"")
            types = {0: u"png", 1: u"jpg", 2: u"bmp", 3: u"tiff"}

            if not os.path.splitext(filename)[1]:
                _name = types[dlg.GetFilterIndex()]
                filename += u"." + _name
                val = filename
            if not _name in meta.types[2:]:
                wx.MessageBox(u"%s .%s" % (_("Invalid filetype to export as:"), _name),
                              u"Whyteboard")
            else:
                val = filename
        return val


    def on_new_tab(self, event=None, name=None, wb=None):
        """
        Opens a new tab, selects it, creates a new thumbnail and tree item
        name: unique name, sent by PDF convert/load file.
        wb: Passed by undo_tab to ensure the tab total is correct
        """
        if not wb:
            self.tab_total += 1
        if not name:
            name = u"%s %s" % (_("Sheet"), self.tab_total)
        logger.debug("Opening new sheet [%s]", name)

        self.tab_count += 1
        self.thumbs.new_thumb(name=name)
        self.notes.add_tab(name)
        self.tabs.AddPage(Canvas(self.tabs, self, (Config().default_width(),
                                                   Config().default_height())), name)

        self.update_panels(False)  # unhighlight current
        self.thumbs.thumbs[self.current_tab].current = True

        self.current_tab = self.tab_count - 1
        self.tabs.SetSelection(self.current_tab)  # fires on_change_tab
        self.on_change_tab()


    def on_change_tab(self, event=None):
        """Updates tab vars, scrolls thumbnails and selects tree node"""
        self.canvas = self.tabs.GetCurrentPage()
        self.update_panels(False)
        self.current_tab = self.tabs.GetSelection()

        self.update_panels(True)
        self.thumbs.thumbs[self.current_tab].update()
        self.thumbs.ScrollChildIntoView(self.thumbs.thumbs[self.current_tab])
        self.control.change_tool()  # updates canvas' shape

        if self.notes.tabs:
            tree_id = self.notes.tabs[self.current_tab]
            self.notes.tree.SelectItem(tree_id, True)
        pub.sendMessage('update_shape_viewer')



    def prompt_for_save(self, method, style=wx.YES_NO | wx.CANCEL, args=None):
        """
        Ask the user to save, quit or cancel (quitting) if they haven't saved.
        Can be called through "Update", "Open (.wtbd)", or "Exit". If updating,
        don't show a cancel button, and explicitly restart if the user cancels
        out of the "save file" dialog
        method(*args) specifies the action to perform if user selects yes or no
        """
        if not args:
            args = []

        if not self.util.saved:
            name = _("Untitled")
            if self.util.filename:
                name = os.path.basename(self.util.filename)

            dialog = PromptForSave(self, name, method, style, args)
            dialog.ShowModal()

        else:
            method(*args)
            if method == self.Destroy:
                logger.info("Program exiting.")
                sys.exit()


    def prompt_for_im(self):
        dlg = FindIM(self.util, self, self.util.check_im_path)
        dlg.ShowModal()


    def on_drop_tab(self, event):
        """
        Update the thumbs/notes so that they're poiting to the new tab position.
        Show a progress dialog, as all thumbnails must be updated.
        """
        if event.GetSelection() == event.GetOldSelection():
            return

        self.show_progress_dialog(_("Loading..."))
        self.dialog.Show()
        self.on_change_tab()

        pub.sendMessage('sheet.move', event=event, tab_count=self.tab_count)
        self.on_done_load()
        wx.MilliSleep(100)  # try and stop user dragging too many tabs quickly
        wx.SafeYield()
        pub.sendMessage('update_shape_viewer')


    def update_panels(self, select):
        """Updates thumbnail panel's text"""
        pub.sendMessage('thumbs.text.highlight', tab=self.current_tab,
                        select=select)


    def on_close_tab(self, event=None):
        """
        Closes the current tab (if there are any to close).
        """
        if self.is_only_one_tab_open():
            return
        logger.debug("Closing sheet [%s]", self.tabs.GetPageText(self.current_tab))
        
        self.tab_count -= 1
        self.notes.remove_tab(self.current_tab)
        self.thumbs.remove(self.current_tab)

        for x in self.canvas.medias:
            x.remove_panel()
        self.create_sheet_undo_point(self.canvas, self.current_tab)

        if os.name == "posix":
            self.tabs.RemovePage(self.current_tab)
        else:
            self.tabs.DeletePage(self.current_tab)

        self.on_change_tab()  # updates self.canvas


    def create_sheet_undo_point(self, canvas, tab_number, recreate_menu=True):
        """
        Creates an undo entry for a tab that's being closed
        """
        if len(self.closed_tabs) == UNDO_SHEET_COUNT:
            del self.closed_tabs[0]

        item = {'shapes': canvas.shapes,
                'undo': canvas.undo_list,
                'redo': canvas.redo_list,
                'size': canvas.area,
                'name': self.tabs.GetPageText(tab_number),
                'medias': canvas.medias,
                'viewport': canvas.GetViewStart()}

        self.closed_tabs.append(item)
        if recreate_menu:
            self.menu.make_closed_tabs_menu()


    def on_close_all_sheets(self, event=None):
        """
        Closes every sheet, creating undo points for each one.
        """
        if self.is_only_one_tab_open():
            return

        for x in reversed(range(self.tab_count)):
            self.create_sheet_undo_point(self.tabs.GetPage(x), x, False)

        self.menu.make_closed_tabs_menu()
        self.remove_all_sheets()
        self.on_new_tab()


    def on_close_other_sheets(self, event=None):
        """
        Closes all sheets except the current open sheet
        """
        if self.is_only_one_tab_open():
            return
        
        current_tab = self.current_tab
        logger.debug("Closing other sheets besides [%s]", self.tabs.GetPageText(self.current_tab))
        
        canvases = self.get_canvases()
        next_to_last_sheets = canvases[current_tab + 1 : len(canvases)]
        
        for canvas in next_to_last_sheets:
            self.current_tab += 1
            self.canvas = canvas
            self.on_close_tab()
        
        first_to_prev_sheets = self.get_canvases()[0 : -1] 
        for canvas in first_to_prev_sheets:
            self.current_tab = 0
            self.canvas = canvas
            self.on_close_tab()
        
        self.menu.make_closed_tabs_menu()
        
        
    def is_only_one_tab_open(self):    
        if not self.tab_count - 1:
            logger.debug("Cannot close sheet -- only one sheet open")
            return True
        return False
                
    def remove_all_sheets(self):
        self.canvas.shapes = []
        self.canvas.redraw_all()
        self.tabs.DeleteAllPages()
        self.thumbs.remove_all()
        self.notes.remove_all()
        self.tab_count = 0
        self.tab_total = 0


    def on_undo_tab(self, event=None, tab=None):
        """
        Undoes the last closed tab from the list.
        Re-creates the canvas from the saved shapes/undo/redo lists
        """
        if not self.closed_tabs:
            return
        if not tab:
            tab = self.closed_tabs.pop()
        else:
            tab = self.closed_tabs.pop(self.closed_tabs.index(tab))

        self.on_new_tab(name=tab['name'], wb=True)
        self.canvas.restore_sheet(tab['shapes'], tab['undo'], tab['redo'],
                                  tab['size'], tab['medias'], tab['viewport'])
        pub.sendMessage('update_shape_viewer')
        self.menu.make_closed_tabs_menu()


    def on_rename(self, event=None, sheet=None):
        if sheet is None:
            sheet = self.current_tab
        current_name = self.tabs.GetPageText(sheet)
        dlg = wx.TextEntryDialog(self, _("Rename this sheet to:"), _("Rename sheet"))
        dlg.SetValue(current_name)

        if dlg.ShowModal() == wx.ID_CANCEL:
            dlg.Destroy()
        else:
            val = dlg.GetValue()
            if val:
                logger.debug("Renaming sheet [%s] to [%s]", current_name, val)
                self.tabs.SetPageText(sheet, val)
                pub.sendMessage('sheet.rename', _id=sheet, text=val)


    def load_recent_files(self, event):
        """
        Re-creates the Recent Files menu by reloading the config file.
        """
        if self.menu.is_file_menu(event.GetMenu()):
            self.menu.remove_all_recent()
            self.load_history_file()
            self.filehistory.Load(self.config)
        event.Skip()  # otherwise interferes with EVT_UPDATE_UI


    def update_menus(self, event):
        """
        Enables/disables GUI menus and toolbar items.
        It uses a counter for the clipboard check as it can be too performance
        intense and cause segmentation faults
        """
        canvas = self.canvas
        if not canvas:
            return
        _id = event.GetId()

        if _id in [wx.ID_PASTE, ID_PASTE_NEW]:  # check this less frequently, possibly expensive
            self.paste_check_count += 1
            if self.paste_check_count == PASTE_CHECK_COUNT:
                self.can_paste = False

            if check_clipboard():
                self.can_paste = True
                self.paste_check_count = 0
                try:
                    self.menu.enable(ID_PASTE_NEW, self.can_paste)
                    self.menu.enable(wx.ID_PASTE, self.can_paste)
                except wx.PyDeadObjectError:
                    pass
            return

        if _id == ID_TRANSPARENT:
            if canvas.can_swap_transparency():
                if canvas.is_transparent():
                    event.Check(True)
                else:
                    event.Check(False)
                event.Enable(True)
            else:
                event.Enable(False)
            return

        do = False
        if _id == wx.ID_REDO and canvas.redo_list:
            do = True
        elif _id == wx.ID_UNDO and canvas.undo_list:
            do = True
        elif _id == ID_PREV and self.current_tab:
            do = True
        elif (_id == ID_NEXT and self.can_change_next_sheet()):
            do = True
        elif _id in [wx.ID_CLOSE, ID_CLOSE_ALL, ID_CLOSE_OTHERS] and self.tab_count > 1:
            do = True
        elif _id in [ID_UNDO_SHEET, ID_RECENTLY_CLOSED] and self.closed_tabs:
            do = True
        elif _id in [wx.ID_DELETE, ID_DESELECT, ID_FOREGROUND] and canvas.selected:
            do = True
        elif _id == ID_MOVE_UP and canvas.check_move(u"up"):
            do = True
        elif _id == ID_MOVE_DOWN and canvas.check_move(u"down"):
            do = True
        elif _id == ID_MOVE_TO_TOP and canvas.check_move(u"top"):
            do = True
        elif _id == ID_MOVE_TO_BOTTOM and canvas.check_move(u"bottom"):
            do = True
        elif _id in [ID_SWAP_COLOURS, ID_BACKGROUND] and canvas.can_swap_colours():
            do = True
        elif _id == wx.ID_COPY:
            if canvas:
                if canvas.copy:
                    do = True
        event.Enable(do)



    def can_change_next_sheet(self):
        return self.tab_count > 1 and self.current_tab + 1 < self.tab_count

    def on_delete_shape(self, event=None):
        self.canvas.delete_selected()

    def on_deselect_shape(self, event=None):
        self.canvas.deselect_shape()

    def on_copy(self, event):
        set_clipboard(self.canvas.get_selection_bitmap())

    def paste_image(self, bitmap, x, y, ignore=False):
        self.canvas.paste_image(bitmap, x, y, ignore)

    def paste_text(self, text, x, y):
        self.canvas.paste_text(text, x, y, self.util.colour)

    def on_paste_new(self, event):
        """ Pastes the text/image into a new tab """
        self.on_new_tab()
        self.on_paste(ignore=True)

    def on_paste(self, event=None, ignore=False):
        """
        Grabs the image from the clipboard and places it on the panel
        Ignore is used when pasting into a new sheet
        """
        data = get_clipboard()
        if not data:
            return

        x, y = 0, 0
        if not ignore:
            x, y = self.canvas.get_mouse_position()

        if isinstance(data, wx.TextDataObject):
            logger.debug("Pasting text data at coords %s", (x, y))
            self.paste_text(data.GetText(), x, y)
        else:
            logger.debug("Pasting bitmap data at coords %s", (x, y))
            self.paste_image(data.GetBitmap(), x, y, ignore)


    def on_change_tool(self, event, _id, key):
        """ Change tool -- used when being used as a hotkey """
        if self.canvas.is_not_drawing():
            self.control.change_tool(_id=_id)
            tool_name = self.canvas.shape.__class__.__name__
            logger.debug("Hotkey [%s] pressed, changing tools to [%s]", key, tool_name)

    def pubsub_change_tool(self, new=None):
        if self.canvas:
            self.change_tool(new)


    def change_tool(self, new=None, canvas=None):
        if not canvas:
            canvas = self.canvas

        self.util.change_tool(canvas, new)
        canvas.change_tool()
        pub.sendMessage('gui.preview.refresh')


    def on_fullscreen(self, event=None, val=None):
        """ Toggles fullscreen. val forces fullscreen on/off """
        flag = wx.FULLSCREEN_NOBORDER | wx.FULLSCREEN_NOCAPTION | wx.FULLSCREEN_NOSTATUSBAR
        if not val:
            val = not self.IsFullScreen()

        self.ShowFullScreen(val, flag)
        self.menu.toggle_fullscreen(val)


    def hotkey(self, event=None):
        """
        Checks for hotkeys to either change tools or to move the canvas'
        viewport. Checks for the arrow keys to move shapes about.
        """
        code = event.GetKeyCode()
        if os.name == "posix":
            for x, key in enumerate(self.hotkeys):

                if code in [ord(key), ord(key.upper())]:                    
                    self.on_change_tool(None, _id=x + 1, key=key)
                    return

        if code == wx.WXK_ESCAPE:  # close fullscreen/deselect shape
            if self.canvas.selected:
                self.canvas.deselect_shape()  # check this before fullscreen
                return
            if self.IsFullScreen():
                self.on_fullscreen(None, False)
        elif code in [wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT, wx.WXK_UP]:
            if self.canvas.selected:
                shape = self.canvas.selected

                _map = { wx.WXK_UP: (shape.x, shape.y - SCROLL_AMOUNT),
                        wx.WXK_DOWN: (shape.x, shape.y + SCROLL_AMOUNT),
                        wx.WXK_LEFT: (shape.x - SCROLL_AMOUNT, shape.y),
                        wx.WXK_RIGHT: (shape.x + SCROLL_AMOUNT, shape.y) }

                if not self.hotkey_pressed:
                    self.hotkey_pressed = True
                    self.canvas.add_undo()
                    shape.start_select_action(0)
                    self.hotkey_timer = wx.CallLater(150, self.reset_hotkey)
                else:
                    self.hotkey_timer.Restart(150)

                shape.move(_map.get(code)[0], _map.get(code)[1],
                           offset=shape.offset(shape.x, shape.y))
                self.canvas.draw_shape(shape)
                #shape.find_edges()
                #self.canvas.shape_near_canvas_edge(shape.edges[EDGE_LEFT],
                #                                   shape.edges[EDGE_TOP], True)
                return
        self.hotkey_scroll(code, event)
        event.Skip()


    def hotkey_scroll(self, code, event):
        """Scrolls the viewport depending on the key pressed"""
        x, y = None, None
        if code == wx.WXK_HOME:
            x, y = 0, -1  # beginning of viewport
            if event.ControlDown():
                x, y = -1, 0  # top of document

        elif code == wx.WXK_END:
            x, y = self.canvas.area[0], -1  # end of viewport
            if event.ControlDown():
                x, y = -1, self.canvas.area[1]  # end of page

        elif code in [wx.WXK_PAGEUP, wx.WXK_PAGEDOWN, wx.WXK_DOWN, wx.WXK_LEFT,
                      wx.WXK_RIGHT, wx.WXK_UP]:
            x, y = self.canvas.GetViewStart()
            x2, y2 = self.canvas.GetClientSizeTuple()

            _map = { wx.WXK_PAGEUP: (-1, y - y2),
                    wx.WXK_PAGEDOWN: (-1, y + y2),
                    wx.WXK_UP: (-1, y - SCROLL_AMOUNT),
                    wx.WXK_DOWN: (-1, y + SCROLL_AMOUNT),
                    wx.WXK_LEFT: (x - SCROLL_AMOUNT, -1),
                    wx.WXK_RIGHT: (x + SCROLL_AMOUNT, -1) }

            x, y = _map.get(code)[0], _map.get(code)[1]

        if x != None and y != None:
            self.canvas.Scroll(x, y)


    def reset_hotkey(self):
        """Reset the system for the next stream of hotkey up/down events"""
        self.hotkey_pressed = False
        if not self.canvas.selected:
            return
        self.canvas.selected.end_select_action(0)
        pub.sendMessage('update_shape_viewer')


    def get_canvases(self):
        return [self.tabs.GetPage(x) for x in range(self.tab_count)]

    def get_tab_names(self):
        return [self.tabs.GetPageText(x) for x in range(self.tab_count)]

    def get_background_colour(self):
        return self.control.get_background_colour()

    def get_colour(self):
        return self.control.get_colour()

    def toggle_control(self, menu, control, force=None):
        """Menu ID to check, enable/disable; view: Control to show/hide"""
        val = self.get_toggle_value(menu, force)
        control.Show(val)
        self.menu.check(menu, val)
        self.SendSizeEvent()

    def get_toggle_value(self, menu, force):
        val = False
        if self.menu.is_checked(menu) or force:
            val = True
        if force is False:
            val = False
        return val

    def on_toolbar(self, event=None, force=None):
        self.toggle_control(ID_TOOLBAR, self.toolbar, force)

    def on_tool_preview(self, event=None, force=None):
        self.toggle_control(ID_TOOL_PREVIEW, self.control.preview, force)

    def on_statusbar(self, event=None, force=None):
        self.toggle_control(ID_STATUSBAR, self.statusbar, force)


    def on_colour_grid(self, event=None, force=None):
        val = self.get_toggle_value(ID_COLOUR_GRID, force)
        self.control.toggle_colour_grid(val)
        self.menu.check(ID_COLOUR_GRID, val)
        pub.sendMessage('gui.preview.refresh')


    def convert_dialog(self, cmd):
        """Called when the PDF convert process begins"""
        self.process = wx.Process(self)
        self.pid = wx.Execute(cmd, wx.EXEC_ASYNC, self.process)
        self.show_progress_dialog(_("Converting..."), True, True)


    def on_end_process(self, event=None):
        """ Destroy the progress process after Convert finishes """
        self.process.Destroy()
        self.dialog.Destroy()
        del self.process
        self.pid = None


    def show_text_dialog(self, text):
        dlg = TextInput(self, text=text)
        if dlg.ShowModal() == wx.ID_CANCEL:
            self.canvas.text = None
            self.canvas.redraw_all()
            self.pubsub_change_tool()
            return False

        dlg.transfer_data(self)  # grab font and text data


    def show_text_edit_dialog(self, text_shape):
        dlg = TextInput(self, text_shape)
        if dlg.ShowModal() == wx.ID_CANCEL:
            return False
        dlg.transfer_data(text_shape)  # grab font and text data
        return True


    def show_progress_dialog(self, title, cancellable=False, modal=False):
        self.dialog = ProgressDialog(self, title, cancellable)
        if modal:
            self.dialog.ShowModal()
        else:
            self.dialog.Show()


    def on_done_load(self, event=None):
        """ Refreshes thumbnails, destroys progress dialog after loading """
        self.dialog.SetTitle(_("Updating Thumbnails"))
        wx.MilliSleep(50)
        wx.SafeYield()
        self.on_refresh()  # force thumbnails
        self.dialog.Destroy()


    def on_file_history(self, evt):
        """ Handle file load from the recent files menu """
        num = evt.GetId() - wx.ID_FILE1
        path = self.filehistory.GetHistoryFile(num)
        if not os.path.exists(path):
            wx.MessageBox(_("File %s not found") % path, u"Whyteboard")
            self.filehistory.RemoveFileFromHistory(num)
            self.filehistory.Save(self.config)
            self.config.Flush()
            return

        self.filehistory.AddFileToHistory(path)  # move up the list
        self.open_file(path)


    def on_exit(self, event=None):
        logger.info("User requested application to exit.")
        self.prompt_for_save(self.Destroy)

    def tab_popup(self, event):
        self.PopupMenu(SheetsPopup(self, self, event.GetSelection()))

    def on_undo(self, event=None):
        logger.debug("Undoing last action")
        self.canvas.undo()

    def on_redo(self, event=None):
        logger.debug("Redoing last action")
        self.canvas.redo()

    def on_move_top(self, event=None):
        self.canvas.move_top(self.canvas.selected)

    def on_move_bottom(self, event=None):
        self.canvas.move_bottom(self.canvas.selected)

    def on_move_up(self, event=None):
        self.canvas.move_up(self.canvas.selected)

    def on_move_down(self, event=None):
        self.canvas.move_down(self.canvas.selected)


    def on_previous_sheet(self, event=None):
        if not self.current_tab:
            return
        self.tabs.SetSelection(self.current_tab - 1)
        self.on_change_tab()

    def on_next_sheet(self, event=None):
        if not self.can_change_next_sheet():
            return
        self.tabs.SetSelection(self.current_tab + 1)
        self.on_change_tab()


    def on_clear(self, event=None):
        self.canvas.clear(keep_images=True)

    def on_clear_all(self, event=None):
        self.canvas.clear()
        self.thumbs.update_all()

    def on_clear_sheets(self, event=None):
        for tab in range(self.tab_count):
            self.tabs.GetPage(tab).clear(keep_images=True)


    def on_clear_all_sheets(self, event=None):
        for tab in range(self.tab_count):
            self.tabs.GetPage(tab).clear()
        self.thumbs.update_all()


    def on_foreground(self, event):
        self.canvas.change_colour()

    def on_background(self, event):
        self.canvas.change_background()

    def on_refresh(self):
        self.thumbs.update_all()

    def on_transparent(self, event=None):
        self.canvas.toggle_transparent()

    def on_swap_colours(self, event=None):
        self.canvas.swap_colours()

    def on_page_setup(self, evt):
        self._print.page_setup()

    def on_print_preview(self, event):
        self._print.print_preview()

    def on_print(self, event):
        self._print.do_print()

    def on_new_win(self, event=None):
        program = (u'python', os.path.abspath(sys.argv[0]))
        if is_exe():
            program = os.path.abspath(sys.argv[0])

        logger.debug("Loading new application instance: [%s]", program)
        subprocess.Popen(program)
        

    def on_translate(self, event):
        open_url(u"https://translations.launchpad.net/whyteboard")

    def on_report_bug(self, event):
        open_url(u"https://bugs.launchpad.net/whyteboard")

    def on_resize(self, event=None):
        show_dialog(Resize(self))

    def on_preferences(self, event=None):
        show_dialog(Preferences(self))

    def on_update(self, event=None):
        show_dialog(UpdateDialog(self))

    def on_history(self, event=None):
        show_dialog(History(self))

    def on_pdf_cache(self, event=None):
        show_dialog(PDFCacheDialog(self, self.util.library))

    def on_feedback(self, event):
        show_dialog(Feedback(self), False)

    def load_history_file(self):
        self.config = wx.Config(u"Whyteboard", style=wx.CONFIG_USE_LOCAL_FILE)


    def on_shape_viewer(self, event=None):
        if not self.shape_viewer_open:
            self.shape_viewer_open = True
            show_dialog(ShapeViewer(self), False)


    def mark_unsaved(self):
        if self.util.saved:
            self.util.saved = False
            self.SetTitle(u"*" + self.GetTitle())


    def find_help(self):
        """Locate the help files, update self.help var"""
        self.help = None

        if os.path.exists(help_file_path()):
            self.help = HtmlHelpController()
            self.help.AddBook(help_file_path())


    def on_help(self, event=None, page=None):
        """
        Shows the help file, if it exists, otherwise prompts the user to
        download it.
        """
        if self.help and os.path.exists(help_file_path()):
            if page:
                self.help.Display(page)
            else:
                self.help.DisplayIndex()
        else:
            if self.download_help():
                self.on_help(page=page)


    def download_help(self):
        """Downloads the help files"""
        msg = _("Help files not found, do you want to download them?")
        d = wx.MessageDialog(self, msg, style=wx.YES_NO | wx.ICON_QUESTION)
        if d.ShowModal() == wx.ID_YES:
            try:
                download_help_files(self.util.path[0])
                self.find_help()
                return True
            except IOError:
                return False


    def on_about(self, event=None):
        inf = wx.AboutDialogInfo()
        inf.Name = u"Whyteboard"
        inf.Version = meta.version
        inf.Copyright = u"© 2009-2011 Steven Sproat"
        inf.Description = _("A simple whiteboard and PDF annotator")
        inf.Developers = [u"Steven Sproat <*****@*****.**>"]
        inf.Translators = meta.translators
        inf.WebSite = (u"http://www.whyteboard.org", u"http://www.whyteboard.org")
        inf.Licence = u"GPL 3"
        license = os.path.join(get_path(), u"LICENSE.txt")
        if os.path.exists(license):
            with open(license) as f:
                inf.Licence = f.read()

        if os.name == "nt":
            AboutDialog(self, inf)
        else:
            wx.AboutBox(inf)