root/trunk/ide/ClassDesigner.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
import copy
import inspect
import dabo
from dabo.dLocalize import _
import dabo.dEvents as dEvents
if __name__ == "__main__":
    dabo.ui.loadUI("wx")
# This is because I'm a lazy typist
dui = dabo.ui
from ClassDesignerFormMixin import ClassDesignerFormMixin as dfm
from ClassDesignerPemForm import PemForm
from ClassDesignerEditor import EditorForm
from ClassDesignerComponents import LayoutPanel
from ClassDesignerComponents import LayoutBasePanel
from ClassDesignerComponents import LayoutSpacerPanel
from ClassDesignerComponents import LayoutSizer
from ClassDesignerComponents import LayoutBorderSizer
from ClassDesignerComponents import LayoutGridSizer
from ClassDesignerComponents import LayoutSaverMixin
from ClassDesignerComponents import NoSizerBasePanel
from ClassDesignerComponents import szItemDefaults
from ClassDesignerComponents import classFlagProp
from ClassDesignerControlMixin import ClassDesignerControlMixin as cmix
from ClassDesignerCustomPropertyDialog import ClassDesignerCustomPropertyDialog
from ClassDesignerSizerPalette import SizerPaletteForm
from dabo.lib.DesignerXmlConverter import DesignerXmlConverter
from dabo.lib import DesignerUtils
import ClassDesignerMenu
import dabo.lib.xmltodict as xtd
import dabo.ui.dialogs as dlgs
from dabo.lib.utils import dictStringify
from ClassDesignerExceptions import PropertyUpdateException
# Temporary fix for wxPython 2.6 users
try:
    dabo.ui.dDockForm
    _USE_DOCKFORM = True
except:
    dabo.ui.dDockForm = None
    _USE_DOCKFORM = False



