/********************************* CApp.cpp ***************************************
 *                                                                                *
 *   #include CApp.h"                                                             *
 *   Project: MedinTux                                                            *
 *   Copyright (C) 2003 2004 2005 by Sevin Roland  and Data Medical Design        *
 *   E-Mail: data.medical.design@club-internet.fr                                 *
 *                                                                                *
 *   This program is free software; you can redistribute it and/or modify         *
 *   it under the terms of the CeCILL Version 1 du 21/06/2004                     *
 *   License (GPL compatible)                                                     *
 *                              http://www.cecill.info/                           *
 *   as published by :                                                            *
 *                                                                                *
 *   Commissariat à l'Energie Atomique                                            *
 *   - CEA,                                                                       *
 *                            31-33 rue de la Fédération, 75752 PARIS cedex 15.   *
 *                            FRANCE                                              *
 *   Centre National de la Recherche Scientifique                                 *
 *   - CNRS,                                                                      *
 *                            3 rue Michel-Ange, 75794 Paris cedex 16.            *
 *                            FRANCE                                              *
 *   Institut National de Recherche en Informatique et en Automatique             *
 *   - INRIA,                                                                     *
 *                            Domaine de Voluceau, Rocquencourt, BP 105, 78153    *
 *                            FRANCE                                              *
 *                                                                                *
 *         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.                   *
 *         CeCILL  License (GPL compatible) for more details.                     *
 *                                                                                *
 **********************************************************************************/
//
//    mysqldump --quote-name --compatible=mysql323 CCAMTest | gzip > /home/ro/CCAMTest.gz
//    Les spectatrices ne veulent pas qu'on les ennuie dans la file.
#include <qdir.h>
#include <qfileinfo.h>
#include <qtextcodec.h>
#include <qmessagebox.h>
#include <qcheckbox.h>
#include <qprocess.h>
#include <qeventloop.h>
#include <qfiledialog.h> 
#include <qclipboard.h> 
#include <qdragobject.h> 
#include "CPreview.h"

#include "CApp.h"
#include "../../MedinTuxTools/cdlg_passwordget.h"
#include "Rubriques.h"
#include "Dlg_MedicaTux.h"
//#include "CMDI_GroupedView.h"
#include "CMDI_Prescription.h"
#include "CMDI_Observation.h"
#include "CMDI_Terrain.h"
#include "CMDI_Documents.h"
#include "CMDI_Ident.h"
#include "CMDI_ChoixPatient.h"
#include "drtux.h"
#include "CMDI_Generic.h"

/*! \class CApp
 * Instance générale de l'application
*/

CApp* G_pCApp = 0;  // contiendra l'instance globale de l'application

//--------------------------------------------- CApp -------------------------------------------------------------------
CApp::~CApp()
{
 #ifdef COMMERCIAL_VERSION
    if (m_pCps)
       {delete m_pCps;
        m_pCps = 0;
       }
 #endif

if (m_pCMoteurBase)
  {delete m_pCMoteurBase;
   m_pCMoteurBase = 0;
  }

if (m_pCMedicaBase)
   {delete m_pCMedicaBase;
    m_pCMedicaBase = 0;
   }
QMimeSourceFactory::removeFactory ( &m_C_ImageList );      // ne rend plus dispo la liste d'images au système (car va être détruite)
}

