示例#1
0
    def __init__(self, parent, dictDonnees={}):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           name="DLG_Choix_periodes",
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
                           | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
        self.parent = parent

        # Périodes
        self.staticbox_periodes_staticbox = wx.StaticBox(
            self, -1, _(u"Sélectionnez une ou plusieurs périodes"))
        self.ctrl_periodes = CTRL_Grille_periode.CTRL(self)
        self.ctrl_toutes = wx.CheckBox(self, -1, _(u"Toutes les périodes"))

        # Boutons de commandes
        self.bouton_ok = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
        self.bouton_annuler = CTRL_Bouton_image.CTRL(
            self,
            id=wx.ID_CANCEL,
            texte=_(u"Annuler"),
            cheminImage="Images/32x32/Annuler.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_CHECKBOX, self.OnCheckToutes, self.ctrl_toutes)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)

        # Applique les valeurs par défaut
        if len(dictDonnees) > 0:
            self.ctrl_periodes.SetDictDonnees(dictDonnees)
    def __init__(self, parent, IDfamille=None, mode="ajout", listeDates=[], selectionIndividus=[], selectionActivite=None):
        wx.Panel.__init__(self, parent, id=-1, name="CTRL_Selection_lot_conso", style=wx.TAB_TRAVERSAL)
        self.parent = parent
        
        self.IDfamille = IDfamille
        self.mode = mode
        self.listeDates = listeDates
        self.selectionIndividus = selectionIndividus
        self.selectionActivite = selectionActivite
        
        # Période
        self.staticbox_periode_staticbox = wx.StaticBox(self, -1, _(u"Période"))
        self.radio_periode_1 = wx.RadioButton(self, -1, u"")
        self.label_periode = wx.StaticText(self, -1, _(u"La période affichée dans la grille"))
        self.radio_periode_2 = wx.RadioButton(self, -1, u"")
        self.radio_periode_2.Enable(False) # <<<<<<<<<<<<<<<< PROVISOIRE
        self.ctrl_periode = CTRL_Grille_periode.CTRL(self)
        self.ctrl_periode.SetMinSize((60, 110))
        
        # Individus
        self.staticbox_individus_staticbox = wx.StaticBox(self, -1, _(u"Individus"))
        self.ctrl_individus = CTRL_Individus(self, self.IDfamille, self.selectionIndividus)
        
        # Activité
        self.staticbox_activite_staticbox = wx.StaticBox(self, -1, _(u"Activité"))
        self.ctrl_activite = CTRL_Activite(self, self.selectionIndividus, self.selectionActivite)
        
        # Groupes
        self.staticbox_groupes_staticbox = wx.StaticBox(self, -1, _(u"Groupes"))
        self.ctrl_groupes = CTRL_Groupes(self, self.selectionActivite)
        
        # Unités
        self.staticbox_unites_staticbox = wx.StaticBox(self, -1, _(u"Unités"))
        self.ctrl_unites = CTRL_Unites(self, self.selectionActivite)
        
        # Modes
        self.staticbox_modes_staticbox = wx.StaticBox(self, -1, _(u"Modes"))
        self.ctrl_modes = CTRL_Modes(self)
        self.ctrl_modes.SetMinSize((60, 40))
        
        # Etats
        self.staticbox_etats_staticbox = wx.StaticBox(self, -1, _(u"Etats"))
        self.ctrl_etats = CTRL_Etats(self)
        self.ctrl_etats.SetMinSize((60, 40))

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioPeriode, self.radio_periode_1)
        self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioPeriode, self.radio_periode_2)
        self.Bind(wx.EVT_CHOICE, self.OnChoixActivite, self.ctrl_activite)
        
        self.Bind(wx.EVT_CHECKLISTBOX, self.OnCocheIndividus, self.ctrl_individus)
        
        # Init Contrôles
        self.radio_periode_1.SetValue(True)
        self.OnRadioPeriode(None)
    def __init__(self, parent):
        wx.Dialog.__init__(self, parent, -1, style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX|wx.THICK_FRAME)
        self.parent = parent
        
        intro = _(u"Vous pouvez ici imprimer la liste des anniversaires des individus inscrits sur les activités cochées et présents sur la période donnée. Il est possible d'inclure un thème graphique et les photos individuelles.")
        titre = _(u"Liste des anniversaires")
        self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage="Images/32x32/Anniversaire.png")
        
        # Périodes
        self.box_periodes_staticbox = wx.StaticBox(self, -1, _(u"Période"))
        self.ctrl_periodes = CTRL_Grille_periode.CTRL(self)
        self.ctrl_periodes.SetMinSize((200, 150))

        # Options
        self.box_options_staticbox = wx.StaticBox(self, -1, _(u"Options"))
        
        self.check_photos = wx.CheckBox(self, -1, u"")
        self.check_photos.SetValue(True)
        self.label_photos = wx.StaticText(self, -1, _(u"Afficher les photos :"))
        self.ctrl_photos = wx.Choice(self, -1, choices=[_(u"Petite taille"), _(u"Moyenne taille"), _(u"Grande taille")])
        self.ctrl_photos.SetSelection(1)

        self.check_theme = wx.CheckBox(self, -1, u"")
        self.check_theme.SetValue(True)
        self.label_theme = wx.StaticText(self, -1, _(u"Inclure le thème :"))
        self.ctrl_theme = wx.Choice(self, -1, choices=THEMES.keys())
        self.ctrl_theme.SetStringSelection(_(u"Feuille d'été"))
        
        # Activités
        self.box_activites_staticbox = wx.StaticBox(self, -1, _(u"Activités"))
        self.ctrl_activites = CTRL_Selection_activites.CTRL(self)
        
        # Boutons
        self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
        self.bouton_ok = CTRL_Bouton_image.CTRL(self, texte=_(u"Aperçu"), cheminImage="Images/32x32/Apercu.png")
        self.bouton_fermer = CTRL_Bouton_image.CTRL(self, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_CHECKBOX, self.OnCheckPhotos, self.check_photos)
        self.Bind(wx.EVT_CHECKBOX, self.OnCheckTheme, self.check_theme)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonFermer, self.bouton_fermer)

        # Init Contrôles
        self.OnCheckPhotos(None) 
        self.bouton_ok.SetFocus() 