class ClassDesigner(dabo.dApp):
    # Behaviors which are normal in the framework may need to
    # be modified when run as the ClassDesigner. This flag will
    # distinguish between the two states.
    isDesigner = True

    def __init__(self, clsFile=""):
        super(ClassDesigner, self).__init__(showSplashScreen=False,
                splashTimeout=10)

        self._basePrefKey = "dabo.ide.ClassDesigner"
        self._desFormClass = None
        self._selectedClass = dui.dForm
        self._currentForm = None
        self._editorForm = None
        self._pemForm = None
        self._tree = None
        self._palette = None
        self._sizerPalette = None
        self._selection = []
        self._editors = []
        self._srcObj = None
        self._srcPos = None
        self._codeDict = {}
        self._classCodeDict = {}
        self._classPropDict = {}
        self._classImportDict = {}
        self._classDefaultVals = {}
        self._mixedControlClasses = {}
        self._superClassInfo = {}
        self._addingClass = False
        # Tuple of all paged-control classes
        self.pagedControls = (dui.dPageFrame, dui.dPageList, dui.dPageSelect,
                dui.dPageFrameNoTabs)
        self.MainFormClass = None
        self.setAppInfo("appName", "Class Designer")
        # Some processes need to behave differently when we are
        # importing a class from a cdxml file; this flag lets them
        # determine what process is being run.
        self.openingClassXML = False
        # Create the clipboard
        self._clipboard = None
        # This holds a reference to the target object when
        # there is a context menu event.
        self._contextObj = None
        # When saving classes, we need to note when we are inside
        # a class definition. The list is used as the class stack.
        self._classStack = []
        # We also need to save child class definitions on a stack, when
        # saving/recreating class components with nested objects.
        self._classChildDefStack = []
        # Flag for indicating that all props, not just non-default ones,
        # are saved in the .cdxml file
        self.saveAllProps = False
        # When we set the DefaultBorder for a sizer, should we
        # resize all its children?
        self._propagateDefaultBorder = True
        # Store the name of the custom class menu here instead of
        # hard-coding it in several places.
        self._customClassCaption = _("Custom Classes")
        # Add this to the persistent MRUs
        self._persistentMRUs[self._customClassCaption] = self.addCustomClass
        # Save the default atts for sizers. This way we can distinguish
        # from default sizers that can be replaced from customized
        # sizers which should remain.
        self._defBoxSizerAtts = bsa = {}
        atts = LayoutSizer().getDesignerDict(allProps=True)["attributes"]
        bsa["DefaultBorder"] = atts["DefaultBorder"]
        bsa["DefaultBorderTop"] = atts["DefaultBorderTop"]
        bsa["DefaultBorderBottom"] = atts["DefaultBorderBottom"]
        bsa["DefaultBorderLeft"] = atts["DefaultBorderLeft"]
        bsa["DefaultBorderRight"] = atts["DefaultBorderRight"]
        self._defGridSizerAtts = gsa = {}
        atts = LayoutGridSizer().getDesignerDict(allProps=True)["attributes"]
        gsa["HGap"] = atts["HGap"]
        gsa["VGap"] = atts["VGap"]
        gsa["MaxDimension"] = atts["MaxDimension"]
        # Get rid of the update/refresh delays
        dabo.useUpdateDelays = False


        # Define the controls that can be added to the ClassDesigner. The
        # 'order' value will determine their order in the menu. One plan
        # is to keep track of the user's choices, and weight the orders
        # so that their most frequent choices are at the top.
        self.designerControls = ({"name" : "Box", "class" : dui.dBox, "order" : 0},
                {"name" : "Bitmap", "class" : dui.dBitmap, "order" : 10},
                {"name" : "BitmapButton", "class" : dui.dBitmapButton, "order" : 20},
                {"name" : "Button", "class" : dui.dButton, "order" : 30},
                {"name" : "CheckBox", "class" : dui.dCheckBox, "order" : 40},
                {"name" : "CodeEditor", "class" : dui.dEditor, "order" : 45},
                {"name" : "ComboBox", "class" : dui.dComboBox, "order" : 50},
                {"name" : "DateTextBox", "class" : dui.dDateTextBox, "order" : 60},
                {"name" : "DropdownList", "class" : dui.dDropdownList, "order" : 70},
                {"name" : "EditBox", "class" : dui.dEditBox, "order" : 80},
                {"name" : "SlidePanelControl", "class" : dui.dSlidePanelControl, "order" : 82},
                {"name" : "HtmlBox", "class" : dui.dHtmlBox, "order" : 85},
                {"name" : "Gauge", "class" : dui.dGauge, "order" : 90},
                {"name" : "Grid", "class" : dui.dGrid, "order" : 100},
                {"name" : "Image", "class" : dui.dImage, "order" : 110},
                {"name" : "Label", "class" : dui.dLabel, "order" : 120},
                {"name" : "Line", "class" : dui.dLine, "order" : 130},
                {"name" : "ListBox", "class" : dui.dListBox, "order" : 140},
                {"name" : "ListControl", "class" : dui.dListControl, "order" : 150},
                {"name" : "RadioList", "class" : dui.dRadioList, "order" : 160},
                {"name" : "Page", "class" : dui.dPage, "order" : 170},
                {"name" : "Panel", "class" : dui.dPanel, "order" : 180},
                {"name" : "ScrollPanel", "class" : dui.dScrollPanel, "order" : 190},
                {"name" : "PageFrame", "class" : dui.dPageFrame, "order" : 200},
                {"name" : "PageList", "class" : dui.dPageList, "order" : 210},
                {"name" : "PageSelect", "class" : dui.dPageSelect, "order" : 220},
                {"name" : "PageFrameNoTabs", "class" : dui.dPageFrameNoTabs, "order" : 230},
                {"name" : "Slider", "class" : dui.dSlider, "order" : 240},
                {"name" : "Spinner", "class" : dui.dSpinner, "order" : 250},
                {"name" : "Splitter", "class" : dui.dSplitter, "order" : 260},
                {"name" : "TextBox", "class" : dui.dTextBox, "order" : 270},
                {"name" : "ToggleButton", "class" : dui.dToggleButton, "order" : 280},
                {"name" : "TreeView", "class" : dui.dTreeView, "order" : 290}
                )
        self._initClassEvents()

        self.setup()

        clsOK = False
        if clsFile:
            if not clsFile.endswith(".cdxml"):
                clsFile += ".cdxml"
            try:
                frm = self.openClass(clsFile)
                clsOK = True
            except IOError, e:
                msg = _("'%s' does not exist. Create it?") % clsFile
                if dui.areYouSure(message=msg, title=_("File Not Found"), cancelButton=False):
                    frm = self.onNewDesign(evt=None, pth=clsFile)
                    clsOK = True

        if not clsOK:
            # Define the form class, and instantiate it.
            frmClass = self.getFormClass()

            # Temp! for development