//--------------------------------------------- CApp -------------------------------------------------------------------......................
CApp::CApp(QString mui_name, int & argc, char ** argv)
    : C_MUI_App(mui_name,  argc, argv )
{   QTextCodec::setCodecForTr( QTextCodec::codecForName("utf8") );
    //........................... iniitaliser variables à zero ...............................................................................
    m_pCMoteurBase           = 0;          // moteur de la base de donnée
    m_pCMedicaBase           = 0;          // moteur de la base de donnée medicaments
#ifdef COMMERCIAL_VERSION
    m_pCps                   = 0;          // moteur de la carte vitale
#endif
    //............................ ok cette appli est déjà active, la mettre au premier plan (sort avec G_pCApp = 0 ) .......................
    //                             mettre absoluement aprés initialisation des variables m_pCMoteurBase et  m_pCMedicaBase m_pCps à zero
    //                             car testées si zero lors passage dans destructeur  ~CApp()
    if (sendMessage("Wake up!") )  { activateMainWidget ();  return ; }

    //.................... recuperer path de demarrage de l'appli ...........................
    QFileInfo qfi(argv[0]);
    m_PathAppli              =  CGestIni::Construct_PathBin_Module("drtux",  qfi.dirPath (true));
    m_pDrTux                 = 0;
    m_pCMoteurBase           = 0;          // moteur de la base de donnée
    m_pCMedicaBase           = 0;          // moteur de la base de donnée medicaments
    m_pAtcd_Code             = 0;          // moteur des antécédents
    m_User                   = "";
    m_SignUser               = "";
    m_CriptedPassWord        = "";
    m_Droits                 = "";
    m_MessVisuDocNotPossible = TR("Vous ne possédez pas les droits\nvous permettant de voir ce document");
    m_IsAppStartWithUser     = FALSE;
    m_TimerVerrouDelay       = 0;
    m_LastError              = "";
    m_DrTuxParam             = "";
    QMimeSourceFactory::addFactory ( &m_C_ImageList );            // rend dispo la liste d'images au système
    //.............................. initialiser variables locales ..........................................
    QString qstr           = "";
    QString val1           = "";
    QString val2           = "";
    QString val3           = "";
    QString val4           = "";
    QString qstr2          = "";
    QString baseCfg        = "";

    //.............................. initialiser variables membres ..........................................
    //m_ListRubName.append(CMDI_GroupedView::S_GetRubName());
    m_ListRubName.append(CMDI_Observation::S_GetRubName());
    m_ListRubName.append(CMDI_Prescription::S_GetRubName());
    m_ListRubName.append(CMDI_Documents::S_GetRubName());
    m_ListRubName.append(CMDI_Terrain::S_GetRubName());
    m_ListRubName.append(CMDI_Ident::S_GetRubName());
    m_ListRubName.append(CMDI_ChoixPatient::S_GetRubName());

    m_Atcd_SortBy      = CApp::SortByRubrique;           // Valeur par défaut pour trie des ATCD : par rubrique
    m_Var_SortBy       = CApp::SortByDate;               // Valeur par défaut pour trie des variables : par date
    m_VarValue_SortBy  = CApp::SortByDate;               // Valeur par défaut pour trie des variables : par date


    //              const char* user    /* = 0*/,  const char *sign_user    /* = 0*/, const char* num_GUID   /* = 0*/,  const char* id_doss /* = 0*/,
    //              const char* dossNom /* = 0*/,  const char *dossPrenom   /* = 0 */,
    //              const char *iniFile /* = 0*/,  const char *cfgBaseFile  /* = 0*/

    //....................... charger le fichier de configuration des bases ..................................
    //                        il peut etre soit donne dans les arguments soit à aller chercher en local
    if (argc >= 8 && argv[8])       m_PathCfg_Base =     argv[8];
    else                            m_PathCfg_Base =     m_PathAppli + "DataBase.cfg";
    CMoteurBase::Param_UpdateFromDisk(m_PathCfg_Base, baseCfg);

    //.......................Charger le chemin du fichier de configuration .............................................
    //                       il peut etre soit donne dans les arguments soit à aller chercher en local
    if (argc >= 7 &&  argv[7])      m_PathDrTuxIni =     argv[7];
    else                            m_PathDrTuxIni =     m_PathAppli + "drtux.ini";

    //.......................Charger les parametres de connexion .............................................
    CMoteurBase::Param_UpdateFromDisk(m_PathDrTuxIni, m_DrTuxParam);

   //................................ initialiser les différents chemins Globaux ............................
   if (CMoteurBase::Param_ReadParam( m_DrTuxParam, "Glossaire", "Path", &m_PathGlossaire) !=0 ) // zero = pas d'erreur
    { m_PathGlossaire =  m_PathAppli + "Glossaire/";
    }
   // Gère répertoire relatif, répertoire utilisateur, autres
   if (m_PathGlossaire[0] == '.') 
      {  if (QDir(m_PathGlossaire).isRelative())
            {m_PathGlossaire.prepend(m_PathAppli);
            }
      }
   else if ( (m_PathGlossaire[0] == '~') || (m_PathGlossaire[0] == '$') )
      {  m_PathGlossaire.replace("~", QDir::homeDirPath() );
         m_PathGlossaire.replace("$home", QDir::homeDirPath(), false);
      }


    /* old
    //................................ initialiser les différents chemins Globaux ............................
    if (CMoteurBase::Param_ReadParam( m_DrTuxParam, "Glossaire", "Path", &m_PathGlossaire) !=0 )  // zero = pas d'erreur
       { m_PathGlossaire =  m_PathAppli + "Glossaire/";
       }
    if (QDir(m_PathGlossaire).isRelative()) m_PathGlossaire.prepend(m_PathAppli);
    old */
    if (CMoteurBase::Param_ReadParam( m_DrTuxParam, "Theme", "Path", &m_PathTheme) !=0 )  // zero = pas d'erreur
       { m_PathTheme     =  "../../Themes/Default/"; 	// valeur par défaut
       }
    if (!QDir(m_PathTheme).exists()) m_PathTheme     =  "../../Themes/Default/"; 	// valeur par défaut
    if (QDir(m_PathTheme).isRelative()) m_PathTheme.prepend(m_PathAppli);
    m_PathTheme = QDir::cleanDirPath(m_PathTheme) + "/";
    Theme::setPath(m_PathTheme);
//    Theme::createDefaultIniFile();

    //.................... je nettoie le path et rajoute / à la fin ..........................................
    m_PathGlossaire         =  QDir::cleanDirPath(m_PathGlossaire) + "/";
    m_PathTerrain           =  m_PathGlossaire + "Terrain/";
    m_PathImages            =  m_PathAppli     + "Ressources/";

    //.............................. delay de verification du verrrou .................................
    CMoteurBase::Param_ReadParam( m_DrTuxParam, "Connexion", "Verification Verrou", &val1 );  // splash utilisé provisoirement
    if (val1.length()) m_TimerVerrouDelay = val1.toInt();

    //................................lire les parametres de connexion ...................................................
    //                          ouvrir et initialiser le moteur de base de données
    if (CMoteurBase::Param_ReadParam( m_DrTuxParam, "Connexion", "Parametres", &val1, &val2, &val3, &val4, &qstr) ==0)  // zero = pas d'erreur
       { m_pCMoteurBase = new CMoteurBase( val1 ,                   // nom du driver: "QODBC3" "QMYSQL3" "QPSQL7"
                                           val2,                    // nom de la base: si QODBC3 -> nom de la source de données (userDSN)
                                           val3,                    // = "root"       user
                                           val4,                    // = ""           password
                                           qstr,                    // = "localhost"  hostname  qstr
                                           baseCfg,
                                           &m_LastError);
       }
   else
       {m_LastError = TR("<u><br>Les données de connexion :</u><br>          Section : <b>Connexion</b>, <br>          Variable : <b>Parametres</b> : Driver, BaseName,User, Password, Hostname <br> n'ont pas été trouvées dans le fichier : \n<b>") + m_PathDrTuxIni + "</b>";
       }
   if (m_pCMoteurBase==0)                {                                         m_LastError.prepend(TR("<u>ECHEC DE LA CONNEXION A LA BASE DE DONNÉE : </u>     m_pCMoteurBase ==0 <br>"));              return;}
   if (m_pCMoteurBase->m_DataBase ==0)   {delete m_pCMoteurBase; m_pCMoteurBase=0; m_LastError.prepend(TR("<u>ECHEC DE LA CONNEXION A LA BASE DE DONNÉE : </u>     m_pCMoteurBase->m_DataBase == 0 <br>")); return;}
   //......................... initialiser la base therapeutique ................................................
   m_pCMedicaBase = new CMedicaBase(m_PathAppli + "MedicaBase.ini", m_PathAppli + "MedicaBase.cfg");
   if (m_pCMedicaBase==0) {delete m_pCMoteurBase; m_pCMoteurBase=0;
                           m_LastError = TR("La base de données thérapeutique n'a pu être initialisée correctement");
                           return;
                          }
    //..................................... utilisateurs ...........................................................
    //                        il peut etre soit donne dans les arguments soit à aller chercher en local
    if (argc >= 1 && argv[1])       m_User     =     argv[1];
    else                            m_User     =     "";
    if (argc >= 2 && argv[2])       m_SignUser =     argv[2];
    else                            m_SignUser =     "";
    //....................... identification utilisateur .............................................................
    //                        si vide, (=="") aller chercher dans fichier DrTux.ini
    m_IsAppStartWithUser = FALSE;
    if ( m_User.length() == 0 )
       {CMoteurBase::Param_ReadParam( m_DrTuxParam, "Derniere Session", "Utilisateur", &m_User, &m_SignUser);  // zero = pas d'erreur
        CMoteurBase::Param_ReadParam( m_DrTuxParam, "Derniere Session", "Password",    &m_CriptedPassWord);
        if (m_CriptedPassWord.left(1)=="#") m_CriptedPassWord = m_CriptedPassWord.mid(1);                       //  si crypté (precede de #)
        else                                CMoteurBase::PassWordEncode(m_CriptedPassWord);                     //  si non crypté (precede de rien) alors le crypter
        if (   m_User.length() != 0 &&  m_SignUser.length() != 0   &&    m_pCMoteurBase->VerifyUserPassWord(m_User, m_CriptedPassWord) )       //                   mot de passe fourni correct
           { m_IsAppStartWithUser = TRUE;
           }
       }
    else
       {m_IsAppStartWithUser = TRUE;
       }
    //............................. si l'utilisateur est le signataire alors les droit sont les siens ......................................................
    Map_Prefix_Droits();            // initialiser la map des prefix droits type de document

    if (m_User == m_SignUser)
       {m_Droits   = m_pCMoteurBase->GetFieldValue( m_pCMoteurBase->m_USER_IDENT_TBL_NAME,
                                                    m_pCMoteurBase->m_USER_IDENT_DROITS,   // field to get
                                                    m_pCMoteurBase->m_USER_IDENT_LOGIN,    // field to match
                                                    m_User);                                               // value to match
       }
    //............................. si l'utilisateur n'est pas le signataire alors les droits sont ceux accordés par le signataire ........................
    else
       {m_Droits = m_pCMoteurBase->PermsUserIsThisUserFriendFromName(  m_SignUser , m_User);
       }
    CMoteurBase::Param_UpdateFromDisk(m_PathAppli + "Ressources/RubriquesTextes/VisuDocNotPossible.html", m_MessVisuDocNotPossible);
    //.................. si message d'erreur construire un QLabel pour l'afficher ..........................................................

    /*

    new DrTux(argv[1],       // utilisateur
                               argv[2],       // utilisateur signataire
                               argv[3],       // num_doss (GUID dossier)
                               argv[4],       // ID_Doss (fchgnrl2002_nom_prenom WHERE ID_PrimKey = ID_Doss)
                               argv[5],       // nom      dossier
                               argv[6],       // prenom   dossier
                               argv[7],       // Fichier Ini à utiliser
                               argv[8]        // fichier de configuration des bases
                              );

     */
     //................................ initialiser le système d'icones commun ..............................................................
     SetIconTherapeutique();       // positionne le bon symbole selon Vidal ou Medicabase
     // ............................... initialiser le pointeur de gestion des antécédents ..................................................
     // qui sera utilisé par Dock_Menu, CMDI_Terrain et CDevilCrucible
     m_pAtcd_Code = new Atcd_Code();
     if (m_pAtcd_Code)
        {QStringList pListItem;
         CMoteurBase::Param_GetList(m_DrTuxParam, "Terrain", "ATCD chirurgicaux",  pListItem );
         m_pAtcd_Code->init_Get_RubChir(&pListItem );
         CMoteurBase::Param_GetList(m_DrTuxParam, "Terrain", "ATCD medicaux",      pListItem );
         m_pAtcd_Code->init_Get_RubMed(&pListItem );
        }
     //......................... carte PS ....................................................................................................
#ifdef COMMERCIAL_VERSION
     m_pCps = new C_Cps;
     qDebug ("Commercial version");
#else
     qDebug ("Free version");
#endif

    //......................... declarer l'application au ...............................................
    //                          système d'instance unique
    initialize();
    G_pCApp                  =    this;
}

