コード例 #1
0
ファイル: PropertiesCanvas.py プロジェクト: danheeks/PyCAD
    def AddProperty(self, property, parent_property=None):
        self.inAddProperty += 1

        # add a cad.property, optionally to an existing wx.PGProperty
        if property.GetType() == cad.PROPERTY_TYPE_STRING:
            new_prop = wxpg.StringProperty(property.GetTitle(),
                                           value=property.GetString())
        elif property.GetType() == cad.PROPERTY_TYPE_LONG_STRING:
            #new_prop = wxpg.LongStringProperty("MultipleButtons", wxpg.PG_LABEL)
            new_prop = wxpg.StringProperty(property.GetTitle(),
                                           value=property.GetString())
        elif property.GetType() == cad.PROPERTY_TYPE_DOUBLE:
            new_prop = wxpg.FloatProperty(property.GetTitle(),
                                          value=property.GetDouble())
        elif property.GetType() == cad.PROPERTY_TYPE_LENGTH:
            new_prop = wxpg.FloatProperty(property.GetTitle(),
                                          value=property.GetDouble() /
                                          cad.GetUnits())
        elif property.GetType() == cad.PROPERTY_TYPE_INT:
            new_prop = wxpg.IntProperty(property.GetTitle(),
                                        value=property.GetInt())
        elif property.GetType() == cad.PROPERTY_TYPE_COLOR:
            col = property.GetColor()
            wcol = wx.Colour(col.red, col.green, col.blue)
            new_prop = wxpg.ColourProperty(property.GetTitle(), value=wcol)
        elif property.GetType() == cad.PROPERTY_TYPE_CHOICE:
            new_prop = wxpg.EnumProperty(property.GetTitle(),
                                         labels=property.GetChoices(),
                                         value=property.GetInt())
        elif property.GetType() == cad.PROPERTY_TYPE_CHECK:
            new_prop = wxpg.BoolProperty(property.GetTitle(),
                                         value=property.GetBool())
            new_prop.SetAttribute(wxpg.PG_BOOL_USE_CHECKBOX, True)
        elif property.GetType() == cad.PROPERTY_TYPE_LIST:
            new_prop = wxpg.StringProperty(property.GetTitle(),
                                           value='<composed>')
        elif property.GetType() == cad.PROPERTY_TYPE_FILE:
            new_prop = wxpg.FileProperty(property.GetTitle(),
                                         value=property.GetString())
        else:
            wx.MessageBox('invalid property type: ' + str(property.GetType()))
            return

        if not property.editable:
            new_prop.ChangeFlag(wxpg.PG_PROP_READONLY, True)
        self.Append(parent_property, new_prop, property)

        if property.GetType() == cad.PROPERTY_TYPE_LIST:
            plist = property.GetProperties()
            for p in plist:
                self.AddProperty(p, new_prop)
            new_prop.ChangeFlag(wxpg.PG_PROP_COLLAPSED, True)
        elif property.GetType() == cad.PROPERTY_TYPE_LONG_STRING:
            # Change property to use editor created in the previous code segment
            #self.pg.SetPropertyEditor("MultipleButtons", self.multiButtonEditor)
            self.pg.SetPropertyEditor(new_prop, "TrivialPropertyEditor")

        self.inAddProperty -= 1
コード例 #2
0
    def populatepropgrid(self, pg):
        #Geometry Properties
        pg.Append(wxpg.PropertyCategory("Geometry"))

        normalID = pg.Append(
            wxpg.StringProperty("Position", value="<composed>"))
        pg.AppendIn(normalID, wxpg.FloatProperty("X", value=self.x))
        pg.AppendIn(normalID, wxpg.FloatProperty("Y", value=self.y))
        pg.AppendIn(normalID, wxpg.FloatProperty("Z", value=self.z))
コード例 #3
0
ファイル: SpherePortal.py プロジェクト: rameshvarun/Azathoth
    def populatepropgrid(self, pg):
        #Geometry Properties
        pg.Append(wxpg.PropertyCategory("Geometry"))

        normalID = pg.Append(wxpg.StringProperty("Center", value="<composed>"))
        pg.AppendIn(normalID, wxpg.FloatProperty("X", value=self.x))
        pg.AppendIn(normalID, wxpg.FloatProperty("Y", value=self.y))
        pg.AppendIn(normalID, wxpg.FloatProperty("Z", value=self.z))

        normalID2 = pg.Append(
            wxpg.StringProperty("Center2", value="<composed>"))
        pg.AppendIn(normalID2, wxpg.FloatProperty("X", value=self.x2))
        pg.AppendIn(normalID2, wxpg.FloatProperty("Y", value=self.y2))
        pg.AppendIn(normalID2, wxpg.FloatProperty("Z", value=self.z2))

        pg.Append(wxpg.FloatProperty("Radius", value=self.r))

        #Material Properties
        pg.Append(wxpg.PropertyCategory("Material"))
        pg.Append(wxpg.FloatProperty("Reflectivity", value=self.reflectivity))

        pg.Append(wxpg.BoolProperty("Cast Shadows", value=self.cast))
        pg.SetPropertyAttribute("Cast Shadows", "UseCheckbox", True)

        pg.Append(wxpg.BoolProperty("Recieve Shadows", value=self.recieve))
        pg.SetPropertyAttribute("Recieve Shadows", "UseCheckbox", True)
コード例 #4
0
    def add_float_property(self, name, key, value, status=None, enabled=True, *args, **kwargs):
        """
        Add float property.

        :param name: title
        :param key:
        :param value:
        :param status: status bar string
        :param enabled:
        :param args:
        :param kwargs:
        :return:
        """
        item = propgrid.FloatProperty(name, key, value=value)
        self.Append(item)

        if status:
            self.SetPropertyHelpString(key, status)

        if enabled:
            self.EnableProperty(key)
        else:
            self.DisableProperty(key)

        return item
コード例 #5
0
    def getPropertyForType(self, stg, pid, dt):
        if dt == "str":
            pgp = wxpg.StringProperty(pid, value="")

        elif dt == "float":
            pgp = wxpg.FloatProperty(pid, value=0.0)

        elif dt in ["int", "extruder"]:
            pgp = wxpg.IntProperty(pid, value=0)

        elif dt == "bool":
            pgp = wxpg.BoolProperty(pid, value=False)

        elif dt == "enum":
            opts = [str(x) for x in stg.getOptions()]
            pgp = wxpg.EnumProperty(pid,
                                    labels=opts,
                                    values=range(len(opts)),
                                    value=0)

        else:
            self.log("taking default action for unknown data type: %s" % dt)
            pgp = wxpg.StringProperty(pid, value="")

        return pgp
コード例 #6
0
    def itemActivated(self, event):
        self.Clear()
        self.btn.Enable(True)
        sel = event.EventObject.GetFirstSelected()
        self.item = item = self.itemView.items[sel]

        for key in sorted(item.attributes.keys()):
            override = item.overrides.get(key, None)
            default = item.attributes[key].value
            if override and override.value != default:
                prop = wxpg.FloatProperty(key, value=override.value)
                prop.SetModifiedStatus(True)
            else:
                prop = wxpg.FloatProperty(key, value=default)

            prop.SetClientData(item.attributes[key])  # set this so that we may access it later
            prop.SetHelpString("%s\n%s" % (item.attributes[key].displayName or key, "Default Value: %0.3f" % default))
            self.Append(prop)
コード例 #7
0
    def test_propgridiface03(self):
        # Ensure SetPropertyValue doesn't truncate floats
        pgrid = pg.PropertyGrid(self.frame)
        pgrid.Append(pg.FloatProperty('Float', value=123.456))

        value = pgrid.GetPropertyValue('Float')
        assert type(value) is float
        assert value == 123.456

        pgrid.SetPropertyValue('Float', 654.321)
        value = pgrid.GetPropertyValue('Float')
        assert type(value) is float
        assert value == 654.321
コード例 #8
0
    def _create_dummy_content(self):
        # some dummy content from the wxPython demo
        import wx.propgrid as wxpg
        pg = self.widget
        pg.AddPage( "Page 1 - Dummy" )

        pg.Append( wxpg.PropertyCategory("1 - Basic Properties") )
        pg.Append( wxpg.StringProperty("String",value="Some Text") )

        sp = pg.Append( wxpg.StringProperty('StringProperty w/ Password flag', value='ABadPassword') )
        sp.SetAttribute('Hint', 'This is a hint')
        sp.SetAttribute('Password', True)

        pg.Append( wxpg.IntProperty("Int",value=123) )
        pg.Append( wxpg.FloatProperty("Float",value=123.4) )
        pg.Append( wxpg.BoolProperty("Bool",value=True) )
        pg.Append( wxpg.BoolProperty("Bool_with_Checkbox",value=True) )
        pg.SetPropertyAttribute( "Bool_with_Checkbox", "UseCheckbox", True)
        pg.Append( wxpg.PropertyCategory("2 - More Properties") )
        pg.Append( wxpg.LongStringProperty("LongString", value="This is a\nmulti-line string\nwith\ttabs\nmixed\tin."))
        pg.Append( wxpg.DirProperty("Dir",value=r"C:\Windows") )
        pg.Append( wxpg.FileProperty("File",value=r"C:\Windows\system.ini") )
        pg.Append( wxpg.ArrayStringProperty("ArrayString",value=['A','B','C']) )

        pg.Append( wxpg.EnumProperty("Enum","Enum", ['wxPython Rules', 'wxPython Rocks', 'wxPython Is The Best'],
                                                    [10,11,12], 0) )
        pg.Append( wxpg.EditEnumProperty("EditEnum","EditEnumProperty", ['A','B','C'], [0,1,2], "Text Not in List") )

        pg.Append( wxpg.PropertyCategory("3 - Advanced Properties") )
        pg.Append( wxpg.DateProperty("Date",value=wx.DateTime.Now()) )
        pg.Append( wxpg.FontProperty("Font",value=self.widget.GetFont()) )
        pg.Append( wxpg.ColourProperty("Colour", value=self.widget.GetBackgroundColour()) )
        pg.Append( wxpg.SystemColourProperty("SystemColour") )
        pg.Append( wxpg.ImageFileProperty("ImageFile") )
        pg.Append( wxpg.MultiChoiceProperty("MultiChoice", choices=['wxWidgets','QT','GTK+']) )

        pg.Append( wxpg.PropertyCategory("4 - Additional Properties") )
        pg.Append( wxpg.IntProperty("IntWithSpin",value=256) )
        pg.SetPropertyEditor("IntWithSpin","SpinCtrl")

        pg.SetPropertyAttribute( "File", wxpg.PG_FILE_SHOW_FULL_PATH, 0 )
        pg.SetPropertyAttribute( "File", wxpg.PG_FILE_INITIAL_PATH, r"C:\Program Files\Internet Explorer" )
        if compat.IS_PHOENIX:
            pg.SetPropertyAttribute( "Date", wxpg.PG_DATE_PICKER_STYLE, wx.adv.DP_DROPDOWN|wx.adv.DP_SHOWCENTURY )

        pg.AddPage( "Page 2 - Almost Empty" )
        pg.Append( wxpg.PropertyCategory("1 - Basic Properties") )
        pg.Append( wxpg.StringProperty("String 2",value="Some Text") )