示例#4
0
    def __init__(self, parent, IDfamille=None, selectionIndividus=[], selectionTous=False):
        wx.Dialog.__init__(self, parent, -1, name="grille", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
        self.parent = parent
        self.IDfamille = IDfamille
        
        # Adapte taille Police pour Linux
        from Utils import UTILS_Linux
        UTILS_Linux.AdaptePolice(self)
        
        self._mgr = aui.AuiManager()
        self._mgr.SetManagedWindow(self)
        self.SetTitle(_(u"Grille des consommations"))
        
        # Récupère les perspectives
        cfg = UTILS_Config.FichierConfig()
        self.userConfig = cfg.GetDictConfig()
        if self.userConfig.has_key("grille_perspectives") == True :
            self.perspectives = self.userConfig["grille_perspectives"]
        else:
            self.perspectives = []
        if self.userConfig.has_key("grille_perspective_active") == True :
            self.perspective_active = self.userConfig["grille_perspective_active"]
        else:
            self.perspective_active = None
                
        # Création du notebook
        self.panel_grille = PanelGrille(self, "individu", self.IDfamille)
        self.dictActivites = self.panel_grille.grille.dictActivites
        self.dictIndividus = self.panel_grille.grille.dictIndividus
        self.dictGroupes = self.panel_grille.grille.dictGroupes
        self.listeSelectionIndividus = self.panel_grille.grille.listeSelectionIndividus
                        
        # Création des panels amovibles
        self.panel_periode = CTRL_Grille_periode.CTRL(self)
        dictDonnees = UTILS_Config.GetParametre("dict_selection_periodes_activites")
        self.panel_periode.SetDictDonnees(dictDonnees)
        self._mgr.AddPane(self.panel_periode, aui.AuiPaneInfo().
                          Name("periode").Caption(_(u"Sélection de la période")).
                          Top().Layer(1).BestSize(wx.Size(230,144)).Position(1).CloseButton(False).Fixed().MaximizeButton(False))
        
        self.panel_individus = CTRL_Grille_individus.CTRL(self, self.IDfamille, self.dictIndividus, selectionIndividus, selectionTous)
        self._mgr.AddPane(self.panel_individus, aui.AuiPaneInfo().
                          Name("individus").Caption(_(u"Sélection des individus")).
                          Top().Layer(1).BestSize(wx.Size(180,140)).Position(2).CloseButton(False).MaximizeButton(False).MinSize((10, 100)))
                        
        self.panel_activites = CTRL_Grille_activite2.CTRL(self, self.dictIndividus, self.dictActivites, self.dictGroupes, self.listeSelectionIndividus)
        self._mgr.AddPane(self.panel_activites, aui.AuiPaneInfo().
                          Name("activites").Caption(_(u"Sélection des activités")).
                          Top().Layer(1).Position(3).CloseButton(False).MaximizeButton(False).MinSize((160, 100)))
        
        self.panel_facturation = CTRL_Grille_facturation.CTRL(self)
        self._mgr.AddPane(self.panel_facturation, aui.AuiPaneInfo().
                          Name("facturation").Caption(_(u"Facturation")).
                          Right().Layer(0).BestSize(wx.Size(275,140)).Position(3).CloseButton(False).MaximizeButton(False).MinSize((275, 100)))

        self.panel_etiquettes = CTRL_Etiquettes.CTRL(self, activeMenu=False, onCheck=self.panel_grille.grille.MAJ_affichage)
        self._mgr.AddPane(self.panel_etiquettes, aui.AuiPaneInfo().
                          Name("etiquettes").Caption(_(u"Etiquettes")).
                          Right().Layer(0).Position(3).CloseButton(False).BestSize(wx.Size(275, 100)).MaximizeButton(False).MinSize((275, 100)))    

        self.panel_forfaits = CTRL_Grille_forfaits.CTRL(self, grille=self.panel_grille.grille)
        self._mgr.AddPane(self.panel_forfaits, aui.AuiPaneInfo().
                          Name("forfaits").Caption(_(u"Forfaits crédits")).
                          Right().Layer(0).Position(4).BestSize(wx.Size(275,140)).CloseButton(False).MaximizeButton(False).MinSize((275, 100)))
        self._mgr.GetPane("forfaits").dock_proportion = 50000
        
        self.panel_commandes = Commandes(self)
        self._mgr.AddPane(self.panel_commandes, aui.AuiPaneInfo().
                          Name("commandes").Caption(_(u"Commandes")).
                          Bottom().Layer(0).CaptionVisible(False).CloseButton(False).MaximizeButton(False).MinSize((-1, 50)))

        self.panel_legende = OL_Legende_grille.ListView(self, id=-1, name="OL_legende", style=wx.LC_REPORT|wx.LC_NO_HEADER | wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)
        self._mgr.AddPane(self.panel_legende, aui.AuiPaneInfo().
                          Name("legende").Caption(_(u"Légende")).
                          Left().Layer(0).Position(2).CloseButton(False).BestSize(wx.Size(170, 100)).MaximizeButton(False).MinSize((170, 100)))    
        self._mgr.GetPane("legende").dock_proportion = 60000
        
        self.panel_raccourcis = OL_Raccourcis_grille.ListView(self, id=-1, name="OL_raccourcis", style=wx.LC_REPORT|wx.LC_NO_HEADER | wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)
        self._mgr.AddPane(self.panel_raccourcis, aui.AuiPaneInfo().
                          Name("raccourcis").Caption(_(u"Touches raccourcis")).
                          Left().Layer(0).Position(2).CloseButton(False).BestSize(wx.Size(170, 100)).MaximizeButton(False).MinSize((170, 100)))    
        self._mgr.GetPane("raccourcis").dock_proportion = 30000
        
        
        # Création du panel central
        self._mgr.AddPane(self.panel_grille, aui.AuiPaneInfo().Name("grille").
                          CenterPane())
                
        self._mgr.GetPane("grille").Show()

        # Sauvegarde de la perspective par défaut
        self.perspective_defaut = self._mgr.SavePerspective()

        # Récupération de la perspective chargée
        if self.perspective_active != None :
            self._mgr.LoadPerspective(self.perspectives[self.perspective_active]["perspective"])
        else:
            self._mgr.LoadPerspective(self.perspective_defaut)

        self._mgr.Update()
        
        self.Bind(wx.EVT_CLOSE, self.OnClose)
        
        # Détermine la taille de la fenêtre
        self.SetMinSize((600, 670))
        taille_fenetre = UTILS_Config.GetParametre("taille_fenetre_grille")
        if taille_fenetre == None :
            self.SetSize((900, 670))
        if taille_fenetre == (0, 0) :
            self.Maximize(True)
        else:
            self.SetSize(taille_fenetre)
        self.CenterOnScreen()
        
        # Initialisation des contrôles
        self.panel_periode.SetVisibleSelection()
        self.SetListesPeriodes(self.panel_periode.GetDatesSelections())
        self.SetListeSelectionIndividus(self.panel_individus.GetSelections())
        self.SetListeSelectionActivites(self.panel_activites.ctrl_activites.GetIDcoches())
        self.MAJ_grille()
        
        # Affichage du panneau du panneau Forfait Credits
        if self.panel_grille.grille.tarifsForfaitsCreditsPresents == True :
            self._mgr.GetPane("forfaits").Show()
        else:
            self._mgr.GetPane("forfaits").Hide()
        
        # Affichage du panneau du panneau Etiquettes
        if self.panel_grille.grille.afficherListeEtiquettes == True :
            self._mgr.GetPane("etiquettes").Show()
        else:
            self._mgr.GetPane("etiquettes").Hide()
        
        # Contre le bug de maximize
        wx.CallAfter(self._mgr.Update)
        wx.CallAfter(self.panel_grille.grille.SetFocus)
    def __init__(self, parent, dictDonnees = {}, afficheLargeurColonneUnite=True, afficheAbregeGroupes=True, totaux=True, abregeGroupes=False, affichePresents=1, afficheTotaux=True):
        wx.Dialog.__init__(self, parent, -1, name="parametres_remplissage", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
        self.parent = parent
        self.afficheLargeurColonneUnite = afficheLargeurColonneUnite
        
        # Périodes
        self.staticbox_periodes_staticbox = wx.StaticBox(self, -1, _(u"Période"))
        self.ctrl_periodes = CTRL_Grille_periode.CTRL(self)
        self.ctrl_periodes.SetMinSize((220, 230))
        
        # Activités
        self.staticbox_activites_staticbox = wx.StaticBox(self, -1, _(u"Activités"))
        self.ctrl_activites = CTRL_activites(self)
        self.ctrl_activites.SetMinSize((300, 150))
        
        self.ctrl_masquer_activites = wx.CheckBox(self, -1, _(u"Masquer les anciennes activités"))
        self.ctrl_masquer_activites.SetValue(UTILS_Parametres.Parametres(mode="get", categorie="parametres_remplissage", nom="masquer_anciennes_activites", valeur=0))
        self.ctrl_masquer_activites.SetFont(wx.Font(8, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, ""))
        
        # Options d'affichage
        self.staticbox_options_staticbox = wx.StaticBox(self, -1, _(u"Options"))
        
        self.label_abregeGroupes = wx.StaticText(self, -1, _(u"Utiliser le nom abrégé des groupes :"))
        self.ctrl_abregeGroupes_oui = wx.RadioButton(self, -1, _(u"Oui"), style = wx.RB_GROUP)
        self.ctrl_abregeGroupes_non = wx.RadioButton(self, -1, _(u"Non"))
        if abregeGroupes == True :
            self.ctrl_abregeGroupes_oui.SetValue(True)
        else:
            self.ctrl_abregeGroupes_non.SetValue(True)

        self.label_affichePresents = wx.StaticText(self, -1, _(u"Afficher les présents en temps réel :"))
        self.ctrl_affichePresents_oui = wx.RadioButton(self, -1, _(u"Oui"), style = wx.RB_GROUP)
        self.ctrl_affichePresents_non = wx.RadioButton(self, -1, _(u"Non"))
        if affichePresents == True :
            self.ctrl_affichePresents_oui.SetValue(True)
        else:
            self.ctrl_affichePresents_non.SetValue(True)

        self.label_afficheTotaux = wx.StaticText(self, -1, _(u"Afficher les colonnes des totaux :"))
        self.ctrl_afficheTotaux_oui = wx.RadioButton(self, -1, _(u"Oui"), style = wx.RB_GROUP)
        self.ctrl_afficheTotaux_non = wx.RadioButton(self, -1, _(u"Non"))
        if totaux == True :
            self.ctrl_afficheTotaux_oui.SetValue(True)
        else:
            self.ctrl_afficheTotaux_non.SetValue(True)

        if afficheAbregeGroupes == False :
            self.label_abregeGroupes.Show(False)
            self.ctrl_abregeGroupes_oui.Show(False)
            self.ctrl_abregeGroupes_non.Show(False)

        if afficheTotaux == False :
            self.label_afficheTotaux.Show(False)
            self.ctrl_afficheTotaux_oui.Show(False)
            self.ctrl_afficheTotaux_non.Show(False)

        if self.afficheLargeurColonneUnite == False and afficheAbregeGroupes == False and afficheTotaux == False :
            self.label_affichePresents.Show(False)
            self.ctrl_affichePresents_oui.Show(False)
            self.ctrl_affichePresents_non.Show(False)
            self.staticbox_options_staticbox.Show(False)



        # Boutons de commandes 
        self.bouton_ok = CTRL_Bouton_image.CTRL(self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
        self.bouton_annuler = CTRL_Bouton_image.CTRL(self, id=wx.ID_CANCEL, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")

        self.__set_properties()
        self.__do_layout()
        
        self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
        self.Bind(wx.EVT_CHECKBOX, self.OnCheckMasquerActivites, self.ctrl_masquer_activites)
        
        # Init contrôles
        self.ctrl_activites.MAJ() 
        
        # Applique les valeurs par défaut
        self.ctrl_periodes.SetDictDonnees(dictDonnees)
        self.ctrl_activites.SetDictDonnees(dictDonnees)
示例#6
0
    def __init__(self, parent):
        wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
        self.parent = parent

        # Mode
        self.staticbox_mode_staticbox = wx.StaticBox(self, -1,
                                                     _(u"Mode de sélection"))
        self.radio_inscrits = wx.RadioButton(self,
                                             -1,
                                             _(u"Inscrits"),
                                             style=wx.RB_GROUP)
        self.radio_presents = wx.RadioButton(self, -1,
                                             _(u"Présents sur une période"))

        # Calendrier
        self.staticbox_date_staticbox = wx.StaticBox(self, -1, _(u"Période"))
        self.ctrl_calendrier = CTRL_Grille_periode.CTRL(self)
        self.ctrl_calendrier.SetMinSize((230, 150))

        # Activités
        self.staticbox_activites_staticbox = wx.StaticBox(
            self, -1, _(u"Activités"))
        self.ctrl_activites_presents = CTRL_Activites(self)
        self.ctrl_activites_inscrits = CTRL_Selection_activites.CTRL(self)
        self.ctrl_activites_presents.SetMinSize((10, 10))
        self.ctrl_activites_inscrits.SetMinSize((10, 10))

        # Groupes
        self.staticbox_groupes_staticbox = wx.StaticBox(
            self, -1, _(u"Groupes"))
        self.ctrl_groupes = CTRL_Groupes(self)
        self.ctrl_groupes.SetMinSize((10, 100))

        # Propriétés
        self.radio_inscrits.SetToolTip(
            wx.ToolTip(
                _(u"Sélectionnez le mode de sélection des individus")))
        self.radio_presents.SetToolTip(
            wx.ToolTip(
                _(u"Sélectionnez le mode de sélection des individus")))

        # Binds
        self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioMode, self.radio_inscrits)
        self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioMode, self.radio_presents)

        # Layout
        grid_sizer_base = wx.FlexGridSizer(rows=1, cols=2, vgap=10, hgap=10)

        # Sizer GAUCHE
        grid_sizer_gauche = wx.FlexGridSizer(rows=4, cols=1, vgap=10, hgap=10)

        # Mode
        staticbox_mode = wx.StaticBoxSizer(self.staticbox_mode_staticbox,
                                           wx.VERTICAL)
        grid_sizer_mode = wx.FlexGridSizer(rows=3, cols=2, vgap=5, hgap=10)
        grid_sizer_mode.Add(self.radio_inscrits, 0, wx.ALIGN_CENTER_VERTICAL,
                            0)
        grid_sizer_mode.Add(self.radio_presents, 0, wx.ALIGN_CENTER_VERTICAL,
                            0)
        staticbox_mode.Add(grid_sizer_mode, 0, wx.ALL | wx.EXPAND, 10)
        grid_sizer_gauche.Add(staticbox_mode, 1, wx.EXPAND, 0)

        # Période
        staticbox_date = wx.StaticBoxSizer(self.staticbox_date_staticbox,
                                           wx.VERTICAL)
        staticbox_date.Add(self.ctrl_calendrier, 1, wx.ALL | wx.EXPAND, 10)
        grid_sizer_gauche.Add(staticbox_date, 1, wx.EXPAND, 0)

        grid_sizer_gauche.AddGrowableRow(1)
        grid_sizer_base.Add(grid_sizer_gauche, 1,
                            wx.EXPAND | wx.TOP | wx.LEFT | wx.BOTTOM, 10)

        # Sizer DROIT
        grid_sizer_droit = wx.FlexGridSizer(rows=2, cols=1, vgap=10, hgap=10)

        # Activités
        staticbox_activites = wx.StaticBoxSizer(
            self.staticbox_activites_staticbox, wx.VERTICAL)

        staticbox_activites.Add(self.ctrl_activites_presents, 1,
                                wx.ALL | wx.EXPAND, 10)
        staticbox_activites.Add(self.ctrl_activites_inscrits, 1,
                                wx.ALL | wx.EXPAND, 10)
        grid_sizer_droit.Add(staticbox_activites, 1, wx.EXPAND, 0)

        # Groupes
        staticbox_groupes = wx.StaticBoxSizer(self.staticbox_groupes_staticbox,
                                              wx.VERTICAL)
        staticbox_groupes.Add(self.ctrl_groupes, 1, wx.ALL | wx.EXPAND, 10)
        grid_sizer_droit.Add(staticbox_groupes, 1, wx.EXPAND, 0)

        grid_sizer_droit.AddGrowableRow(0)
        grid_sizer_droit.AddGrowableCol(0)
        grid_sizer_base.Add(grid_sizer_droit, 1,
                            wx.EXPAND | wx.TOP | wx.RIGHT | wx.BOTTOM, 10)

        grid_sizer_base.AddGrowableRow(0)
        grid_sizer_base.AddGrowableCol(1)
        self.SetSizer(grid_sizer_base)
        self.Layout()
        self.grid_sizer_base = grid_sizer_base

        # Init
        self.ctrl_calendrier.SetVisibleSelection()
        self.SetListesPeriodes(self.ctrl_calendrier.GetDatesSelections())
        self.OnRadioMode()
示例#7
0
    def __init__(self, parent, liste_activites=[], mode="attente"):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
                           | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
        self.parent = parent
        self.mode = mode

        if self.mode == "attente":
            label = _(u"en attente")
        else:
            label = _(u"refusées")

        intro = _(
            u"Vous pouvez ici consulter la liste des inscriptions %s. Si une coche verte apparaît en début de ligne, cela signifie qu'une place s'est libérée pour cet individu. Cliquez alors sur l'individu souhaité avec le bouton droit de la souris puis sélectionnez dans le menu contextuel la commande 'Ouvrir la fiche Famille'..."
        ) % label
        titre = _(u"Inscriptions %s") % label
        self.SetTitle(titre)
        self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
            self,
            titre=titre,
            texte=intro,
            hauteurHtml=30,
            nomImage="Images/32x32/Liste_attente.png")

        # Périodes
        self.staticbox_periodes_staticbox = wx.StaticBox(
            self, -1, _(u"Période"))
        self.ctrl_periodes = CTRL_Grille_periode.CTRL(self)
        self.ctrl_periodes.SetMinSize((220, 230))

        # PROVISOIRE
        self.staticbox_periodes_staticbox.Show(False)
        self.ctrl_periodes.Show(False)

        # Résultats
        self.staticbox_resultats_staticbox = wx.StaticBox(self, -1, titre)
        self.ctrl_attente = CTRL_Inscriptions_attente.CTRL(
            self, liste_activites=liste_activites, mode=self.mode)
        self.ctrl_attente.SetMinSize((100, 100))

        self.bouton_ouvrir_fiche = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Famille.png"),
                      wx.BITMAP_TYPE_ANY))
        self.bouton_imprimer = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"),
                      wx.BITMAP_TYPE_ANY))
        self.bouton_excel = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Excel.png"),
                      wx.BITMAP_TYPE_ANY))

        self.bouton_aide = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
        self.bouton_fermer = CTRL_Bouton_image.CTRL(
            self,
            id=wx.ID_CANCEL,
            texte=_(u"Fermer"),
            cheminImage="Images/32x32/Fermer.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.OuvrirFiche, self.bouton_ouvrir_fiche)
        self.Bind(wx.EVT_BUTTON, self.Imprimer, self.bouton_imprimer)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonExcel, self.bouton_excel)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