//--------------------------------------------- PathDocumentToType ---------------------------------------------
/*! \brief retourne le type de rubrique associé avec le chemin du document type du Glossaire fourni en entrée
 *  \param path : chemin du document type dont on cherche le type de rubrique auquel il es associé
 *  \return Renvoie le type de rubrique
*/

int CApp::PathDocumentToType( const QString &path , QString *pRubNameToFind)
{QString toFind = "";
 for ( QStringList::Iterator it = m_ListRubName.begin(); it != m_ListRubName.end(); ++it ) 
     {toFind = m_PathGlossaire + *it;
      if  (path.find(toFind )!=-1)   
          { if ( pRubNameToFind ) *pRubNameToFind = *it;
            return RubNameToType(*it);
          }
     }
 if ( pRubNameToFind ) *pRubNameToFind = "";
 return 0;
}

//--------------------------------------------- PathDocumentToType ----------------------------------------------
/*! \brief retourne le type de rubrique le dont le nom le plus probable contenu dans le texte fourni en entrée
 *  \param path : texte dont on cherche le type de rubrique auquel il est associé
 *  \return Renvoie le type de rubrique
*/

int CApp::ApproximativeRubNameToType( const QString &texte , QString *pRubNameToFind)
{QString toFind = "";
 for ( QStringList::Iterator it = m_ListRubName.begin(); it != m_ListRubName.end(); ++it ) 
     {toFind = (*it).left(5);             // on se sert des 5 premieres lettres du nom de la rubrique
      if  (texte.find(toFind )!=-1)   
          { if ( pRubNameToFind ) *pRubNameToFind = *it;
            return RubNameToType(*it);
          }
     }
 if ( pRubNameToFind ) *pRubNameToFind = "";
 return 0;
}