コード例 #9
0
    def set_solver(self, solver):
        """Sets current solver and builds UI basing on its properties.

        :param Solver solver: Solver to show properties of.
        """

        # Set the solver
        self.solver = solver

        # Reset the properties
        self.reset()

        # Skip if there is no solver or solver has no properties
        if not self.solver or not self.solver.properties:
            return

        # For each property
        for i, p in enumerate(self.solver.properties):
            # Create property object with appropriate type
            if p.type is int:
                prop = wxpg.IntProperty()
            elif p.type is float:
                prop = wxpg.FloatProperty()
            elif issubclass(p.type, Enum):
                prop = wxpg.EnumProperty()
                labels = list(map(lambda c: c.name, p.type))
                values = list(map(lambda c: c.value, p.type))
                prop_choices = wxpg.PGChoices(labels=labels, values=values)
                prop.SetChoices(prop_choices)

            # Set label and value
            prop.SetLabel(p.name)
            prop.SetValue(p.default)
            prop.SetDefaultValue(p.default)
            prop.SetAttribute('property_idx', i)

            # And append the property object
            self.Append(prop)

        # Fit columns and layout the parent
        self.FitColumns()
        self.GetParent().Layout()
コード例 #10
0
ファイル: HEMyFrame.py プロジェクト: DamirKh/zbv
    def fill_property_grid(self):
        print('Filling property grid')
        pair = self.wxprop_layerconf_pair
        pg = self.property_grid_1
        lc = self.layer_config
        pg.Append(wxpg.PropertyCategory("1 - Basic Properties"))
        if len(lc.keys()):
            for p in lc.keys():
                # print('    property <<%s>>'%p)
                proper = lc[p]   # Конфигурационный объект потомок CommonProp
                value = lc[p]()
                curprop = None
                # p - parametr name
                # value - default value of parametr
                if isinstance(proper, layers_opt.BoolProp):  # дискретный параметр
                    curprop = pg.Append(wxpg.BoolProperty(p, value=value))  # объект wx

                elif isinstance(proper, layers_opt.RealRangeProp):  # вещественный параметр
                    curprop = pg.Append(wxpg.FloatProperty(p, value=value))

                elif isinstance(proper, layers_opt.IntRangeProp):  # целочисленый параметр
                    curprop = pg.Append(wxpg.IntProperty(p, value=value))

                elif isinstance(proper, layers_opt.SelectOneProp): # выбор один из многих
                    choices = wxpg.PGChoices()
                    for choice in proper:
                        choices.Add(label=choice, value=wxpg.PG_INVALID_VALUE)
                    default_coice = choices.GetIndicesForStrings([value,])[0]
                    # print(default_coice)
                    curprop = pg.Append(wxpg.EnumProperty(label=p, name=p, choices=choices))
                    curprop.SetChoiceSelection(default_coice)

                if curprop is not None:
                    curprop.SetHelpString(proper.__doc__)
                    pair[curprop] = proper  # свойство wx, свойство CommonProp
        else: # no properties
            print(' No properties')
            empty_prop = pg.Append(wxpg.StringProperty(label='No editable property', value='May be for a while'))
            empty_prop.SetHelpString('Nothing to tweek here')
            pg.Enable(False)
        print('End of filling property grid')
