# -*- coding: iso-8859-1 -*-
from __future__ import division # 1/2 == .5 (par defaut, 1/2 == 0)

##--------------------------------------##
#              WxGeometrie               #
#          fenetre principale            #
##--------------------------------------##
#    WxGeometrie
#    Dynamic geometry, graph plotter, and more for french mathematic teachers.
#    Copyright (C) 2005-2007  Nicolas Pourcelot
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

# version unicode

# importation des librairies specifiques et des composantes du programme
from GUI import *
from API import *

######################################################


class ReceptionDeFichiers(wx.FileDropTarget):
    def __init__(self, window):
        wx.FileDropTarget.__init__(self)
        self.window = window

    def OnDropFiles(self, x, y, filenames):
        for filename in filenames:
            if filename.endswith(u".geo") or filename.endswith(u".geoz"):
                self.window.onglets.ouvrir(filename)



class WxGeometrie(wx.Frame):
    def __init__(self, app):
        wx.Frame.__init__(self, parent = None, title = u"WxGéométrie", pos=wx.DefaultPosition, size=wx.Size(*param.dimensions_fenetre), style=wx.DEFAULT_FRAME_STYLE)

        self.application = app # pour acceder a l'application en interne

        # Repertoires par defaut
        #self.repertoire = param.repertoire # memorise le repertoire de lancement
        #self.rep_save = param.rep_save # repertoire ou on sauve les fichiers
        #self.rep_open = param.rep_open # repertoire ou on ouvre les fichiers
        #self.rep_export = param.rep_export # repertoire ou on exporte les fichiers

        self.SetIcon(wx.Icon(path2(u"%/images/icone.ico"), wx.BITMAP_TYPE_ICO))


        # Barre d'outils
        self.tb = tb = self.CreateToolBar( wx.TB_HORIZONTAL
                                 | wx.NO_BORDER
                                 | wx.TB_FLAT
                                 | wx.TB_TEXT )
        tb.AddSeparator()
        tb.AddControl(wx.StaticText(tb, -1, u"Ligne de commande :"))
        tb.AddSeparator()
        self.commande = wx.TextCtrl(tb, -1, u"", size=(300, -1), style=wx.TE_PROCESS_ENTER)
        tb.AddControl(self.commande)
        self.commande.Bind(wx.EVT_CHAR, self.EvtChar)

        # Final thing to do for a toolbar is call the Realize() method. This
        # causes it to render (more or less, that is).
        tb.Realize()
        tb.Show(param.ligne_commande)


        # Barre de statut
        self.barre = wx.StatusBar(self, -1)
        self.barre.SetFieldsCount(2)
        self.barre.SetStatusWidths([-3, -2])
        self.barre.SetStatusText(u"  Bienvenue !", 1)
        self.barre.SetStatusText(u"WxGéométrie version " + param.version, 0)
        self.SetStatusBar(self.barre)

        # Creation des onglets et de leur contenu
        self.onglets = Onglets(self, -1)

        # Creation des menus
        #self.menus = [onglet.menu(self) for onglet in self.onglets.liste_onglets()]
        #[GeoMenuBar(self), TraMenuBar(self), CalcMenuBar(self)]


        #affiche le menu
        #self.changer_menu(0)

        # historique de la toolbar
        self.historique = []
        self.commande_en_cours = ""
        self.commande_en_cours_a_sauvegarder = True
        self.position = -1

        self.console = Console(self)

        self.Bind(wx.EVT_CLOSE, self.OnClose)

        self.SetDropTarget(ReceptionDeFichiers(self))
        self.SetFocus()

        #self.DragAcceptFiles(True)
        #self.Bind(wx.EVT_DROP_FILES, self.OnDrop)

        # Création (si nécessaire) des répertoires /log, /macro, etc., définis dans /param/__init__.py
        for repertoire in param.emplacements.values():
            repertoire = path2(repertoire)
            if not os.path.isdir(repertoire):
                try:
                    os.makedirs(repertoire)
                except IOError:
                    print_error()