//--------------------------------------------- RubNameToType --------------------------------------
/*! \brief retourne le type de rubrique associée au nom de rubrique fourni en entrée
 *  \param rubName : nom de la rubrique dont on recherche le type
 *  \return Renvoie le type de rubrique
*/
int CApp::RubNameToType( const QString &rubName )
{
      if      (rubName == CMDI_Observation::S_GetRubName())   return CMDI_Observation::S_GetType();
      else if (rubName == CMDI_Prescription::S_GetRubName())  return CMDI_Prescription::S_GetType();
      else if (rubName == CMDI_Terrain::S_GetRubName())       return CMDI_Terrain::S_GetType();
      else if (rubName == CMDI_Documents::S_GetRubName())     return CMDI_Documents::S_GetType();
      else if (rubName == CMDI_Ident::S_GetRubName())         return CMDI_Ident::S_GetType();
      else if (rubName == CMDI_ChoixPatient::S_GetRubName())  return CMDI_ChoixPatient::S_GetType();
     // else if (rubName == CMDI_GroupedView::S_GetRubName())   return CMDI_GroupedView::S_GetType();

 return 0;
}
//--------------------------------------------- RubNameToType ---------------------------------------------
/*! \brief retourne le nom d'une rubrique associée au type de rubrique fourni en entrée
 *  \param typRub : type de la rubrique dont on recherche le nom
 *  \return Renvoie le nom de la rubrique
*/
QString CApp::TypeToRubName( int typRub )
{     if      (typRub == CMDI_Ident::S_GetType())                                                             return CMDI_Ident::S_GetRubName();
      else if (typRub == CMDI_ChoixPatient::S_GetType())                                                      return CMDI_ChoixPatient::S_GetRubName();
      //else if (typRub == CMDI_GroupedView::S_GetType())                                                       return CMDI_GroupedView::S_GetRubName();
      else if (typRub >= CMDI_Observation::S_GetType()  && typRub <= (CMDI_Observation::S_GetType()  + 999) ) return CMDI_Observation::S_GetRubName();
      else if (typRub >= CMDI_Prescription::S_GetType() && typRub <= (CMDI_Prescription::S_GetType() + 999) ) return CMDI_Prescription::S_GetRubName();
      else if (typRub == 20099999)                                                                            return CMDI_Prescription::S_GetRubName();
      else if (typRub >= CMDI_Terrain::S_GetType()      && typRub <= (CMDI_Terrain::S_GetType()      + 999) ) return CMDI_Terrain::S_GetRubName();
      else if (typRub >= CMDI_Documents::S_GetType()    && typRub <= (CMDI_Documents::S_GetType()    + 999) ) return CMDI_Documents::S_GetRubName();
      else                                                                                                    return QString::null;
}