コード例 #11
0
    def init_view(self, items, para, preview=False, modal=True, app=None):
        self.para, self.modal = para, modal
        self.pg = pg = wxpg.PropertyGridManager(
            self, style=wxpg.PG_SPLITTER_AUTO_CENTER)

        sizer = wx.BoxSizer(wx.VERTICAL)
        # Show help as tooltips
        pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS)
        pg.Bind(wxpg.EVT_PG_CHANGED, self.OnPropGridChange)
        pg.Bind(wxpg.EVT_PG_SELECTED, self.OnPropGridSelect)

        pg.AddPage('')
        for i in items:
            if i[0] == 'lab': pg.Append(wxpg.PropertyCategory(i[2]))
            if i[0] == int:
                pg.Append(wxpg.IntProperty(i[1], value=int(para[i[1]]) or 0))
            if i[0] == float:
                pg.Append(
                    wxpg.FloatProperty(i[1], value=float(para[i[1]]) or 0))
            if i[0] == str:
                pg.Append(wxpg.StringProperty(i[1], value=para[i[1]] or ''))
            if i[0] == 'txt':
                pg.Append(wxpg.LongStringProperty(i[1], value=para[i[1]]
                                                  or ''))
            if i[0] == bool: pg.Append(wxpg.BoolProperty(i[1]))
            if i[0] == 'date':
                pg.Append(wxpg.DateProperty(i[1], value=wx.DateTime.Now()))
            #if i[0] == 'list': pg.Append( wxpg.EnumProperty(i[1], i[1], [i.strip() for i in i[2][1:-1].split(',')]))
            #if i[0] == 'img': pg.Append( wxpg.EnumProperty(v[1], v[1], ['a','b','c']))
            #if i[0] == 'tab': pg.Append( wxpg.EnumProperty(v[1], v[1], ['a','b','c']))

        #if preview:self.add_ctrl_(Check, 'preview', ('preview',), app=app)
        #self.reset(para)
        sizer.Add(pg, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.add_confirm(modal)
        self.Layout()
        self.Fit()
        wx.Dialog.Bind(self, wx.EVT_WINDOW_DESTROY, self.OnDestroy)
        #wx.Dialog.Bind(self, wx.EVT_IDLE, lambda e: self.reset())
        print('bind close')
コード例 #12
0
 def refereshView(self):
     #referesh the grid based on self.confList
     confdir=(_("Configuration File Location"),[(("confDir"),{"desc":_("Configuration Directory"),
         "value":os.path.dirname(self.confPath),"type":"directory"})])
     self.confList.insert(0,confdir)
     for cgroup in self.confList:
         self.grid.Append(wxpg.PropertyCategory(cgroup[0]))
         for conf in cgroup[1]:
             if conf[1]['type']=='directory':
                 self.grid.Append(wxpg.DirProperty(conf[1]['desc'],conf[0],conf[1]['value']))
                 continue
             if conf[1]['type']=='string':
                 self.grid.Append(wxpg.StringProperty(conf[1]['desc'],conf[0],conf[1]['value']))
                 continue
             if conf[1]['type']=='int':
                 self.grid.Append(wxpg.IntProperty(conf[1]['desc'],conf[0],conf[1]['value']))
                 continue
             if conf[1]['type']=='float':
                 self.grid.Append(wxpg.FloatProperty(conf[1]['desc'],conf[0],conf[1]['value']))
                 continue
             if conf[1]['type']=='bool':
                 self.grid.Append(wxpg.BoolProperty(conf[1]['desc'],conf[0],conf[1]['value']))
                 continue
     self.grid.CenterSplitter(False)
コード例 #13
0
    def populatepropgrid(self, pg):
        #Geometry Properties
        pg.Append(wxpg.PropertyCategory("Geometry"))

        minID = pg.Append(wxpg.StringProperty("Minimum", value="<composed>"))
        pg.AppendIn(minID, wxpg.FloatProperty("X", value=self.min[0]))
        pg.AppendIn(minID, wxpg.FloatProperty("Y", value=self.min[1]))
        pg.AppendIn(minID, wxpg.FloatProperty("Z", value=self.min[2]))

        maxID = pg.Append(wxpg.StringProperty("Maximum", value="<composed>"))
        pg.AppendIn(maxID, wxpg.FloatProperty("X", value=self.max[0]))
        pg.AppendIn(maxID, wxpg.FloatProperty("Y", value=self.max[1]))
        pg.AppendIn(maxID, wxpg.FloatProperty("Z", value=self.max[2]))

        #Material Properties
        pg.Append(wxpg.PropertyCategory("Material"))

        pg.Append(wxpg.BoolProperty("Cast Shadows", value=self.cast))
        pg.SetPropertyAttribute("Cast Shadows", "UseCheckbox", True)
コード例 #14
0
 def test_propgridprops06(self):
     p = pg.FloatProperty()
コード例 #15
0
 def color(self, item, name, val):
     c = wx.Colour(val["r"] * 255, val["g"] * 255, val["b"] * 255)
     cp = wxpg.ColourProperty(item["name"], name, value=c)
     cp.AppendChild(wxpg.FloatProperty("alpha", "a", value=val["a"]))
     return cp
コード例 #16
0
    def Remplissage(self):
        listeChampsPiedsPages = [
            "{DATE_JOUR}", "{TITRE_DOCUMENT}", "{NOM_ORGANISATEUR}",
            "{NUM_PAGE}", "{NBRE_PAGES}"
        ]

        # --------------------------- Divers ------------------------------------------
        self.Append(wxpg.PropertyCategory("Divers"))

        # Inclure les images
        propriete = wxpg.BoolProperty(label=INCLURE_IMG_LABEL,
                                      name="inclure_images",
                                      value=True)
        propriete.SetHelpString(INCLURE_IMG_HELP)
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)

        # Entete de colonne sur chaque page
        propriete = wxpg.BoolProperty(label=AFFICHER_ENTETE_LABEL,
                                      name="entetes_toutes_pages",
                                      value=True)
        propriete.SetHelpString(AFFICHER_ENTETE_HELP)
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)

        # Qualité de l'impression
        propriete = wxpg.EnumProperty(label=CHOIX_QUALITE_LABEL,
                                      name="qualite_impression",
                                      labels=CHOIX_QUALITE_LABELS,
                                      values=CHOIX_QUALITE_VALEURS,
                                      value=wx.PRINT_QUALITY_MEDIUM)
        propriete.SetHelpString(CHOIX_QUALITE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Marges ------------------------------------------
        self.Append(wxpg.PropertyCategory("Marges"))

        # Gauche
        propriete = wxpg.IntProperty(label=MARGE_GAUCHE_LABEL,
                                     name="marge_gauche",
                                     value=5)
        propriete.SetHelpString(TAILLE_MARGE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_gauche", "SpinCtrl")

        # Droite
        propriete = wxpg.IntProperty(label=MARGE_DROITE_LABEL,
                                     name="marge_droite",
                                     value=5)
        propriete.SetHelpString(TAILLE_MARGE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_droite", "SpinCtrl")

        # Haut
        propriete = wxpg.IntProperty(label=MARGE_HAUT_LABEL,
                                     name="marge_haut",
                                     value=5)
        propriete.SetHelpString(TAILLE_MARGE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_haut", "SpinCtrl")

        # Bas
        propriete = wxpg.IntProperty(label=MARGE_BAS_LABEL,
                                     name="marge_bas",
                                     value=5)
        propriete.SetHelpString(TAILLE_MARGE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_bas", "SpinCtrl")

        # --------------------------- Quadrillage ------------------------------------------
        self.Append(wxpg.PropertyCategory("Quadrillage"))

        # Epaisseur de trait
        propriete = wxpg.FloatProperty(label=EPAISSEUR_TRAIT_LABEL,
                                       name="grille_trait_epaisseur",
                                       value=0.25)
        propriete.SetHelpString(EPAISSEUR_TRAIT_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de trait
        propriete = wxpg.ColourProperty(label=COULEUR_TRAIT_LABEL,
                                        name="grille_trait_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TRAIT_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Titre de liste ------------------------------------------
        self.Append(wxpg.PropertyCategory("Titre"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="titre_taille_texte",
                                     value=16)
        propriete.SetHelpString(TAILLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("titre_taille_texte", "SpinCtrl")

        # Style
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="titre_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_BOLD)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="titre_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = ["Gauche", "Centre", "Droite"]
        propriete = wxpg.EnumProperty(label=ALIGNEMENT_TEXTE_LABEL,
                                      name="titre_alignement",
                                      labels=ALIGNEMENT_TEXTE_LABELS,
                                      values=ALIGNEMENT_TEXTE_VALUES,
                                      value=wx.ALIGN_LEFT)
        propriete.SetHelpString(ALIGNEMENT_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Intro ------------------------------------------
        self.Append(wxpg.PropertyCategory("Introduction"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="intro_taille_texte",
                                     value=7)
        propriete.SetHelpString(TAILLE_TEXTE_INTRO_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("intro_taille_texte", "SpinCtrl")

        # Style
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="intro_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="intro_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        propriete = wxpg.EnumProperty(label=ALIGNEMENT_TEXTE_LABEL,
                                      name="intro_alignement",
                                      labels=ALIGNEMENT_TEXTE_LABELS,
                                      values=ALIGNEMENT_TEXTE_VALUES,
                                      value=wx.ALIGN_LEFT)
        propriete.SetHelpString(ALIGNEMENT_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Titre de colonne  ------------------------------------------
        self.Append(wxpg.PropertyCategory("Entête de colonne"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="titre_colonne_taille_texte",
                                     value=8)
        propriete.SetHelpString(TAILLE_TEXTE_TITRE_COL_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("titre_colonne_taille_texte", "SpinCtrl")

        #  Style
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="titre_colonne_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="titre_colonne_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        propriete = wxpg.EnumProperty(label=ALIGNEMENT_TEXTE_LABEL,
                                      name="titre_colonne_alignement",
                                      labels=ALIGNEMENT_TEXTE_LABELS,
                                      values=ALIGNEMENT_TEXTE_VALUES,
                                      value=wx.ALIGN_CENTER)
        propriete.SetHelpString(ALIGNEMENT_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de fond
        propriete = wxpg.ColourProperty(label=COULEUR_FOND_LABEL,
                                        name="titre_colonne_couleur_fond",
                                        value=wx.Colour(240, 240, 240))
        propriete.SetHelpString(COULEUR_FOND_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Ligne  ------------------------------------------
        self.Append(wxpg.PropertyCategory("Ligne"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="ligne_taille_texte",
                                     value=8)
        propriete.SetHelpString(TAILLE_TEXTE_LIGNE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("ligne_taille_texte", "SpinCtrl")

        #  Style
        labels = ["Normal", "Light", "Gras"]
        valeurs = [
            wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD
        ]
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="ligne_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="ligne_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Multilignes autorisé
        propriete = wxpg.BoolProperty(label=AUTORISER_SAUT_LIGNE_LABEL,
                                      name="ligne_multilignes",
                                      value=True)
        propriete.SetHelpString(AUTORISER_SAUT_LIGNE_HELP)
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)

        # --------------------------- Pied de page  ------------------------------------------
        self.Append(wxpg.PropertyCategory("Pied de page"))

        # Texte de gauche
        valeur = "{DATE_JOUR}"
        propriete = wxpg.StringProperty(label=PIED_TEXTE_GAUCHE_LABEL,
                                        name="pied_page_texte_gauche",
                                        value=valeur)
        propriete.SetHelpString(
            "Saisissez le texte de gauche du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s"
            % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Texte du milieu
        valeur = "{TITRE_DOCUMENT} - {NOM_ORGANISATEUR}"
        propriete = wxpg.StringProperty(label=PIED_TEXTE_MILIEU_LABEL,
                                        name="pied_page_texte_milieu",
                                        value=valeur)
        propriete.SetHelpString(
            "Saisissez le texte du milieu du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s"
            % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Texte de droite
        valeur = "{NUM_PAGE} / {NBRE_PAGES}"
        propriete = wxpg.StringProperty(label=PIED_TEXTE_DROITE_LABEL,
                                        name="pied_page_texte_droite",
                                        value=valeur)
        propriete.SetHelpString(
            "Saisissez le texte de droite du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s"
            % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="pied_page_taille_texte",
                                     value=8)
        propriete.SetHelpString(TAILLE_TEXTE_PIED_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("pied_page_taille_texte", "SpinCtrl")

        #  Style
        labels = ["Normal", "Light", "Gras"]
        valeurs = [
            wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD
        ]
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="pied_page_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="pied_page_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Pied de colonne  ------------------------------------------
        self.Append(wxpg.PropertyCategory("Pied de colonne"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="pied_colonne_taille_texte",
                                     value=8)
        propriete.SetHelpString(TAILLE_TEXTE_PIED_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("pied_colonne_taille_texte", "SpinCtrl")

        #  Style
        labels = ["Normal", "Light", "Gras"]
        valeurs = [
            wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD
        ]
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="pied_colonne_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="pied_colonne_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = ["Gauche", "Centre", "Droite"]
        propriete = wxpg.EnumProperty(label=ALIGNEMENT_TEXTE_LABEL,
                                      name="pied_colonne_alignement",
                                      labels=ALIGNEMENT_TEXTE_LABELS,
                                      values=ALIGNEMENT_TEXTE_VALUES,
                                      value=wx.ALIGN_CENTER)
        propriete.SetHelpString(ALIGNEMENT_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de fond
        propriete = wxpg.ColourProperty(label=COULEUR_FOND_LABEL,
                                        name="pied_colonne_couleur_fond",
                                        value=wx.Colour(240, 240, 240))
        propriete.SetHelpString(COULEUR_FOND_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Pied de liste ------------------------------------------
        self.Append(wxpg.PropertyCategory("Conclusion"))

        # Taille police
        propriete = wxpg.IntProperty(label=TAILLE_TEXTE_LABEL,
                                     name="conclusion_taille_texte",
                                     value=7)
        propriete.SetHelpString(TAILLE_TEXTE_CONCL_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("conclusion_taille_texte", "SpinCtrl")

        # Style
        propriete = wxpg.EnumProperty(label=STYLE_TEXTE_LABEL,
                                      name="conclusion_style",
                                      labels=STYLE_TEXTE_LABELS,
                                      values=STYLE_TEXTE_VALEURS,
                                      value=wx.FONTWEIGHT_BOLD)
        propriete.SetHelpString(STYLE_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur
        propriete = wxpg.ColourProperty(label=COULEUR_TEXTE_LABEL,
                                        name="conclusion_couleur",
                                        value=wx.BLACK)
        propriete.SetHelpString(COULEUR_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = ["Gauche", "Centre", "Droite"]
        propriete = wxpg.EnumProperty(label=ALIGNEMENT_TEXTE_LABEL,
                                      name="conclusion_alignement",
                                      labels=ALIGNEMENT_TEXTE_LABELS,
                                      values=ALIGNEMENT_TEXTE_VALUES,
                                      value=wx.ALIGN_LEFT)
        propriete.SetHelpString(ALIGNEMENT_TEXTE_HELP)
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
コード例 #17
0
    def Remplissage(self):
        listeChampsPiedsPages = ["{DATE_JOUR}", "{TITRE_DOCUMENT}", "{NUM_PAGE}", "{NBRE_PAGES}"]

        # --------------------------- Divers ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Divers")) )

        # Inclure les images
        propriete = wxpg.BoolProperty(label=_(u"Inclure les images"), name="inclure_images", value=True)
        propriete.SetHelpString(_(u"Cochez cette case pour inclure les images")) 
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)

        # Entete de colonne sur chaque page
        propriete = wxpg.BoolProperty(label=_(u"Afficher les entêtes sur chaque page"), name="entetes_toutes_pages", value=True)
        propriete.SetHelpString(_(u"Cochez cette case pour afficher les entêtes de colonne sur chaque page")) 
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)

        # Qualité de l'impression
        labels = [_(u"Brouillon"), _(u"Basse"), _(u"Moyenne"), _(u"Haute")]
        propriete = wxpg.EnumProperty(label=_(u"Qualité d'impression"), name="qualite_impression", labels=labels, values=[wx.PRINT_QUALITY_DRAFT, wx.PRINT_QUALITY_LOW, wx.PRINT_QUALITY_MEDIUM, wx.PRINT_QUALITY_HIGH] , value=wx.PRINT_QUALITY_MEDIUM)
        propriete.SetHelpString(_(u"Sélectionnez la qualité d'impression (Moyenne par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)


        # --------------------------- Marges ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Marges")) )

        # Gauche
        propriete = wxpg.IntProperty(label=_(u"Gauche"), name="marge_gauche", value=5)
        propriete.SetHelpString(_(u"Saisissez une taille de marge")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_gauche", "SpinCtrl")

        # Droite
        propriete = wxpg.IntProperty(label=_(u"Droite"), name="marge_droite", value=5)
        propriete.SetHelpString(_(u"Saisissez une taille de marge")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_droite", "SpinCtrl")

        # Haut
        propriete = wxpg.IntProperty(label=_(u"Haut"), name="marge_haut", value=5)
        propriete.SetHelpString(_(u"Saisissez une taille de marge")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_haut", "SpinCtrl")

        # Bas
        propriete = wxpg.IntProperty(label=_(u"Bas"), name="marge_bas", value=5)
        propriete.SetHelpString(_(u"Saisissez une taille de marge")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("marge_bas", "SpinCtrl")

        # --------------------------- Quadrillage ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Quadrillage")) )

        # Epaisseur de trait
        propriete = wxpg.FloatProperty(label=_(u"Epaisseur de trait"), name="grille_trait_epaisseur", value=0.25)
        propriete.SetHelpString(_(u"Saisissez une épaisseur de trait (Par défaut '0.25')")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de trait
        propriete = wxpg.ColourProperty(label=_(u"Couleur de trait"), name="grille_trait_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur de trait")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Titre de liste ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Titre")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="titre_taille_texte", value=16)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (16 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("titre_taille_texte", "SpinCtrl")

        # Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="titre_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_BOLD)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="titre_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = [_(u"Gauche"), _(u"Centre"), _(u"Droite")]
        propriete = wxpg.EnumProperty(label=_(u"Alignement du texte"), name="titre_alignement", labels=labels, values=[wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT] , value=wx.ALIGN_LEFT)
        propriete.SetHelpString(_(u"Sélectionnez le type d'alignement")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)


        # --------------------------- Intro ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Introduction")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="intro_taille_texte", value=7)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (7 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("intro_taille_texte", "SpinCtrl")

        # Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="intro_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="intro_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = [_(u"Gauche"), _(u"Centre"), _(u"Droite")]
        propriete = wxpg.EnumProperty(label=_(u"Alignement du texte"), name="intro_alignement", labels=labels, values=[wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT] , value=wx.ALIGN_LEFT)
        propriete.SetHelpString(_(u"Sélectionnez le type d'alignement")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Titre de colonne  ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Entête de colonne")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="titre_colonne_taille_texte", value=8)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (8 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("titre_colonne_taille_texte", "SpinCtrl")

        #  Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="titre_colonne_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="titre_colonne_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = [_(u"Gauche"), _(u"Centre"), _(u"Droite")]
        propriete = wxpg.EnumProperty(label=_(u"Alignement du texte"), name="titre_colonne_alignement", labels=labels, values=[wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT] , value=wx.ALIGN_CENTER)
        propriete.SetHelpString(_(u"Sélectionnez le type d'alignement")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de fond
        propriete = wxpg.ColourProperty(label=_(u"Couleur de fond"), name="titre_colonne_couleur_fond", value=wx.Colour(240, 240, 240))
        propriete.SetHelpString(_(u"Sélectionnez une couleur de fond")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # --------------------------- Ligne  ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Ligne")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="ligne_taille_texte", value=8)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (8 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("ligne_taille_texte", "SpinCtrl")

        #  Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="ligne_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="ligne_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Multilignes autorisé
        propriete = wxpg.BoolProperty(label=_(u"Autoriser saut à la ligne"), name="ligne_multilignes", value=True)
        propriete.SetHelpString(_(u"Cochez cette case pour autoriser le saut à la ligne en cas de colonne trop étroite")) 
        propriete.SetAttribute("UseCheckbox", True)
        self.Append(propriete)


        # --------------------------- Pied de page  ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Pied de page")) )
        
        # Texte de gauche
        valeur = "{DATE_JOUR}"
        propriete = wxpg.StringProperty(label=_(u"Texte de gauche"), name="pied_page_texte_gauche", value=valeur)
        propriete.SetHelpString(_(u"Saisissez le texte de gauche du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s") % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Texte du milieu
        valeur = "{TITRE_DOCUMENT}"
        propriete = wxpg.StringProperty(label=_(u"Texte du milieu"), name="pied_page_texte_milieu", value=valeur)
        propriete.SetHelpString(_(u"Saisissez le texte du milieu du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s") % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Texte de droite
        valeur = "{NUM_PAGE} / {NBRE_PAGES}"
        propriete = wxpg.StringProperty(label=_(u"Texte de droite"), name="pied_page_texte_droite", value=valeur)
        propriete.SetHelpString(_(u"Saisissez le texte de droite du pied de page (Par défaut '%s'). Vous pouvez intégrer les mots-clés suivants : %s") % (valeur, ", ".join(listeChampsPiedsPages)))
        self.Append(propriete)

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="pied_page_taille_texte", value=8)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (8 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("pied_page_taille_texte", "SpinCtrl")

        #  Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="pied_page_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="pied_page_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)


        # --------------------------- Pied de colonne  ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Pied de colonne")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="pied_colonne_taille_texte", value=8)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (8 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("pied_colonne_taille_texte", "SpinCtrl")

        #  Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="pied_colonne_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_NORMAL)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="pied_colonne_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = [_(u"Gauche"), _(u"Centre"), _(u"Droite")]
        propriete = wxpg.EnumProperty(label=_(u"Alignement du texte"), name="pied_colonne_alignement", labels=labels, values=[wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT] , value=wx.ALIGN_CENTER)
        propriete.SetHelpString(_(u"Sélectionnez le type d'alignement")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Couleur de fond
        propriete = wxpg.ColourProperty(label=_(u"Couleur de fond"), name="pied_colonne_couleur_fond", value=wx.Colour(240, 240, 240))
        propriete.SetHelpString(_(u"Sélectionnez une couleur de fond")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)


        # --------------------------- Pied de liste ------------------------------------------
        self.Append( wxpg.PropertyCategory(_(u"Conclusion")) )

        # Taille police
        propriete = wxpg.IntProperty(label=_(u"Taille de texte"), name="conclusion_taille_texte", value=7)
        propriete.SetHelpString(_(u"Saisissez une taille de texte (7 par défaut)")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        self.SetPropertyEditor("conclusion_taille_texte", "SpinCtrl")

        # Style
        labels = [_(u"Normal"), _(u"Light"), "Gras"]
        valeurs = [wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT, wx.FONTWEIGHT_BOLD]
        propriete = wxpg.EnumProperty(label=_(u"Style de texte"), name="conclusion_style", labels=labels, values=valeurs, value=wx.FONTWEIGHT_BOLD)
        propriete.SetHelpString(_(u"Sélectionnez un style de texte")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
        
        # Couleur
        propriete = wxpg.ColourProperty(label=_(u"Couleur de texte"), name="conclusion_couleur", value=wx.BLACK)
        propriete.SetHelpString(_(u"Sélectionnez une couleur")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)

        # Alignement
        labels = [_(u"Gauche"), _(u"Centre"), _(u"Droite")]
        propriete = wxpg.EnumProperty(label=_(u"Alignement du texte"), name="conclusion_alignement", labels=labels, values=[wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT] , value=wx.ALIGN_LEFT)
        propriete.SetHelpString(_(u"Sélectionnez le type d'alignement")) 
        propriete.SetAttribute("obligatoire", True)
        self.Append(propriete)
コード例 #18
0
    def __init__(self, parent, title, tree, key):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           title,
                           style=wx.DEFAULT_DIALOG_STYLE,
                           size=wx.Size((300, 480)))
        # wx.Panel.__init__(self, parent, wx.ID_ANY)
        self.app = parent

        self.panel = panel = wx.Panel(self, wx.ID_ANY)
        topsizer = wx.BoxSizer(wx.VERTICAL)

        # Difference between using PropertyGridManager vs PropertyGrid is that
        # the manager supports multiple pages and a description box.
        self.pg = pg = wxpg.PropertyGridManager(
            panel, style=wxpg.PG_SPLITTER_AUTO_CENTER)

        # Show help as tooltips
        pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS)

        pg.Bind(wxpg.EVT_PG_CHANGED, self.OnPropGridChange)
        pg.Bind(wxpg.EVT_PG_SELECTED, self.OnPropGridSelect)

        pg.AddPage('Page 1')
        self.key = key
        for page in tree:
            pg.Append(wxpg.PropertyCategory(page[0]))
            for item in page[1]:
                v = item[1]
                if v[0] == 'int':
                    pg.Append(wxpg.IntProperty(v[1], value=int(v[2]) or 0))
                if v[0] == 'float':
                    pg.Append(wxpg.FloatProperty(v[1], value=float(v[2]) or 0))
                if v[0] == 'str':
                    pg.Append(wxpg.StringProperty(v[1], value=v[2] or ''))
                if v[0] == 'txt':
                    pg.Append(wxpg.LongStringProperty(v[1], value=v[2] or ''))
                if v[0] == 'bool': pg.Append(wxpg.BoolProperty(v[1]))
                if v[0] == 'date':
                    pg.Append(wxpg.DateProperty(v[1], value=wx.DateTime.Now()))
                if v[0] == 'list':
                    pg.Append(
                        wxpg.EnumProperty(
                            v[1], v[1],
                            [i.strip() for i in v[2][1:-1].split(',')]))
                if v[0] == 'img':
                    pg.Append(
                        wxpg.EnumProperty(v[1], v[1], self.app.img_names()))
                if v[0] == 'tab':
                    pg.Append(
                        wxpg.EnumProperty(v[1], v[1], self.app.table_names()))

        topsizer.Add(pg, 1, wx.EXPAND)
        self.txt_info = wx.TextCtrl(self, wx.ID_ANY, 'information',
                                    wx.DefaultPosition, wx.Size(80, 80),
                                    wx.TE_MULTILINE | wx.TRANSPARENT_WINDOW)
        topsizer.Add(self.txt_info, 0, wx.EXPAND | wx.ALL, 0)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(panel, wx.ID_OK, "OK")
        rowsizer.Add(but, 1)
        #but.Bind( wx.EVT_BUTTON, self.OnGetPropertyValues )
        but = wx.Button(panel, wx.ID_CANCEL, "Cancel")
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)

        panel.SetSizer(topsizer)
        topsizer.SetSizeHints(panel)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetAutoLayout(True)
コード例 #19
0
ファイル: PropertyGrid.py プロジェクト: masatoikuras8/Phoenix
    def __init__(self, parent, log):
        wx.Panel.__init__(self, parent, wx.ID_ANY)
        self.log = log

        self.panel = panel = wx.Panel(self, wx.ID_ANY)
        topsizer = wx.BoxSizer(wx.VERTICAL)

        # Difference between using PropertyGridManager vs PropertyGrid is that
        # the manager supports multiple pages and a description box.
        self.pg = pg = wxpg.PropertyGridManager(
            panel,
            style=wxpg.PG_SPLITTER_AUTO_CENTER | wxpg.PG_AUTO_SORT
            | wxpg.PG_TOOLBAR)

        # Show help as tooltips
        pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS)

        pg.Bind(wxpg.EVT_PG_CHANGED, self.OnPropGridChange)
        pg.Bind(wxpg.EVT_PG_PAGE_CHANGED, self.OnPropGridPageChange)
        pg.Bind(wxpg.EVT_PG_SELECTED, self.OnPropGridSelect)
        pg.Bind(wxpg.EVT_PG_RIGHT_CLICK, self.OnPropGridRightClick)

        #
        # Let's use some simple custom editor
        #
        # NOTE: Editor must be registered *before* adding a property that
        # uses it.
        if not getattr(sys, '_PropGridEditorsRegistered', False):
            pg.RegisterEditor(TrivialPropertyEditor)
            pg.RegisterEditor(SampleMultiButtonEditor)
            pg.RegisterEditor(LargeImageEditor)
            # ensure we only do it once
            sys._PropGridEditorsRegistered = True

        #
        # Add properties
        #

        pg.AddPage("Page 1 - Testing All")

        pg.Append(wxpg.PropertyCategory("1 - Basic Properties"))
        pg.Append(wxpg.StringProperty("String", value="Some Text"))

        sp = pg.Append(
            wxpg.StringProperty('StringProperty w/ Password flag',
                                value='ABadPassword'))
        sp.SetAttribute('Hint', 'This is a hint')
        sp.SetAttribute('Password', True)

        pg.Append(wxpg.IntProperty("Int", value=100))
        pg.Append(wxpg.FloatProperty("Float", value=100.0))
        pg.Append(wxpg.BoolProperty("Bool", value=True))
        boolprop = pg.Append(
            wxpg.BoolProperty("Bool_with_Checkbox", value=True))
        pg.SetPropertyAttribute(
            "Bool_with_Checkbox",  # You can find the property by name,
            #boolprop,               # or give the property object itself.
            "UseCheckbox",
            True)  # The attribute name and value

        pg.Append(wxpg.PropertyCategory("2 - More Properties"))
        pg.Append(
            wxpg.LongStringProperty(
                "LongString",
                value="This is a\nmulti-line string\nwith\ttabs\nmixed\tin."))
        pg.Append(wxpg.DirProperty("Dir", value=r"C:\Windows"))
        pg.Append(wxpg.FileProperty("File", value=r"C:\Windows\system.ini"))
        pg.Append(
            wxpg.ArrayStringProperty("ArrayString", value=['A', 'B', 'C']))

        pg.Append(
            wxpg.EnumProperty(
                "Enum", "Enum",
                ['wxPython Rules', 'wxPython Rocks', 'wxPython Is The Best'],
                [10, 11, 12], 0))
        pg.Append(
            wxpg.EditEnumProperty("EditEnum", "EditEnumProperty",
                                  ['A', 'B', 'C'], [0, 1, 2],
                                  "Text Not in List"))

        pg.Append(wxpg.PropertyCategory("3 - Advanced Properties"))
        pg.Append(wxpg.DateProperty("Date", value=wx.DateTime.Now()))
        pg.Append(wxpg.FontProperty("Font", value=panel.GetFont()))
        pg.Append(
            wxpg.ColourProperty("Colour", value=panel.GetBackgroundColour()))
        pg.Append(wxpg.SystemColourProperty("SystemColour"))
        pg.Append(wxpg.ImageFileProperty("ImageFile"))
        pg.Append(
            wxpg.MultiChoiceProperty("MultiChoice",
                                     choices=['wxWidgets', 'QT', 'GTK+']))

        pg.Append(wxpg.PropertyCategory("4 - Additional Properties"))
        #pg.Append( wxpg.PointProperty("Point",value=panel.GetPosition()) )
        pg.Append(SizeProperty("Size", value=panel.GetSize()))
        #pg.Append( wxpg.FontDataProperty("FontData") )
        pg.Append(wxpg.IntProperty("IntWithSpin", value=256))
        pg.SetPropertyEditor("IntWithSpin", "SpinCtrl")

        pg.SetPropertyAttribute("File", wxpg.PG_FILE_SHOW_FULL_PATH, 0)
        pg.SetPropertyAttribute("File", wxpg.PG_FILE_INITIAL_PATH,
                                r"C:\Program Files\Internet Explorer")
        pg.SetPropertyAttribute("Date", wxpg.PG_DATE_PICKER_STYLE,
                                wx.adv.DP_DROPDOWN | wx.adv.DP_SHOWCENTURY)

        pg.Append(wxpg.PropertyCategory("5 - Custom Properties and Editors"))
        pg.Append(IntProperty2("IntProperty2", value=1024))

        pg.Append(PyObjectProperty("PyObjectProperty"))

        pg.Append(DirsProperty("Dirs1", value=['C:/Lib', 'C:/Bin']))
        pg.Append(DirsProperty("Dirs2", value=['/lib', '/bin']))

        # Test another type of delimiter
        pg.SetPropertyAttribute("Dirs2", "Delimiter", '"')

        # SampleMultiButtonEditor
        pg.Append(wxpg.LongStringProperty("MultipleButtons"))
        pg.SetPropertyEditor("MultipleButtons", "SampleMultiButtonEditor")
        pg.Append(SingleChoiceProperty("SingleChoiceProperty"))

        # Custom editor samples
        prop = pg.Append(
            wxpg.StringProperty("StringWithCustomEditor", value="test value"))
        pg.SetPropertyEditor(prop, "TrivialPropertyEditor")

        pg.Append(wxpg.ImageFileProperty("ImageFileWithLargeEditor"))
        pg.SetPropertyEditor("ImageFileWithLargeEditor", "LargeImageEditor")

        # When page is added, it will become the target page for AutoFill
        # calls (and for other property insertion methods as well)
        pg.AddPage("Page 2 - Results of AutoFill will appear here")

        topsizer.Add(pg, 1, wx.EXPAND)

        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(panel, -1, "SetPropertyValues")
        but.Bind(wx.EVT_BUTTON, self.OnSetPropertyValues)
        rowsizer.Add(but, 1)
        but = wx.Button(panel, -1, "GetPropertyValues")
        but.Bind(wx.EVT_BUTTON, self.OnGetPropertyValues)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(panel, -1, "GetPropertyValues(as_strings=True)")
        but.Bind(wx.EVT_BUTTON, self.OnGetPropertyValues2)
        rowsizer.Add(but, 1)
        but = wx.Button(panel, -1, "AutoFill")
        but.Bind(wx.EVT_BUTTON, self.OnAutoFill)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(panel, -1, "Delete")
        but.Bind(wx.EVT_BUTTON, self.OnDeleteProperty)
        rowsizer.Add(but, 1)
        but = wx.Button(panel, -1, "Run Tests")
        but.Bind(wx.EVT_BUTTON, self.RunTests)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)

        panel.SetSizer(topsizer)
        topsizer.SetSizeHints(panel)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetAutoLayout(True)
コード例 #20
0
	def __init__( self, parent ):
		wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = wx.EmptyString, pos = wx.DefaultPosition, size = wx.Size( -1,630 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )
		
		self.SetSizeHintsSz( wx.Size( 695,630 ), wx.DefaultSize )
		
		bSizer_csc_mainPanel = wx.BoxSizer( wx.VERTICAL )
		
		self.m_listbook_menu = wx.Listbook( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LB_DEFAULT|wx.RAISED_BORDER )
		m_listbook_menuImageSize = wx.Size( 64,64 )
		m_listbook_menuIndex = 0
		m_listbook_menuImages = wx.ImageList( m_listbook_menuImageSize.GetWidth(), m_listbook_menuImageSize.GetHeight() )
		self.m_listbook_menu.AssignImageList( m_listbook_menuImages )
		self.m_panel_csc = wx.Panel( self.m_listbook_menu, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		bSizer_csc = wx.BoxSizer( wx.VERTICAL )
		
		self.m_notebook_csc = wx.Notebook( self.m_panel_csc, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_panel_csc1 = wx.Panel( self.m_notebook_csc, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		bSizer_csc1 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_grid_csc1 = wx.grid.Grid( self.m_panel_csc1, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
		
		# Grid
		self.m_grid_csc1.CreateGrid( 30, 5 )
		self.m_grid_csc1.EnableEditing( False )
		self.m_grid_csc1.EnableGridLines( True )
		self.m_grid_csc1.EnableDragGridSize( False )
		self.m_grid_csc1.SetMargins( 0, 0 )
		
		# Columns
		self.m_grid_csc1.EnableDragColMove( False )
		self.m_grid_csc1.EnableDragColSize( True )
		self.m_grid_csc1.SetColLabelSize( 30 )
		self.m_grid_csc1.SetColLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Rows
		self.m_grid_csc1.EnableDragRowSize( True )
		self.m_grid_csc1.SetRowLabelSize( 80 )
		self.m_grid_csc1.SetRowLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Label Appearance
		
		# Cell Defaults
		self.m_grid_csc1.SetDefaultCellAlignment( wx.ALIGN_LEFT, wx.ALIGN_TOP )
		bSizer_csc1.Add( self.m_grid_csc1, 0, wx.ALL|wx.EXPAND, 5 )
		
		
		self.m_panel_csc1.SetSizer( bSizer_csc1 )
		self.m_panel_csc1.Layout()
		bSizer_csc1.Fit( self.m_panel_csc1 )
		self.m_notebook_csc.AddPage( self.m_panel_csc1, u"CSC1", True )
		self.m_panel_csc2 = wx.Panel( self.m_notebook_csc, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		bSizer_csc2 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_grid_csc2 = wx.grid.Grid( self.m_panel_csc2, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
		
		# Grid
		self.m_grid_csc2.CreateGrid( 30, 5 )
		self.m_grid_csc2.EnableEditing( True )
		self.m_grid_csc2.EnableGridLines( True )
		self.m_grid_csc2.EnableDragGridSize( False )
		self.m_grid_csc2.SetMargins( 0, 0 )
		
		# Columns
		self.m_grid_csc2.EnableDragColMove( False )
		self.m_grid_csc2.EnableDragColSize( True )
		self.m_grid_csc2.SetColLabelSize( 30 )
		self.m_grid_csc2.SetColLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Rows
		self.m_grid_csc2.EnableDragRowSize( True )
		self.m_grid_csc2.SetRowLabelSize( 80 )
		self.m_grid_csc2.SetRowLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Label Appearance
		
		# Cell Defaults
		self.m_grid_csc2.SetDefaultCellAlignment( wx.ALIGN_LEFT, wx.ALIGN_TOP )
		bSizer_csc2.Add( self.m_grid_csc2, 0, wx.ALL|wx.EXPAND, 5 )
		
		
		self.m_panel_csc2.SetSizer( bSizer_csc2 )
		self.m_panel_csc2.Layout()
		bSizer_csc2.Fit( self.m_panel_csc2 )
		self.m_notebook_csc.AddPage( self.m_panel_csc2, u"CSC2", False )
		self.m_panel_csc3 = wx.Panel( self.m_notebook_csc, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		bSizer_csc3 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_grid_csc3 = wx.grid.Grid( self.m_panel_csc3, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
		
		# Grid
		self.m_grid_csc3.CreateGrid( 30, 5 )
		self.m_grid_csc3.EnableEditing( True )
		self.m_grid_csc3.EnableGridLines( True )
		self.m_grid_csc3.EnableDragGridSize( False )
		self.m_grid_csc3.SetMargins( 0, 0 )
		
		# Columns
		self.m_grid_csc3.EnableDragColMove( False )
		self.m_grid_csc3.EnableDragColSize( True )
		self.m_grid_csc3.SetColLabelSize( 30 )
		self.m_grid_csc3.SetColLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Rows
		self.m_grid_csc3.EnableDragRowSize( True )
		self.m_grid_csc3.SetRowLabelSize( 80 )
		self.m_grid_csc3.SetRowLabelAlignment( wx.ALIGN_CENTRE, wx.ALIGN_CENTRE )
		
		# Label Appearance
		
		# Cell Defaults
		self.m_grid_csc3.SetDefaultCellAlignment( wx.ALIGN_LEFT, wx.ALIGN_TOP )
		bSizer_csc3.Add( self.m_grid_csc3, 0, wx.ALL|wx.EXPAND, 5 )
		
		
		self.m_panel_csc3.SetSizer( bSizer_csc3 )
		self.m_panel_csc3.Layout()
		bSizer_csc3.Fit( self.m_panel_csc3 )
		self.m_notebook_csc.AddPage( self.m_panel_csc3, u"CSC3", False )
		
		bSizer_csc.Add( self.m_notebook_csc, 1, wx.EXPAND |wx.ALL, 5 )
		
		
		self.m_panel_csc.SetSizer( bSizer_csc )
		self.m_panel_csc.Layout()
		bSizer_csc.Fit( self.m_panel_csc )
		self.m_listbook_menu.AddPage( self.m_panel_csc, u"CSC", False )
		m_listbook_menuBitmap = wx.Bitmap( u"src/1.png", wx.BITMAP_TYPE_ANY )
		if ( m_listbook_menuBitmap.Ok() ):
			m_listbook_menuImages.Add( m_listbook_menuBitmap )
			self.m_listbook_menu.SetPageImage( m_listbook_menuIndex, m_listbook_menuIndex )
			m_listbook_menuIndex += 1
		
		self.m_panel_bms = wx.Panel( self.m_listbook_menu, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		bSizer_bms = wx.BoxSizer( wx.VERTICAL )
		
		bSizer38 = wx.BoxSizer( wx.VERTICAL )
		
		bSizer38.SetMinSize( wx.Size( -1,205 ) ) 
		self.m_propertyGridManager1 = pg.PropertyGridManager(self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.Size( -1,-1 ), wx.propgrid.PGMAN_DEFAULT_STYLE|wx.propgrid.PG_SPLITTER_AUTO_CENTER)
		self.m_propertyGridManager1.Enable( False )
		
		
		self.m_propertyGridPage1 = self.m_propertyGridManager1.AddPage( u"Page", wx.NullBitmap );
		self.m_propertyGridItem1 = self.m_propertyGridPage1.Append( pg.StringProperty( u"Battery State", u"Battery State" ) ) 
		self.m_propertyGridItem9 = self.m_propertyGridPage1.Append( pg.FloatProperty( u"Voltage(V)", u"Voltage(V)" ) ) 
		self.m_propertyGridItem2 = self.m_propertyGridPage1.Append( pg.FloatProperty( u"Current(A)", u"Current(A)" ) ) 
		self.m_propertyGridItem3 = self.m_propertyGridPage1.Append( pg.IntProperty( u"Nominal Capacity(Ah)", u"Nominal Capacity(Ah)" ) ) 
		self.m_propertyGridItem4 = self.m_propertyGridPage1.Append( pg.FloatProperty( u"Current Capacity(KWh)", u"Current Capacity(KWh)" ) ) 
		self.m_propertyGridItem5 = self.m_propertyGridPage1.Append( pg.FloatProperty( u"SOC(%)", u"SOC(%)" ) ) 
		self.m_propertyGridItem6 = self.m_propertyGridPage1.Append( pg.IntProperty( u"SOH(%)", u"SOH(%)" ) ) 
		self.m_propertyGridItem7 = self.m_propertyGridPage1.Append( pg.StringProperty( u"Pack SN.", u"Pack SN." ) ) 
		self.m_propertyGridItem8 = self.m_propertyGridPage1.Append( pg.StringProperty( u"Version", u"Version" ) ) 
		bSizer38.Add( self.m_propertyGridManager1, 1, wx.EXPAND, 5 )
		
		
		bSizer_bms.Add( bSizer38, 0, wx.EXPAND, 5 )
		
		
		bSizer_bms.AddSpacer( ( 0, 0), 1, wx.EXPAND, 5 )
		
		self.m_staticline1 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline1, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_staticText1 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"***** Error/Warning Status *****", wx.DefaultPosition, wx.DefaultSize, wx.ALIGN_CENTRE )
		self.m_staticText1.Wrap( -1 )
		bSizer_bms.Add( self.m_staticText1, 0, wx.EXPAND, 5 )
		
		self.m_staticline2 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline2, 0, wx.EXPAND |wx.ALL, 5 )
		
		bSizer11 = wx.BoxSizer( wx.HORIZONTAL )
		
		bSizer12 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText2 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"MainPosRelay", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText2.Wrap( -1 )
		bSizer12.Add( self.m_staticText2, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline12 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer12.Add( self.m_staticline12, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_bitmap1 = wx.StaticBitmap( self.m_panel_bms, wx.ID_ANY, wx.Bitmap( u"src/11.png", wx.BITMAP_TYPE_ANY ), wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer12.Add( self.m_bitmap1, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer11.Add( bSizer12, 1, wx.EXPAND, 5 )
		
		bSizer13 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText3 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"MainNegRelay", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText3.Wrap( -1 )
		bSizer13.Add( self.m_staticText3, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline13 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer13.Add( self.m_staticline13, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_bitmap2 = wx.StaticBitmap( self.m_panel_bms, wx.ID_ANY, wx.Bitmap( u"src/11.png", wx.BITMAP_TYPE_ANY ), wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer13.Add( self.m_bitmap2, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer11.Add( bSizer13, 1, wx.EXPAND, 5 )
		
		self.m_staticline9 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_VERTICAL )
		bSizer11.Add( self.m_staticline9, 0, wx.EXPAND |wx.ALL, 5 )
		
		bSizer14 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText4 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"ISO Normal", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText4.Wrap( -1 )
		bSizer14.Add( self.m_staticText4, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline21 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer14.Add( self.m_staticline21, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_bitmap3 = wx.StaticBitmap( self.m_panel_bms, wx.ID_ANY, wx.Bitmap( u"src/11.png", wx.BITMAP_TYPE_ANY ), wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer14.Add( self.m_bitmap3, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer11.Add( bSizer14, 1, wx.EXPAND, 5 )
		
		bSizer141 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText41 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"ISO Warning", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText41.Wrap( -1 )
		bSizer141.Add( self.m_staticText41, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline22 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer141.Add( self.m_staticline22, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_bitmap31 = wx.StaticBitmap( self.m_panel_bms, wx.ID_ANY, wx.Bitmap( u"src/11.png", wx.BITMAP_TYPE_ANY ), wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer141.Add( self.m_bitmap31, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer11.Add( bSizer141, 1, wx.EXPAND, 5 )
		
		bSizer142 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText42 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"ISO Error", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText42.Wrap( -1 )
		bSizer142.Add( self.m_staticText42, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline23 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer142.Add( self.m_staticline23, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_bitmap32 = wx.StaticBitmap( self.m_panel_bms, wx.ID_ANY, wx.Bitmap( u"src/11.png", wx.BITMAP_TYPE_ANY ), wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer142.Add( self.m_bitmap32, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer11.Add( bSizer142, 1, wx.EXPAND, 5 )
		
		
		bSizer_bms.Add( bSizer11, 0, wx.EXPAND, 5 )
		
		self.m_staticline30 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline30, 0, wx.EXPAND |wx.ALL, 5 )
		
		
		bSizer_bms.AddSpacer( ( 0, 0), 1, wx.EXPAND, 5 )
		
		self.m_staticline3 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline3, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_staticText5 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"***** User Control Area *****", wx.DefaultPosition, wx.DefaultSize, wx.ALIGN_CENTRE )
		self.m_staticText5.Wrap( -1 )
		bSizer_bms.Add( self.m_staticText5, 0, wx.EXPAND, 5 )
		
		self.m_staticline4 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline4, 0, wx.EXPAND |wx.ALL, 5 )
		
		bSizer15 = wx.BoxSizer( wx.HORIZONTAL )
		
		bSizer37 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText25 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"User Name", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText25.Wrap( -1 )
		bSizer37.Add( self.m_staticText25, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_textCtrl2 = wx.TextCtrl( self.m_panel_bms, wx.ID_ANY, u"admin", wx.DefaultPosition, wx.DefaultSize, 0 )
		bSizer37.Add( self.m_textCtrl2, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline25 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer37.Add( self.m_staticline25, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_staticText26 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"Password", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText26.Wrap( -1 )
		bSizer37.Add( self.m_staticText26, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_textCtrl1 = wx.TextCtrl( self.m_panel_bms, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.DefaultSize, wx.TE_PASSWORD|wx.TE_PROCESS_ENTER )
		bSizer37.Add( self.m_textCtrl1, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer15.Add( bSizer37, 1, wx.EXPAND, 5 )
		
		self.m_staticline27 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_VERTICAL )
		bSizer15.Add( self.m_staticline27, 0, wx.EXPAND |wx.ALL, 5 )
		
		bSizer36 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText21 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"Close Time", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText21.Wrap( -1 )
		bSizer36.Add( self.m_staticText21, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticText14 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"00:00:00", wx.DefaultPosition, wx.Size( -1,25 ), 0 )
		self.m_staticText14.Wrap( -1 )
		bSizer36.Add( self.m_staticText14, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline24 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer36.Add( self.m_staticline24, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_staticText22 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"MainRelay", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText22.Wrap( -1 )
		bSizer36.Add( self.m_staticText22, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_button14 = wx.Button( self.m_panel_bms, wx.ID_ANY, u"Close", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_button14.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_HIGHLIGHT ) )
		self.m_button14.Enable( False )
		
		bSizer36.Add( self.m_button14, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer15.Add( bSizer36, 1, wx.EXPAND, 5 )
		
		self.m_staticline28 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_VERTICAL )
		bSizer15.Add( self.m_staticline28, 0, wx.EXPAND |wx.ALL, 5 )
		
		bSizer35 = wx.BoxSizer( wx.VERTICAL )
		
		self.m_staticText23 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"Open(Cur<1A)", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText23.Wrap( -1 )
		bSizer35.Add( self.m_staticText23, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_button10 = wx.Button( self.m_panel_bms, wx.ID_ANY, u"Open", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_button10.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_HIGHLIGHT ) )
		
		bSizer35.Add( self.m_button10, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_staticline26 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer35.Add( self.m_staticline26, 0, wx.EXPAND |wx.ALL, 5 )
		
		self.m_staticText24 = wx.StaticText( self.m_panel_bms, wx.ID_ANY, u"EmergencyOpen", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_staticText24.Wrap( -1 )
		bSizer35.Add( self.m_staticText24, 0, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		self.m_button11 = wx.Button( self.m_panel_bms, wx.ID_ANY, u"SOS Open", wx.DefaultPosition, wx.DefaultSize, 0 )
		self.m_button11.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_HIGHLIGHT ) )
		self.m_button11.SetMinSize( wx.Size( 140,50 ) )
		
		bSizer35.Add( self.m_button11, 1, wx.ALIGN_CENTER|wx.ALL, 5 )
		
		
		bSizer15.Add( bSizer35, 1, wx.EXPAND, 5 )
		
		self.m_staticline31 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer15.Add( self.m_staticline31, 0, wx.EXPAND |wx.ALL, 5 )
		
		
		bSizer_bms.Add( bSizer15, 0, wx.EXPAND, 5 )
		
		self.m_staticline32 = wx.StaticLine( self.m_panel_bms, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL )
		bSizer_bms.Add( self.m_staticline32, 0, wx.EXPAND |wx.ALL, 5 )
		
		
		bSizer_bms.AddSpacer( ( 0, 0), 1, wx.EXPAND, 5 )
		
		
		self.m_panel_bms.SetSizer( bSizer_bms )
		self.m_panel_bms.Layout()
		bSizer_bms.Fit( self.m_panel_bms )
		self.m_listbook_menu.AddPage( self.m_panel_bms, u"BMS", True )
		m_listbook_menuBitmap = wx.Bitmap( u"src/2.png", wx.BITMAP_TYPE_ANY )
		if ( m_listbook_menuBitmap.Ok() ):
			m_listbook_menuImages.Add( m_listbook_menuBitmap )
			self.m_listbook_menu.SetPageImage( m_listbook_menuIndex, m_listbook_menuIndex )
			m_listbook_menuIndex += 1
		
		self.m_panel_car = wx.Panel( self.m_listbook_menu, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		self.m_listbook_menu.AddPage( self.m_panel_car, u"Car", False )
		m_listbook_menuBitmap = wx.Bitmap( u"src/3.png", wx.BITMAP_TYPE_ANY )
		if ( m_listbook_menuBitmap.Ok() ):
			m_listbook_menuImages.Add( m_listbook_menuBitmap )
			self.m_listbook_menu.SetPageImage( m_listbook_menuIndex, m_listbook_menuIndex )
			m_listbook_menuIndex += 1
		
		self.m_panel_setting = wx.Panel( self.m_listbook_menu, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		self.m_listbook_menu.AddPage( self.m_panel_setting, u"Setting", False )
		m_listbook_menuBitmap = wx.Bitmap( u"src/4.png", wx.BITMAP_TYPE_ANY )
		if ( m_listbook_menuBitmap.Ok() ):
			m_listbook_menuImages.Add( m_listbook_menuBitmap )
			self.m_listbook_menu.SetPageImage( m_listbook_menuIndex, m_listbook_menuIndex )
			m_listbook_menuIndex += 1
		
		self.m_panel_diag = wx.Panel( self.m_listbook_menu, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
		self.m_listbook_menu.AddPage( self.m_panel_diag, u"Diag", False )
		m_listbook_menuBitmap = wx.Bitmap( u"src/5.png", wx.BITMAP_TYPE_ANY )
		if ( m_listbook_menuBitmap.Ok() ):
			m_listbook_menuImages.Add( m_listbook_menuBitmap )
			self.m_listbook_menu.SetPageImage( m_listbook_menuIndex, m_listbook_menuIndex )
			m_listbook_menuIndex += 1
		
		
		bSizer_csc_mainPanel.Add( self.m_listbook_menu, 1, wx.EXPAND, 5 )
		
		
		self.SetSizer( bSizer_csc_mainPanel )
		self.Layout()
		self.m_statusBar1 = self.CreateStatusBar( 1, wx.ST_SIZEGRIP, wx.ID_ANY )
		
		self.Centre( wx.BOTH )
		
		# Connect Events
		self.m_listbook_menu.Bind( wx.EVT_LISTBOOK_PAGE_CHANGED, self.funcMenuChanged )
		self.m_listbook_menu.Bind( wx.EVT_LISTBOOK_PAGE_CHANGING, self.funcMenuChanging )
		self.m_notebook_csc.Bind( wx.EVT_NOTEBOOK_PAGE_CHANGED, self.cscPageChanged )
		self.m_notebook_csc.Bind( wx.EVT_NOTEBOOK_PAGE_CHANGING, self.cscPageChanging )
		self.m_textCtrl1.Bind( wx.EVT_TEXT_ENTER, self.passwordInputFinished )
		self.m_button14.Bind( wx.EVT_BUTTON, self.closeMainRelay )
		self.m_button10.Bind( wx.EVT_BUTTON, self.openMainRelay )
		self.m_button11.Bind( wx.EVT_BUTTON, self.openMainRelayEmergency )
コード例 #21
0
ファイル: ImageInfo.py プロジェクト: thewtex/MicroView
    def UpdateHeaderValues(self):

        # clear the existing general page
        self._general_page.Clear()

        # get main frame widget - abort if something goes wrong
        # for instance - handle case where all tabs are closed
        try:

            try:
                image = component.getUtility(ICurrentImage)
            except component.ComponentLookupError:
                # no image is loaded
                return

            header = image.GetHeader().copy()
            dicom_header = image.GetDICOMHeader()
            pageState = component.getUtility(
                ICurrentViewportManager).GetPageState()
        except:
            logging.exception("ImageInfo")
            return

        # if page isn't an image, get out of here early
        if pageState.GetPageType() != "image":
            return

        # remove hidden properties

        # Update all text fields in the dialog box
        # Title
        val = dicom_header.PatientsName
        if isinstance(val, list):
            val = '\\'.join(val)

        properties = {
            'Image Properties': [],
            'Patient/Subject Info': [],
            'Scan Properties': [],
            'Reconstruction Properties': [],
            "Display Properties": [],
            'Additional Properties': []
        }

        prop = Property("Image Properties", "Number of Channels",
                        image.GetNumberOfScalarComponents(), int, True)
        properties[prop.category].append(prop)

        spacing = image.GetSpacing()
        origin = image.GetOrigin()
        (SizeX, SizeY, SizeZ) = image.GetDimensions()
        _range = image.GetScalarRange()
        _size = SizeX * SizeY * SizeZ * image.GetScalarSize(
        ) * image.GetNumberOfScalarComponents()

        prop = Property("Image Properties", "Minimum Value", float(_range[0]),
                        float, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Maximum Value", float(_range[1]),
                        float, True)
        properties[prop.category].append(prop)

        prop = Property(
            "Image Properties", "Voxel Size (mm)",
            "%.4F %.4F %.4F" % (spacing[0], spacing[1], spacing[2]), str, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Image Origin (mm)",
                        "%.4F %.4F %.4F" % (origin[0], origin[1], origin[2]),
                        str, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Image Bit-depth",
                        int(image.GetScalarSize() * 8), int, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Image Data Type",
                        image.GetScalarTypeAsString(), str, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Dimensions",
                        "%d %d %d" % (SizeX, SizeY, SizeZ), str, True)
        properties[prop.category].append(prop)

        prop = Property("Image Properties", "Memory Required",
                        self.sizeof_fmt(_size), str, True)
        properties[prop.category].append(prop)

        prop = Property("Patient/Subject Info", "Title",
                        str(val).encode('utf-8'), str, False)
        properties[prop.category].append(prop)

        val = dicom_header.SeriesDescription
        prop = Property("Patient/Subject Info", "Subject",
                        str(val).encode('utf-8'), str, False)
        properties[prop.category].append(prop)

        if 'PatientPosition' in dicom_header:
            pos = dicom_header.PatientPosition
        else:
            pos = ''

        if pos in self.patient_positions:
            index = self.patient_positions.keys().index(pos)
        else:
            index = 0

        prop = Property("Patient/Subject Info", "Patient Position", index,
                        self.patient_positions.values(), False)
        properties[prop.category].append(prop)

        # Modality
        modality = dicom_header.Modality

        if modality in self.modtostring:
            index = self.modtostring.keys().index(modality)
        else:
            index = 0

        prop = Property("Scan Properties", "Modality", index,
                        self.modtostring.values(), False)
        properties[prop.category].append(prop)

        try:
            _d = image.GetDate()  # DICOM-style date
            dmy = None
            try:
                year, month, day = int(_d[0:4]), int(_d[4:6]), int(_d[6:8])
            except:
                logging.error("Unable to parse DICOM date: {0}".format(_d))
            _t = image.GetTime()  # DICOM_style time
            try:
                hour, minute, second, microsecond = int(_t[0:2]), int(
                    _t[2:4]), int(_t[4:6]), _t[6:]
                dmy = (day, month - 1, year)
            except:
                logging.error("Unable to parse DICOM time: {0}".format(_t))

            if dmy:
                prop = Property("Scan Properties", "Date",
                                wx.DateTimeFromDMY(*dmy), wx.DateTime, False)
                properties[prop.category].append(prop)
        except:
            logging.exception("UpdateHeaderValues")

        # Scan-related fields (deprecated)
        scan_mapping = {
            'spacingunit': (str, 'Measurement Unit'),
        }

        # handle old-style keywords (deprecated)
        for key in header:
            if key.startswith('scan_') or key.startswith('scanner_'):
                if key in scan_mapping:
                    dtype, label = scan_mapping[key]
                else:
                    dtype, label = (str, key)

                if dtype == float or isinstance(header[key], float):
                    prop = Property("Scan Properties", label,
                                    float(header[key]), float, False)
                elif dtype == int or isinstance(header[key], int):
                    prop = Property("Scan Properties", label, int(header[key]),
                                    int, False)
                else:
                    prop = Property("Scan Properties", label, str(header[key]),
                                    str, False)

                properties[prop.category].append(prop)

        # scan-related DICOM fields
        dicom_scan_fields = {
            'ExposureTime': (float, 'Exposure Time (ms)'),
            'KVP': (float, 'X-Ray Voltage (kVp)'),
            'XRayTubeCurrent': (float, 'X-Ray Tube Current (mA)'),
            'XRayTubeCurrentInmA': (float, u'X-Ray Tube Current (mA)'),
            'XRayTubeCurrentInuA': (float, u'X-Ray Tube Current (\u00b5A)'),
            'DistanceSourceToPatient': (float, 'Object Position (mm)'),
            'DistanceSourceToDetector': (float, 'Detector Position (mm)'),
            'Manufacturer': (str, 'Scanner Manufacturer'),
            'ManufacturerModelName': (str, 'Scanner Model'),
            'ProtocolName': (str, 'Protocol Name'),
        }

        # handle DICOM keywords
        for key in dicom_scan_fields:
            if key in dicom_header:
                dtype, label = dicom_scan_fields[key]
                value = dicom_header.get(key)
                if dtype == float:
                    try:
                        value = float(value)
                        prop = Property("Scan Properties", label, value, float,
                                        False)
                        properties[prop.category].append(prop)
                        continue
                    except:
                        dtype = str
                elif dtype == int:
                    try:
                        value = int(value)
                        prop = Property("Scan Properties", label, value, int,
                                        False)
                        properties[prop.category].append(prop)
                        continue
                    except:
                        dtype = str

                prop = Property("Scan Properties", label,
                                str(dicom_header.get(key)), str, False)
                properties[prop.category].append(prop)

        # Reconstruction-related fields
        recon_property_created = False
        recon_mapping = {
            'recon_sw_version': (str, 'Software Version'),
            'recon_git_sha1': (str, 'Software SHA1'),
            'recon_date': (str, 'Reconstruction Date'),
            'recon_center_of_rotation': (float, 'Center of Rotation'),
            'recon_central_slice': (float, 'Central Slice'),
            'recon_filter_type': (str, 'Filter Type'),
            'recon_auth': (int, 'Reconstruction Authorized'),
            'recon_cmdLine': (str, 'Commandline'),
            'recon_gate_delay_us': (float, u'Gating delay (\u00b5s)'),
            'recon_gate_window_us': (float, u'Gating window (\u00b5s)'),
            'ct_recon_macaddr': (str, 'Ethernet Address'),
            'ct_recon_every_nth_proj': (int, 'View Skip'),
            'ct_cone_angle': (float, 'Cone Angle (deg)')
        }

        for key in header.keys():
            if key.startswith('recon_') or key.startswith(
                    'ct_recon_') or key in ('y_bin', 'z_bin'):
                if key in recon_mapping:
                    dtype, label = recon_mapping[key]
                else:
                    dtype, label = (str, key)

                if dtype == float:
                    prop = Property("Reconstruction Properties", label,
                                    float(header[key]), float, False)
                    properties[prop.category].append(prop)
                else:
                    prop = Property("Reconstruction Properties", label,
                                    str(header[key]), str, False)
                    properties[prop.category].append(prop)

                del (header[key])

        try:
            if modality == 'CT':
                prop = Property("Reconstruction Properties", "Air Value",
                                float(header.get('air', 0.0)), float, False)
                properties[prop.category].append(prop)
                prop = Property("Reconstruction Properties", "Water Value",
                                float(header.get('water', 0.0)), float, False)
                properties[prop.category].append(prop)
                prop = Property("Reconstruction Properties", "Bone Value (HU",
                                int(header.get('boneHU', 0)), int, False)
                properties[prop.category].append(prop)
        except:
            pass

        self._general_page.Append(wxpg.PropertyCategory("Display Properties"))
        prop = Property("Display Properties", "Texture Interpolation",
                        bool(self._config.bInterpolateTextures), bool, False)
        properties[prop.category].append(prop)

        numC = image.GetNumberOfScalarComponents()
        prop = Property("Display Properties",
                        "Colour Table",
                        pageState.lut_index,
                        self.LD.get_names(),
                        False,
                        disabled=(numC > 1))
        properties[prop.category].append(prop)

        # grab configuration object, see if there's any colour info in there
        try:
            root = MicroViewObjectShelve.MicroViewObjectShelve.getObject(
            ).getRoot()
            state = root['options.pane3D.background']
            bg1 = state.GetTopColour()
            bg2 = state.GetBottomColour()
            use_gradient = state.GetGradientState()
        except:
            bg1 = bg2 = (0, 0, 0)
            use_gradient = True

        # for the moment, colour editing shall be disabled
        prop = Property("Display Properties", "Background Colour #1", bg1,
                        tuple, False)
        properties[prop.category].append(prop)
        prop = Property("Display Properties", "Background Colour #2", bg2,
                        tuple, False)
        properties[prop.category].append(prop)
        prop = Property("Display Properties", "Enable Background Gradient",
                        use_gradient, bool, False)
        properties[prop.category].append(prop)

        # everything else
        for key in header:
            _k = key.lower()
            if not (_k.startswith('recon_') or _k.startswith('scan_')
                    or _k.startswith('scanner_') or _k.startswith('hidden')):
                if key.lower() not in ('size', 'air', 'water', 'bonehu',
                                       'y_bin', 'z_bin'):
                    try:
                        prop = Property("Additional Properties", key,
                                        str(header[key]), str, False)
                        properties[prop.category].append(prop)
                    except:
                        logging.warning("duplicate tag: {0}".format(key))

        _filter = None
        if self._search_filter:
            _filter = self._search_filter.lower()
            _filter = _filter.split()

        added_categories = []

        for category in properties:
            for property in properties[category]:

                name = property.name
                value = property.value

                # apply filter
                should_display = False
                if _filter:
                    for _f in _filter:
                        if _f in unicode(name).lower() or _f in unicode(
                                repr(value)).lower():
                            should_display = True
                            break
                    if not should_display:
                        continue

                if category not in added_categories:
                    added_categories.append(category)
                    self._general_page.Append(wxpg.PropertyCategory(category))

                if property.value_type is int:
                    _id = wxpg.IntProperty(property.name, value=property.value)
                elif property.value_type is float:
                    _id = wxpg.FloatProperty(property.name,
                                             value=property.value)
                elif property.value_type is str:
                    _id = wxpg.StringProperty(property.name,
                                              value=property.value)
                elif isinstance(property.value_type, list):
                    # enum
                    _id = wxpg.EnumProperty(property.name, property.name,
                                            property.value_type,
                                            range(len(property.value_type)),
                                            property.value)
                elif property.value_type is wx.DateTime:
                    # date
                    _id = wxpg.DateProperty(property.name,
                                            value=property.value)
                    _id.SetAttribute(wxpg.PG_DATE_PICKER_STYLE,
                                     wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)
                elif property.value_type is bool:
                    _id = wxpg.BoolProperty(property.name,
                                            value=property.value)
                elif property.value_type is tuple:
                    _id = wxpg.ColourProperty(property.name,
                                              value=property.value)

                self._general_page.Append(_id)
                if property.read_only:
                    _id.ChangeFlag(wxpg.PG_PROP_READONLY, True)
                if property.disabled:
                    self._general_page.DisableProperty(_id)
コード例 #22
0
ファイル: propertiesgrid.py プロジェクト: jbernardis/shapeoko
    def getPropertyForType(self, name, label, dt):
        if dt == "str":
            pgp = wxpg.StringProperty(label, name, value="")

        elif dt == "float":
            pgp = wxpg.FloatProperty(label, name, value=0.0)

        elif dt == "int":
            pgp = wxpg.IntProperty(label, name, value=0)

        elif dt == "bool":
            pgp = wxpg.BoolProperty(label, name, value=False)

        elif dt == "point2dlist":
            pgp = PointList2DProperty(label,
                                      name,
                                      value=[],
                                      images=self.images)

        elif dt == "point2d":
            pgp = Point2DProperty(label, name, ["0.0", "0.0"])

        elif dt == "point3d":
            pgp = Point3DProperty(label, name, ["0.0", "0.0", "0.0"])

        elif dt == "anchorType":
            pgp = wxpg.EnumProperty(label,
                                    name,
                                    labels=anchorType.names,
                                    values=range(len(anchorType.names)),
                                    value=0)

        elif dt == "pocketType":
            pgp = wxpg.EnumProperty(label,
                                    name,
                                    labels=pocketType.names,
                                    values=range(len(pocketType.names)),
                                    value=0)

        elif dt == "cutDirection":
            pgp = wxpg.EnumProperty(label,
                                    name,
                                    labels=cutDirection.names,
                                    values=range(len(cutDirection.names)),
                                    value=0)

        elif dt == "toolMovement":
            pgp = wxpg.EnumProperty(label,
                                    name,
                                    labels=toolMovement.names,
                                    values=range(len(toolMovement.names)),
                                    value=0)

        elif dt == "enum":
            pgp = wxpg.EnumProperty(label,
                                    name,
                                    labels=["a", "b", "c"],
                                    values=range(3),
                                    value=0)

        else:
            #self.log("taking default action for unknown data type: %s" % dt)
            pgp = wxpg.StringProperty(label, name, value="")

        return pgp
コード例 #23
0
    def __init__(self, parent, log):
        # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
        wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)

        self.log = log
        tID = wx.NewId()

        topsizer = wx.BoxSizer(wx.VERTICAL)

        # Difference between using PropertyGridManager vs PropertyGrid is that
        # the manager supports multiple pages and a description box.
        self.pg = pg = wxpg.PropertyGridManager(
            self,
            style=wxpg.PG_SPLITTER_AUTO_CENTER | wxpg.PG_AUTO_SORT
            | wxpg.PG_TOOLBAR)  # |wxpg.PG_DESCRIPTION
        #self.pg = pg = wxpg.PropertyGrid(self,
        #    style=wxpg.PG_SPLITTER_AUTO_CENTER|wxpg.PG_AUTO_SORT)

        # Show help as tooltips
        pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS
                         | wxpg.PG_EX_MULTIPLE_SELECTION)

        pg.Bind(wxpg.EVT_PG_CHANGED, self.OnPropGridChange)
        pg.Bind(wxpg.EVT_PG_PAGE_CHANGED, self.OnPropGridPageChange)
        pg.Bind(wxpg.EVT_PG_SELECTED, self.OnPropGridSelect)
        pg.Bind(wxpg.EVT_PG_RIGHT_CLICK, self.OnPropGridRightClick)

        # Needed by custom image editor
        wx.InitAllImageHandlers()

        #
        # Let's use some simple custom editor
        #
        # NOTE: Editor must be registered *before* adding a property that
        # uses it.
        pg.RegisterEditor(TrivialPropertyEditor)
        pg.RegisterEditor(LargeImageEditor)

        #
        # Add properties
        #

        pg.AddPage("Page 1 - Testing All")

        pg.Append(wxpg.PropertyCategory("1 - Basic Properties"))

        pg.Append(wxpg.StringProperty("String", value="Some Text"))
        pg.Append(wxpg.IntProperty("Int", value=100))
        pg.Append(wxpg.FloatProperty("Float", value=100.0))
        pg.Append(wxpg.BoolProperty("Bool", value=True))
        pg.Append(wxpg.BoolProperty("Bool_with_Checkbox", value=True))
        pg.SetPropertyAttribute("Bool_with_Checkbox", "UseCheckbox", True)

        pg.Append(wxpg.PropertyCategory("2 - More Properties"))
        pg.Append(
            wxpg.LongStringProperty(
                "LongString",
                value=
                "This is a\\nmulti-line string\\nwith\\ttabs\\nmixed\\tin."))
        pg.Append(wxpg.DirProperty("Dir", value="C:\\Windows"))
        pg.Append(wxpg.FileProperty("File", value="C:\\Windows\\system.ini"))
        pg.Append(
            wxpg.ArrayStringProperty("ArrayString", value=['A', 'B', 'C']))

        pg.Append(
            wxpg.EnumProperty(
                "Enum", "Enum",
                ['wxPython Rules', 'wxPython Rocks', 'wxPython Is The Best'],
                [10, 11, 12], 0))
        pg.Append(
            wxpg.EditEnumProperty("EditEnum", "EditEnumProperty",
                                  ['A', 'B', 'C'], [0, 1, 2],
                                  "Text Not in List"))

        pg.Append(wxpg.PropertyCategory("3 - Advanced Properties"))
        pg.Append(wxpg.DateProperty("Date", value=wx.DateTime_Now()))
        pg.Append(wxpg.FontProperty("Font", value=self.GetFont()))
        pg.Append(
            wxpg.ColourProperty("Colour", value=self.GetBackgroundColour()))
        pg.Append(wxpg.SystemColourProperty("SystemColour"))
        pg.Append(wxpg.ImageFileProperty("ImageFile"))
        pg.Append(
            wxpg.MultiChoiceProperty("MultiChoice",
                                     choices=['wxWidgets', 'QT', 'GTK+']))

        pg.Append(wxpg.PropertyCategory("4 - Additional Properties"))
        pg.Append(wxpg.PointProperty("Point", value=self.GetPosition()))
        pg.Append(wxpg.SizeProperty("Size", value=self.GetSize()))
        pg.Append(wxpg.FontDataProperty("FontData"))
        pg.Append(wxpg.IntProperty("IntWithSpin", value=256))
        pg.SetPropertyEditor("IntWithSpin", "SpinCtrl")
        pg.Append(wxpg.DirsProperty("Dirs", value=['C:/Lib', 'C:/Bin']))
        pg.SetPropertyHelpString("String", "String Property help string!")
        pg.SetPropertyHelpString("Dirs", "Dirs Property help string!")

        pg.SetPropertyAttribute("File", wxpg.PG_FILE_SHOW_FULL_PATH, 0)
        pg.SetPropertyAttribute("File", wxpg.PG_FILE_INITIAL_PATH,
                                "C:\\Program Files\\Internet Explorer")
        pg.SetPropertyAttribute("Date", wxpg.PG_DATE_PICKER_STYLE,
                                wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)

        pg.Append(wxpg.PropertyCategory("5 - Custom Properties"))
        pg.Append(IntProperty2("IntProperty2", value=1024))
        pg.Append(
            RectProperty("RectProperty", value=wx.Rect(100, 200, 300, 400)))

        pg.Append(ShapeProperty("ShapeProperty", value=0))
        pg.Append(PyObjectProperty("PyObjectProperty"))

        prop = pg.Append(
            wxpg.StringProperty("StringWithCustomEditor", value="test value"))
        pg.SetPropertyEditor(prop, "TrivialPropertyEditor")

        pg.Append(wxpg.ImageFileProperty("ImageFileWithLargeEditor"))
        pg.SetPropertyEditor("ImageFileWithLargeEditor", "LargeImageEditor")

        # When page is added, it will become the target page for AutoFill
        # calls (and for other property insertion methods as well)
        pg.AddPage("Page 2 - Results of AutoFill will appear here")

        pg.SetPropertyClientData("Point", 1234)
        if pg.GetPropertyClientData("Point") != 1234:
            raise ValueError("Set/GetPropertyClientData() failed")

        # Test setting unicode string
        pg.GetPropertyByName("String").SetValue(u"Some Unicode Text")

        #
        # Test some code that *should* fail (but not crash)
        try:
            a_ = pg.GetPropertyValue("NotARealProperty")
            pg.EnableProperty("NotAtAllRealProperty", False)
            pg.SetPropertyHelpString("AgaintNotARealProperty",
                                     "Dummy Help String")
        except:
            pass
            #raise

        topsizer.Add(pg, 1, wx.EXPAND)

        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(self, -1, "SetPropertyValues")
        but.Bind(wx.EVT_BUTTON, self.OnSetPropertyValues)
        rowsizer.Add(but, 1)
        but = wx.Button(self, -1, "GetPropertyValues")
        but.Bind(wx.EVT_BUTTON, self.OnGetPropertyValues)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(self, -1, "GetPropertyValues(as_strings=True)")
        but.Bind(wx.EVT_BUTTON, self.OnGetPropertyValues2)
        rowsizer.Add(but, 1)
        but = wx.Button(self, -1, "AutoFill")
        but.Bind(wx.EVT_BUTTON, self.OnAutoFill)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(self, -1, "Delete")
        but.Bind(wx.EVT_BUTTON, self.OnDeleteProperty)
        rowsizer.Add(but, 1)
        but = wx.Button(self, -1, "Run Tests")
        but.Bind(wx.EVT_BUTTON, self.RunTests)
        rowsizer.Add(but, 1)
        topsizer.Add(rowsizer, 0, wx.EXPAND)

        self.SetSizer(topsizer)
        topsizer.SetSizeHints(self)
コード例 #24
0
 def float(self, item, name, val):
     return wxpg.FloatProperty(item["name"], name, value=val)
コード例 #25
0
    def __init__(self, parent, plot):
        wx.Panel.__init__(self, parent, wx.ID_ANY)
        sizer = wx.BoxSizer(wx.VERTICAL)
        self.plot = plot

        self.pg = pg = wxpg.PropertyGridManager(
            self,
            style=wxpg.PG_SPLITTER_AUTO_CENTER | wxpg.PG_AUTO_SORT
            | wxpg.PG_TOOLBAR)

        # Show help as tooltips
        pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS)

        # Bind events
        pg.Bind(wxpg.EVT_PG_CHANGED, self.OnPropGridChange)
        pg.Bind(wxpg.EVT_PG_RIGHT_CLICK, self.OnPropGridRightClick)

        # Parse the properties to insert into the propertygrid
        for property_category_index, property_category in enumerate(
                INPUT_DATA['PropertyCategory']):
            pg.Append(
                wxpg.PropertyCategory(
                    '%s - %s' %
                    (property_category_index + 1, property_category['title'])))
            format_string = (
                str(property_category_index + 1) + '.%0' +
                str(len(str(len(property_category['properties']) + 1))) + 'd')
            for prop_index, prop in enumerate(property_category['properties']):
                self.append(format_string % (prop_index + 1), prop)

        # pg.Append(wxpg.PropertyCategory("2 - Plot Type"))
        # projection_names = sorted([PROJECTIONS[proj]['name']
        #                            for proj in PROJECTIONS])
        # proj = 'Cylindrical Equidistant'
        # pg.Append(SingleChoiceProperty("Projection",
        #                                choices=projection_names,
        #                                value=proj))

        self.pp = pg.Append(wxpg.PropertyCategory("3 - Projection Parameters"))
        self.pp_list = []

        pg.Append(wxpg.PropertyCategory("4 - Plot Properties"))
        pg.Append(wxpg.BoolProperty("Blue Marble", value=True))
        pg.Append(wxpg.BoolProperty("Coastlines", value=False))
        pg.Append(wxpg.BoolProperty("State Borders", value=False))
        pg.Append(wxpg.BoolProperty("Country Borders", value=False))
        pg.Append(wxpg.FloatProperty("Area Threshold", value=10000))
        # pg.Append(SingleChoiceProperty("Resolution", choices=RESOLUTION_KEYS,
        #                                value='Crude'))

        # Do Layout
        sizer.Add(pg, 1, wx.EXPAND)
        rowsizer = wx.BoxSizer(wx.HORIZONTAL)
        but = wx.Button(self, -1, "Update Plot")
        but.Bind(wx.EVT_BUTTON, self.OnUpdatePlotButtonEvent)
        rowsizer.Add(but, 1)
        sizer.Add(rowsizer, 0, wx.EXPAND)

        self.SetSizer(sizer)
        self.SetAutoLayout(True)

        self.OnUpdatePlotButtonEvent()