示例#8
0
    def __init__(self, parent):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           name="DLG_Impression_infos_medicales",
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
                           | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
                           | wx.THICK_FRAME)
        self.parent = parent

        intro = _(
            u"Vous pouvez ici imprimer une liste au format PDF des informations médicales des individus présents sur la période de votre choix. Pour une liste standard, sélectionnez simplement une période puis cliquez sur 'Aperçu'."
        )
        titre = _(u"Impression de la liste des informations médicales")
        self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
            self,
            titre=titre,
            texte=intro,
            hauteurHtml=30,
            nomImage="Images/32x32/Imprimante.png")

        # Calendrier
        self.staticbox_date_staticbox = wx.StaticBox(self, -1, _(u"Période"))
        self.ctrl_calendrier = CTRL_Grille_periode.CTRL(self)
        self.ctrl_calendrier.SetMinSize((200, 150))

        # Activités
        self.staticbox_activites_staticbox = wx.StaticBox(
            self, -1, _(u"Activités"))
        self.ctrl_activites = CTRL_Activites(self)
        self.ctrl_activites.SetMinSize((10, 50))

        # Groupes
        self.staticbox_groupes_staticbox = wx.StaticBox(
            self, -1, _(u"Groupes"))
        self.ctrl_groupes = CTRL_Groupes(self)

        # Options
        self.staticbox_options_staticbox = wx.StaticBox(
            self, -1, _(u"Options"))
        self.label_modele = wx.StaticText(self, -1, _(u"Modèle :"))
        self.ctrl_modele = wx.Choice(self,
                                     -1,
                                     choices=[
                                         _(u"Modèle par défaut"),
                                     ])
        self.ctrl_modele.Select(0)
        self.label_tri = wx.StaticText(self, -1, _(u"Tri :"))
        self.ctrl_tri = wx.Choice(self,
                                  -1,
                                  choices=["Nom",
                                           _(u"Prénom"),
                                           _(u"Age")])
        self.ctrl_tri.Select(0)
        self.ctrl_ordre = wx.Choice(self,
                                    -1,
                                    choices=["Croissant",
                                             _(u"Décroissant")])
        self.ctrl_ordre.Select(0)
        self.checkbox_lignes_vierges = wx.CheckBox(
            self, -1, _(u"Afficher des lignes vierges :"))
        self.checkbox_lignes_vierges.SetValue(True)
        self.ctrl_nbre_lignes = wx.Choice(self,
                                          -1,
                                          choices=[
                                              "1", "2", "3", "4", "5", "6",
                                              "7", "8", "9", "10", "11", "12",
                                              "13", "14", "15"
                                          ])
        self.ctrl_nbre_lignes.Select(2)
        self.checkbox_page_groupe = wx.CheckBox(
            self, -1, _(u"Insérer un saut de page après chaque groupe"))
        self.checkbox_page_groupe.SetValue(True)
        self.checkbox_nonvides = wx.CheckBox(
            self, -1, _(u"Afficher uniquement les individus avec infos"))
        self.checkbox_nonvides.SetValue(False)
        self.checkbox_age = wx.CheckBox(self, -1,
                                        _(u"Afficher l'âge des individus"))
        self.checkbox_age.SetValue(True)
        self.checkbox_photos = wx.CheckBox(self, -1,
                                           _(u"Afficher les photos :"))
        self.checkbox_photos.SetValue(False)
        self.ctrl_taille_photos = wx.Choice(self,
                                            -1,
                                            choices=[
                                                _(u"Petite taille"),
                                                _(u"Moyenne taille"),
                                                _(u"Grande taille")
                                            ])
        self.ctrl_taille_photos.SetSelection(1)

        # Mémorisation des paramètres
        self.ctrl_memoriser = wx.CheckBox(self, -1,
                                          _(u"Mémoriser les paramètres"))
        font = self.GetFont()
        font.SetPointSize(7)
        self.ctrl_memoriser.SetFont(font)
        self.ctrl_memoriser.SetValue(True)

        # Boutons
        self.bouton_aide = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
        self.bouton_ok = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Aperçu"), cheminImage="Images/32x32/Apercu.png")
        self.bouton_annuler = CTRL_Bouton_image.CTRL(
            self,
            id=wx.ID_CANCEL,
            texte=_(u"Fermer"),
            cheminImage="Images/32x32/Fermer.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_CHECKBOX, self.OnCheckLignesVierges,
                  self.checkbox_lignes_vierges)
        self.Bind(wx.EVT_CHECKBOX, self.OnCheckPhotos, self.checkbox_photos)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)

        # Récupération des paramètres dans le CONFIG
        param_tri = UTILS_Config.GetParametre("impression_infos_med_tri",
                                              defaut=0)
        self.ctrl_tri.Select(param_tri)

        param_ordre = UTILS_Config.GetParametre("impression_infos_med_ordre",
                                                defaut=0)
        self.ctrl_ordre.Select(param_ordre)

        param_lignes_vierges = UTILS_Config.GetParametre(
            "impression_infos_med_lignes_vierges", defaut=1)
        self.checkbox_lignes_vierges.SetValue(param_lignes_vierges)

        if param_lignes_vierges == 1:
            param_nbre_lignes_vierges = UTILS_Config.GetParametre(
                "impression_infos_med_nbre_lignes_vierges", defaut=2)
            self.ctrl_nbre_lignes.Select(param_nbre_lignes_vierges)

        param_page_groupe = UTILS_Config.GetParametre(
            "impression_infos_med_page_groupe", defaut=1)
        self.checkbox_page_groupe.SetValue(param_page_groupe)

        param_nonvides = UTILS_Config.GetParametre(
            "impression_infos_med_nonvides", defaut=0)
        self.checkbox_nonvides.SetValue(param_nonvides)

        param_age = UTILS_Config.GetParametre("impression_infos_med_age",
                                              defaut=1)
        self.checkbox_age.SetValue(param_age)

        param_photos = UTILS_Config.GetParametre("impression_infos_med_photos",
                                                 defaut=1)
        self.checkbox_photos.SetValue(param_photos)

        param_taille_photos = UTILS_Config.GetParametre(
            "impression_infos_med_taille_photos", defaut=1)
        self.ctrl_taille_photos.SetSelection(param_taille_photos)

        param_memoriser = UTILS_Config.GetParametre(
            "impression_infos_med_memoriser", defaut=1)
        self.ctrl_memoriser.SetValue(param_memoriser)

        # Init Contrôles
        self.OnCheckLignesVierges(None)
        self.OnCheckPhotos(None)
        self.bouton_ok.SetFocus()

        self.ctrl_calendrier.SetVisibleSelection()
        self.SetListesPeriodes(self.ctrl_calendrier.GetDatesSelections())

        self.grid_sizer_base.Fit(self)