//--------------------------------------------- GetCurrentRubrique --------------------------------------------
/*! \brief retourne un pointeur sur la rubrique courante (m_pDrTux doit avoir été initialisé ce qui est forcément le cas lors de l'appel)
 *  \param pRubName : pointeur sur une QString qui si il n'est pas nul contiendra le nom de la rubrique courante
 *  \param rub_type_ret : pointeur sur un int qui si il n'est pas nul contiendra le type de la rubrique
 *  \param ppCRubRecord : pointeur sur un pointeur sur CRubRecord  qui si il n'est pas nul contiendra un pointeur sur l'enregistrement en cours
 *  \return Renvoie un pointeur sur la rubrique en cours sinon vide (NULL)
*/

CMDI_Generic *CApp::GetCurrentRubrique(QString *pRubName /*=0*/, int* rub_type_ret  /*=0*/ , CRubRecord **ppCRubRecord/*=0*/ )
{if (m_pDrTux)
    {return (CMDI_Generic*) m_pDrTux->GetCurrentRubrique(pRubName,  rub_type_ret , ppCRubRecord);
    }
 return 0;
}

//--------------------------------------------- IsThisDroitExist ----------------------------------------------
/*! \brief Vérifie si le droit : droitToFind  (trois caractères style med adm sgn ....) existe dans la chaine de droits : listDroits 6 fois plus rapide que : listDroits.find(droitToFind) != -1
*/
bool CApp::IsThisDroitExist(const char *listDroits, const char *droitToFind)
{char *pt  = (char*)listDroits;
 while (*pt)
    {if (pt[1]==droitToFind[0] && pt[2]==droitToFind[1] &&pt[3]==droitToFind[2]) return TRUE;
     pt += 4;
    }
 return FALSE;
}