#####################################################################





    #def recharger(self, event):
    #    reload(param)
    #
    #    self.onglets.onglet_actuel.historique.rafraichir()
    #    self.barre.SetStatusText("Parametres et figure recharges.", 0)

    def message(self, texte, lieu = 0):
        self.barre.SetStatusText(texte, lieu)

    def titre(self, texte = u""):
        if texte:
            self.SetTitle(u"WxGéométrie - " + unicode2(texte))
        else:
            self.SetTitle(u"WxGéométrie")




    def EvtChar(self, event):    # gere la ligne de commandes
        commande = self.commande.GetValue()
        code = event.GetKeyCode()

        if self.commande_en_cours_a_sauvegarder and commande.strip():
            self.commande_en_cours = commande
            self.commande_en_cours_a_sauvegarder = False

        if code == wx.WXK_RETURN or code == wx.WXK_NUMPAD_ENTER:
            try:
                self.console.executer(commande)
                self.barre.SetStatusText(u"Commande interne exécutée.", 0)
                self.historique.append(commande)
                self.commande_en_cours = ""
                self.position = len(self.historique) - 1
                self.commande.Clear()
            except:
                self.barre.SetStatusText(u"Commande incorrecte.", 0)
                if param.debug:
                    raise

        elif code == wx.WXK_UP:   # on remonte dans l'historique des commandes
            if self.position >= 0:
                if self.position == len(self.historique):
                    self.commande.SetValue(self.commande_en_cours)
                else:
                    self.commande.SetValue(self.historique[self.position])
                self.position = self.position - 1

        elif code == wx.WXK_DOWN:   # on redescend dans l'historique vers les commandes recentes
            if self.position < len(self.historique) -1 or (self.position == len(self.historique) -1 and self.commande_en_cours):
                if self.position == (len(self.historique) - 2):
                    self.commande.SetValue(self.commande_en_cours)
                elif self.position == (len(self.historique) - 1):
                    self.commande.Clear()
                else:
                    self.commande.SetValue(self.historique[self.position + 2])
                self.position += 1
        else:
            event.Skip()
            self.commande_en_cours_a_sauvegarder = True


    def OnClose(self, event):
        if not param.fermeture_instantanee: # pour des tests rapides
            try:
                if param.confirmer_quitter:
                    panel = self.onglets.onglet_actuel
                    if hasattr(panel, u"canvas") and hasattr(panel.canvas, u"Freeze"):
                        panel.canvas.Freeze()
                    dlg = wx.MessageDialog(self, u'Voulez-vous quitter WxGéométrie ?', u'Quitter WxGéométrie ?', wx.YES_NO | wx.ICON_QUESTION)
                    reponse = dlg.ShowModal()
                    if hasattr(panel, u"canvas") and hasattr(panel.canvas, u"Thaw"):
                        panel.canvas.Thaw()
                    dlg.Destroy()
                    if reponse != wx.ID_YES: return

                if param.sauvegarder_preferences:
                    fgeo = sauvegarder_module(param)
                    fgeo.ecrire(path2(param.emplacements["preferences"] + "/parametres.xml"))
                    for onglet in self.onglets.liste_onglets():
                        try:
                            onglet.sauver_preferences()
                        except:
                            debug(u"Fermeture incorrecte de l'onglet : ", unicode2(str(onglet)))
                            raise

                if param.enregistrer_messages and param.debug:
                    filename = path2(param.emplacements["log"] + u"/messages.log")
                    f = open(filename, u"w")
                    if self.application.stdioWin and hasattr(self.application.stdioWin, u"text") and self.application.stdioWin.text:
                        texte = self.application.stdioWin.text.GetValue()
                        if isinstance(texte, unicode):  # version unicode de WxPython
                            texte = texte.encode(param.encodage) # Par défaut, Python tente de le convertir en str à l'aide du codec ASCII
                        f.write(texte) # on copie les messages (erreurs...) dans messages.log
                    f.close()

                if self.application.stdioWin:   # fermeture de la fenetre de messages
                    self.application.stdioWin.close()

                for onglet in self.onglets.liste_onglets():
                    try:
                        if isinstance(onglet, Panel_API_graphique):
                            if param.historique_log:
                                onglet.log.archiver()
                            onglet.fermer_feuilles()
                    except:
                        #print_error()
                        debug(u"Fermeture incorrecte de l'onglet : ", unicode2(str(onglet)))
                        raise

            except:
                wx.lib.dialogs.ScrolledMessageDialog(self, traceback.format_exc(), u"Erreur lors de la fermeture du programme").ShowModal()
        else: # mode 'fermeture instantanée' (à utiliser seulement lors du développement)
            try:
                self.application.stdioWin.close()
            except:
                pass
        event.Skip()