#           useSz = not os.path.exists("/Users/ed/dls")
#           frm = frmClass(UseSizers=useSz)
            frm = frmClass(UseSizers=True)

            frm._setupPanels()
            # Use this to determine if an empty class should be released
            frm._initialStateDict = frm.getDesignerDict()
        else:
            frm._initialStateDict = {}
        frm.Controller = self
        self.MainForm = frm
        # When more than one ClassDesigner is open, this will
        # hold the active reference.
        self.CurrentForm = frm
        # Create the form the holds the PropSheet, Method listing
        # and object tree if it hasn't already been created.
        pf = self._pemForm
        if pf is None:
            pf = self._pemForm = PemForm(None)
        pf.Controller = self
        pf.Visible = True

        # Create the control palette
        palette = self.ControlPalette
        palette.Controller = self
        palette.Visible = False

        # Create the sizer palette, but make it hidden to start
        palette = self.SizerPalette
        palette.Controller = self
        palette.Visible = False

        # Create the Code Editor
        ed = self.EditorForm
        ed.Controller = self
        ed.Visible = True

        # Set the initial selection to the form
        self.select(self.CurrentForm)

        frm.Visible = True
        dui.callAfter(frm.layout)
        dui.callAfterInterval(100, self.updateLayout)
        dui.callAfter(frm.bringToFront)
        dui.callAfter(frm.saveState)
        self.start()


    def _initClassEvents(self):
        """Create a dict by baseclass of all applicable events."""
        self._classEvents = {}
        self._classMethods = {}
        baseEvents = ("DataEvent", "EditorEvent", "GridEvent", "KeyEvent",
                "ListEvent", "MenuEvent", "MouseEvent", "SashEvent",
                "CalendarEvent", "TreeEvent")
        classes = (dui.dBox, dui.dBitmap, dui.dBitmapButton, dui.dButton, dui.dCheckBox, dui.dComboBox,
                dui.dDateTextBox, dui.dDialog, dui.dDropdownList, dui.dEditBox, dui.dEditor, dui.dSlidePanelControl,
                dui.dForm, dui.dDockForm, dui.dGauge, dui.dGrid, dui.dHtmlBox, dui.dImage, dui.dLabel, dui.dLine,
                dui.dListBox, dui.dListControl, dui.dOkCancelDialog, dui.dPanel, dui.dPage, dui.dScrollPanel,
                dui.dPage, dui.dPageFrame, dui.dPageList, dui.dPageSelect, dui.dPageFrameNoTabs,
                dui.dRadioList, dui.dSlider, dui.dSpinner, dui.dSplitter, dui.dTextBox, dui.dToggleButton,
                dui.dTreeView, dlgs.Wizard, dlgs.WizardPage)

        def evtsForClass(cls):
            def safeApplies(itm, cls):
                try:
                    return itm.appliesToClass(cls)
                except (AttributeError, NameError):
                    return False
            ret = ["on%s" % k for k,v in dEvents.__dict__.items() 
                    if safeApplies(v,cls)]
            ret.sort()
            return ret

        def mthdsForClass(cls):
            ret = []
            mthds = inspect.getmembers(cls, inspect.ismethod)
            ret = [mthd[0] for mthd in mthds
                    if mthd[0][0] in "abcdefghijklmnopqrstuvwxyz"]
            return ret

        for cls in classes:
            self._classEvents[cls] = evtsForClass(cls)
            self._classMethods[cls] = mthdsForClass(cls)

    def getFormClass(self, filepath=None):
        """If the selected class is a form/dialog, return a mixed-in
        subclass of it. Otherwise, return the base ClassDesignerForm.
        """
        formIsMain = issubclass(self._selectedClass, (dui.dForm, dui.dDialog))
        isDialog = issubclass(self._selectedClass, (dui.dDialog, ))
        isWizard = issubclass(self._selectedClass, (dlgs.Wizard, ))
        isDockForm = _USE_DOCKFORM and issubclass(self._selectedClass, (dui.dDockForm, ))
        if formIsMain:
            if isDockForm:
                base = self._selectedClass      ##dui.dForm
            elif not isDialog and self._desFormClass is not None:
                return self._desFormClass
            else:
                base = self._selectedClass
        else:
            base = dui.dForm
        class DesForm(dfm, base):
            _superBase = base
            _superMixin = dfm
            _classFile = filepath
            def __init__(self, parent=None, *args, **kwargs):
                self._isMain = formIsMain
                if isDialog:
                    kwargs["BorderResizable"] = True
                    kwargs["ShowCloseButton"] = True
                if isWizard:
                    kwargs["Caption"] = "Dabo Wizard Designer"
                base.__init__(self, parent=parent, *args, **kwargs)
                dfm.__init__(self, parent=parent, *args, **kwargs)
                self._basePrefKey = "dabo.ide.ClassDesigner.ClassDesignerForm"

            def _afterInit(self):
                self._designerMode = True
                self._formMode = True
                if isDockForm:
                    self._configureForDockForm()
                super(DesForm, self)._afterInit()

            def addControls(self):
                if not isinstance(self, dui.dOkCancelDialog):
                    # Could be a wizard, or some other object with an 'addControls' method
                    self._superBase.addControls(self)
                    return
                if self.UseSizers:
                    self.mainPanel = LayoutBasePanel(self)
                    self.Sizer.append1x(self.mainPanel)
                    self.mainPanel.Sizer = LayoutSizer("v")
                    # Use a Layout Sizer instead of the default sizer.
                    self.initLayoutPanel = LayoutPanel(self.mainPanel)
                else:
                    self.mainPanel = self.initLayoutPanel = NoSizerBasePanel(self, BackColor=(222,222,255))
                    self.Sizer.append1x(self.mainPanel)
                    self.layout()
                # We need to 'deactivate' the built-in buttons
                self.btnOK.unbindEvent(dEvents.Hit)
                self.btnCancel.unbindEvent(dEvents.Hit)
                self.btnOK.Enabled = self.btnCancel.Enabled = False


            def _setupPanels(self, fromNew=True):
                if isinstance(self, dlgs.Wizard):
                    self.mainPanel = self.pagePanel
                    if self.UseSizers:
                        self.mainPanel.Sizer = LayoutSizer("v")
                    if fromNew:
                        # Need to ask for number of pages.
                        numPages = dabo.ui.getInt(_("How many pages?"), caption=_("Wizard Pages"),
                                defaultValue=3)
                        pgCls = self.Controller.getControlClass(dlgs.WizardPage)
                        pgs = [pgCls] * max(1, numPages)
                        self.append(pgs)
                        for num, p in enumerate(self._pages):
                            # Remove the title and line from the current sizer
                            p.Caption = _("Page %s Title") % num
                            if self.UseSizers:
                                # This will automatically add itself to the sizer
                                LayoutPanel(p)
                            else:
                                p.Sizer.append1x(NoSizerBasePanel(p))
                        self.initLayoutPanel = self._pages[0].Children[0]
                    else:
                        self.initLayoutPanel = self.mainPanel
                    self.CurrentPage = 0
                    self.btnCancel.Enabled = False
                    # Prevent the Finish button from closing the design surface.
                    self.finish = lambda: False
                    return

                if self.UseSizers:
                    if isinstance(self, dui.dOkCancelDialog):
                        # already done
                        return
                    if _USE_DOCKFORM and isinstance(self, dui.dDockForm):
                        self.mainPanel = self.CenterPanel
                    else:
                        self.Sizer = dui.dSizer("v")
                        self.mainPanel = LayoutBasePanel(self)
                        self.Sizer.append1x(self.mainPanel)
                    
                    self.mainPanel.Sizer = LayoutSizer("v")
                    # Use a Layout Sizer instead of the default sizer.
                    self.initLayoutPanel = LayoutPanel(self.mainPanel)
                else:
                    self.Sizer.release()
                    self.Sizer = None
                    self.mainPanel = self.initLayoutPanel = NoSizerBasePanel(self, BackColor=(222,222,255))
                    self.layout()
        ret = DesForm
        if formIsMain and not isDialog and not isDockForm:
            self._desFormClass = ret
        return ret


    def _reuseMainForm(self, useSizers=False):
        """Determines if the MainForm for the Class Designer is a blank, unedited
        form, which can be re-used when the user opens an existing class or
        creates a new class.
        """
        mf = self.MainForm
        if mf:
            if mf.UseSizers != useSizers:
                return False
            mfCurrDict = mf.getDesignerDict()
            # Position and size of the form may have changed; delete those
            # since they are irrelevant. Also, it seems that on Windows these
            # atts are set while the object is being created, so we have to
            # clear them in the _initialStateDict, too.
            for att in ("Left", "Top", "Width", "Height"):
                try:
                    del mfCurrDict["attributes"][att]
                except: pass
                try:
                    del mf._initialStateDict["attributes"][att]
                except: pass
        ret = mf and (mf._initialStateDict == mfCurrDict)
        return ret


    def onEditUndo(self, evt):
        dabo.infoLog.write(_("Not implemented yet"))
    def onEditRedo(self, evt):
        dabo.infoLog.write(_("Not implemented yet"))


    def _importClassXML(self, pth):
        """Read in the XML and associated code file (if any), and
        return a dict that can be used to re-create the object.
        """
        try:
            if not os.path.exists(pth):
                if os.path.exists(os.path.abspath(pth)):
                    pth = os.path.abspath(pth)
            dct = xtd.xmltodict(pth, addCodeFile=True)
        except StandardError, e:
            if pth.strip().startswith("<?xml") or os.path.exists(pth):
                raise IOError, _("This does not appear to be a valid class file.")
            else:
                raise IOError, _("The class file '%s' was not found.") % pth
            

        # Traverse the dct, looking for superclass information
        super = xtd.flattenClassDict(dct)
        if super:
            # We need to modify the info to incorporate the superclass info
            xtd.addInheritedInfo(dct, super)
            # Store the base code so that we can determine if instances have
            # modified it.
            self._updateClassCodeRepository(super)
        return dct


    def _updateClassCodeRepository(self, dct):
        """Take a flattened dict of class IDs and store any code
        associated with those IDs, so that we can later compare it to
        an object's code in order to determine if it has been changed.
        """
        cds = [(kk, vv["code"]) for kk, vv in dct.items()
                if vv["code"]]
        for cd in cds:
            self._classCodeDict.update({cd[0]: cd[1]})


    def _getClassMethod(self, clsID, mthd):
        """Given a class ID and a method name, returns the code for that
        classID/method combination (if any) from self._classCodeDict.
        """
        cd = self._classCodeDict.get(clsID, {})
        return cd.get(mthd, "")


    def _findSizerInClassDict(self, clsd):
        """Recursively search until a child is found with sizer information.
        If no such child is found, return False.
        """
        ret =