//--------------------------------------------- SetIconTherapeutique ---------------------------------------------
/*! \brief Selon que l'utilisateur va utiliser DataSemp ou une base thérapeutique l'icone change. L'icone est stocké dans m_IconTherapeutique.
*/
int CApp::SetIconTherapeutique()
{
 if ((int)(m_pCMedicaBase->Medica_GetBaseMode() & CMedicaBase::Datasemp))
    { m_IconTherapeutique = Theme::getIconVidal();
      return CMedicaBase::Datasemp;
    }
 else
    { m_IconTherapeutique = Theme::getIconMedicaments();
      return CMedicaBase::MedicaBase;
    }
}

//--------------------------------------------- Map_Prefix_Droits -------------------------------------------------------------------
/*! \brief Creation d'une map type_document   prefix du droit allant avec ce prefix sera suffixé par 'v' pour voir 'c' pour créer 'm' pour modifier 'p' pour imprimer  'r' pour renouveler
*/
void CApp::Map_Prefix_Droits()
{QString key           =    "";
 QString prefix        =    "";
 QString defaut_map    =    "";
 CMoteurBase::Param_UpdateFromDisk(m_PathAppli+"Ressources/prefix_map.txt", defaut_map);       // charger le fichier de map
 if (defaut_map.length()==0)
    {defaut_map     =    "#define TYP_ORDO_CALC    |20020100|or\n"
                         "#define TYP_ORDONNANCE   |20020200|or\n"
                         "#define TYP_CERTIFICAT   |20020300|ce\n"
                         "#define TYP_COURRIER     |20020500|co\n";
    }
 defaut_map.replace("\r\n",  "\n");
 defaut_map.replace("\r"  ,  "\n");
 QStringList lines_list = QStringList::split("\n", defaut_map);
 for ( QStringList::Iterator it = lines_list.begin(); it != lines_list.end(); ++it )
     {QStringList param_list = QStringList::split('|', *it);
      key                   = param_list[1];
      prefix                = param_list[2];
      m_mapDroitPrefix[key] = prefix;
     }
}

//--------------------------------------------- GetMap_Prefix_Droits -------------------------------------------------------------------
QString CApp::GetMap_Prefix_Droits(const QString &doc_Type)
{//QMap<QString, QString>::iterator mt = G_pCApp->m_mapDroitPrefix.find (doc_Type);
 //return *mt;
 return *(G_pCApp->m_mapDroitPrefix.find (doc_Type));
}

//--------------------------------------------- IsAppStartWithUser -------------------------------------------------------------------
bool CApp::IsAppStartWithUser()
{return m_IsAppStartWithUser;
}

//--------------------------------------------- AuthentifyAndSelectUser -------------------------------------
/*! \brief non documenté */
//  Oh dieux qui etes aux cieux
//  Reglez vos comptes en cieux
//
int CApp::AuthentifyAndSelectUser(QWidget * parent, const QString &newUser, const QString &newSignUser, bool /*passwordMustBeRecorded  = 1 */)
{int                          ok = 0;
 QString        cripted_password = "";
 QString        userPk           = m_pCMoteurBase->GetUserPrimKey( newUser, &cripted_password );
 //........................ verifier si des fois que sans mot de passe ..................................
 if (m_pCMoteurBase->VerifyUserPassWord(newUser, ""))
    { m_User            = newUser;
      m_SignUser        = newSignUser;
      m_CriptedPassWord = "";
      //saveLastUserOn_Ini(newUser, newSignUser, "", passwordMustBeRecorded);
      ok = 1;
    }
 //................ sinon demander le mot de passe ..................................
 else
    {CDlg_PasswordGet *dlg = new CDlg_PasswordGet(&cripted_password, parent);
    if (dlg == 0)             return ok;

     if (dlg->exec()==QDialog::Accepted && m_pCMoteurBase->VerifyUserPassWord(newUser, cripted_password) )
        {m_CriptedPassWord = cripted_password;
         m_User            = newUser;
         m_SignUser        = newSignUser;
         saveLastUserOn_Ini(newUser, newSignUser, cripted_password, dlg->IsPasswordMustBeRecord());
         ok = 1;
        }
     delete dlg;
    }
 return ok;
}
//---------------------------------------------- saveLastUserOn_Ini -----------------------------------------
/*! \brief non documenté */
void CApp::saveLastUserOn_Ini(const QString &user, const QString &signUser, const QString &cripted_password, bool passwordMustBeRecorded /* = 1 */)
{
     if ( passwordMustBeRecorded )
        {CMoteurBase::Param_WriteParam( &m_DrTuxParam, "Derniere Session", "Password",    QString("#") + cripted_password);
         CMoteurBase::Param_WriteParam( &m_DrTuxParam, "Derniere Session", "Utilisateur", user, signUser);
         CMoteurBase::Param_UpdateToDisk(m_PathDrTuxIni, m_DrTuxParam);
        }
     else
        {CMoteurBase::Param_WriteParam( &m_DrTuxParam, "Derniere Session", "Password", "");
         CMoteurBase::Param_WriteParam( &m_DrTuxParam, "Derniere Session", "Utilisateur", "", "");
         CMoteurBase::Param_UpdateToDisk(m_PathDrTuxIni, m_DrTuxParam);
        }
}

//---------------------------------- GetImageFile -----------------------------------------------------------------------------
/*! \brief recupère avec le selecteur de fichier un non de fichier d'image 
 *  \return une QString qui contient le nom du fichier d'image ou vide si annulation ou fichier inexistant.
*/

QString CApp::GetImageFileName(QString *last_path /* = 0 */, QString stringPreselect /*=""*/, int prewiew /*=1*/)
{   //.................................. selectionner le ficher ..................................
    QString filename  = "";
    QString        fn = "";
    QString  outParam = "";

    if (fn .length()==0 && last_path)     fn = *last_path;
    if (fn .length()==0)                  fn = QFileInfo (qApp->argv()[0]).dirPath (true);

    if (stringPreselect.length()==0)
       {stringPreselect = TR( "Fichiers IMAGE (*.jpg *.jpeg *.png *.PNG *.gif *.GIF *.JPEG *.JPG);;"
                                             "Tous les fichiers (*)");
       }
    //................. choisir le fichier image src à insérer .................................................
    QFileDialog *fd = new QFileDialog  ( fn,
                                         stringPreselect ,
                                         0,
                                         "OuvrirDlg"
                                        ) ;
    if (fd==0)                                            return filename;
    CPreview*     p = 0;
    if (prewiew)  p = new CPreview;
    if (p)
       { fd->setInfoPreviewEnabled( TRUE );
         fd->setInfoPreview( p, p );
         fd->setPreviewMode( QFileDialog::Info );
       }
    if ( (fd->exec() == QDialog::Accepted) )
       {filename = fd->selectedFile();
        if ( QFile::exists( filename )==0 ) filename = "";
        if ( filename.length() )
           { if (last_path) *last_path = QFileInfo(filename).dirPath ( TRUE );
           }
       }
    delete fd;
    return filename;
}
