/****************************************************************************
**
** Copyright (C) 2002-2006 Tilo Riemer <riemer@crossvc.com>,
**                         Frank Hemer <frank@hemer.at>,
**                         Jose Hernandez <joseh@tesco.net> and
**                         Joerg Preiss <auba@auba.de>
**
**
**----------------------------------------------------------------------------
**
**----------------------------------------------------------------------------
**
** CrossVC is available under two different licenses:
**
** If CrossVC is linked against the GPLed version of Qt 
** CrossVC is released under the terms of GPL also.
**
** If CrossVC is linked against a nonGPLed version of Qt 
** CrossVC is released under the terms of the 
** CrossVC License for non-Unix platforms (CLNU)
**
**
** CrossVC License for non-Unix platforms (CLNU):
**
** Redistribution and use in binary form, without modification, 
** are permitted provided that the following conditions are met:
**
** 1. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 2. It is not permitted to distribute the binary package under a name
**    different than CrossVC.
** 3. The name of the authors may not be used to endorse or promote
**    products derived from this software without specific prior written
**    permission.
** 4. The source code is the creative property of the authors.
**    Extensions and development under the terms of the Gnu Public License
**    are limited to the Unix platform. Any distribution or compilation of 
**    the source code against libraries licensed other than gpl requires 
**    the written permission of the authors.
**
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR 
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 
** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
** GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
**
**
** CrossVC License for Unix platforms:
**
** 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, version 2 of the License.
** 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 version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
**
*****************************************************************************/

#ifndef CVSLIB_CVSCONFIG
#define CVSLIB_CVSCONFIG

//----------------------------------------------------------------------------

#include "config.h"

//----------------------------------------------------------------------------

#include <qrect.h>
#include <qsettings.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qmessagebox.h>
#include <qcolor.h>

//----------------------------------------------------------------------------

#include "globals.h"
#include "TextCodec.h"

//----------------------------------------------------------------------------


/*!	This class implements all configurable Items of lincvs.
  \brief Configuration class.
*/
class CvsConfig
{
   static const char Version[];
   static const char Debug[];
   static const char LogLevel[];
   static const char VeryFirstStart[];
   static const char CheckStatusIntervall[];
   static const char CheckStatusLevel[];
   static const char ProgressIntervall[];

   static const char AutoUpdate[];
   static const char AutoUpdateIntervall[];

   static const char cvsPassFile[];
   static const char cvsPath[];
   static const char cvsVersion[];
   static const char useDirWatch[];

   static const char DirPopupMenu[];
   static const char FilePopupMenu[];
   static const char KeyboarsShortcuts[];
   static const char OpenFileList[];
   static const char ViewFileList[];
   static const char ScanOnTheFly[];
   static const char ScanNonCvs[];
   static const char CvsIgnoreFiles[];
   static const char UseExternalDiff[];
   static const char ExtDiffProgram[];
   static const char IconDir[];
   static const char ColorRevA[];
   static const char ColorRevB[];
   static const char UseStandardDialogs[];
   static const char DateTimeOrder[];
   static const char DateTimeFormat[];
   static const char Use0AsParent[];
   static const char TopLevelWidget[];
   
   static const char GeomX[];
   static const char GeomY[];
   static const char GeomWidth[];
   static const char GeomHeight[];
   static const char SplitterPosH[];
   static const char SplitterPosV[];
   static const char WorkbenchColumnWidth[];
   static const char ToolbarPos[];
   static const char FileHeaderPos[];

   static const char Compression[];
   static const char RwPermission[];
   static const char VirtualInFiletab[];
   static const char DiffPrecision[];
   static const char UnifiedDiffOutput[];

   static const char PruneDirs[];
   static const char BringOverNewDirs[];
   static const char KeywordSuppression[];
   static const char IgnoreWhiteSpace[];
   static const char HistoryPeriod[];
   static const char Quiet[];

   static const char SshKeyList[];
   static const char SshAgent[];
   static const char RemoteBrowser[];
   static const char LocalBrowser[];
   static const char CVSRsh[];
   static const char LocalShell[];

   static const char UserList[];
   static const char ServerList[];
   static const char RepositoryList[];
   static const char ProfileList[];
   static const char XProfileList[];
   static const char ModuleList[];
   static const char WorkdirList[];
   static const char CheckoutAsList[];
   static const char ProxyList[];
   static const char BinaryFileSpecList[];

   static const char HistSizeComments[];
   static const char HistSizeWorkdirs[];
   static const char HistSizeProfiles[];

   static const char Projects[];

   //Syntax highlighting of messagewidget
   static const char UseSyntaxHighlight[];
   static const char SynHighQuestionMarkStyle[];
   static const char SynHighQuestionMarkRgb[];
   static const char SynHighModifiedStyle[];
   static const char SynHighModifiedRgb[];
   static const char SynHighNeedsUpdateStyle[];
   static const char SynHighNeedsUpdateRgb[];
   static const char SynHighMergingStyle[];
   static const char SynHighMergingRgb[];
   static const char SynHighConflictStyle[];
   static const char SynHighConflictRgb[];
   static const char SynHighAddedStyle[];
   static const char SynHighAddedRgb[];
   static const char SynHighRemovedStyle[];
   static const char SynHighRemovedRgb[];
   static const char SynHighRemovedByOtherStyle[];
   static const char SynHighRemovedByOtherRgb[];
   static const char SynHighDiffOldStyle[];
   static const char SynHighDiffOldRgb[];
   static const char SynHighDiffNewStyle[];
   static const char SynHighDiffNewRgb[];
   static const char SynHighScmErrStyle[];
   static const char SynHighScmErrRgb[];

   //fonts
   static const char FontGeneral[];
   static const char FontMessage[];
   static const char FontDiff[];

   //i18n
   static const char TextEncoder[];
   static const char TextDecoder[];
   
   //defaults
   static const char defCvsPath[];
   static const char defCvsVersion[];
   static const char defSshAgent[];
   static const char defRemoteBrowser[];
   static const char defLocalBrowser[];
   static const char defCvsRsh[];
   static const char defLocalShell[];
   static const char defCvsIgnoreFiles[];
   static const char defKeyboarsShortcuts[];
   static const char defOpenFileList[];
   static const char defViewFileList[];

      
public:
   CvsConfig();
   ~CvsConfig();


   void readCfg();
   void writeCfg();

   bool debug() {
      return m_pSettings->readBoolEntry(Debug, false);
   }
   void setDebug(bool dbg) {
      m_pSettings->writeEntry(Debug, dbg);
   }
   Debug::LogLevel logLevel() {
      switch (m_pSettings->readNumEntry(LogLevel, 0)) {
	 case 0:  return Debug::LL_LIKE_A_FISH;
	 case 1:  return Debug::LL_THE_OLD_MAN_AND_THE_SEA;
	 case 2:  return Debug::LL_INFO;
	 case 3:  return Debug::LL_DEBUG;
	 case 4:  return Debug::LL_GOSSIP_MONGER;
	 default: return Debug::LL_LIKE_A_FISH;
      }
   }
   bool setLogLevel(int level) {
      return m_pSettings->writeEntry(LogLevel, level);
   }
   bool getVeryFirstStart(bool bVeryFirstStart) {
      return m_pSettings->readBoolEntry(VeryFirstStart, bVeryFirstStart);
   }
   void setVeryFirstStart(bool bVeryFirstStart) {
      m_pSettings->writeEntry(VeryFirstStart, bVeryFirstStart);
   }
   QString getCvsPassPath() {
      return m_pSettings->readEntry(cvsPassFile, CVSPASSPATH);
   }
   void setCvsPassPath(QString& file) {
      m_pSettings->writeEntry(cvsPassFile,file);
   }
   QString getCvsPath() {
      return m_pSettings->readEntry(cvsPath, defCvsPath);
   }
   void setCvsPath(QString& path) {
      m_pSettings->writeEntry(cvsPath,path);
   }
   QString getCvsVersion() {
      return m_pSettings->readEntry(cvsVersion, defCvsVersion);
   }
   void setCvsVersion(QString& version) {
      m_pSettings->writeEntry(cvsVersion,version);
   }
   bool getUseDirWatch() {
      return m_pSettings->readBoolEntry(useDirWatch, false);
   }
   void setUseDirWatch(bool state) {
      m_pSettings->writeEntry(useDirWatch,state);
   }
   long checkStatusIntervall() {
      return m_pSettings->readNumEntry(CheckStatusIntervall, 3000L);
   }
   bool setCheckStatusIntervall(int val) {
      return m_pSettings->writeEntry(CheckStatusIntervall, val);
   }
   int getCheckStatusLevel() {
      return m_pSettings->readNumEntry(CheckStatusLevel, 1);
   }
   bool setCheckStatusLevel(int val) {
      return m_pSettings->writeEntry(CheckStatusLevel, val);
   }
   long progressIntervall() {
      return m_pSettings->readNumEntry(ProgressIntervall, 117L);
   }
   bool setProgressIntervall(int val) {
      return m_pSettings->writeEntry(ProgressIntervall, val);
   }
   bool getAutoUpdate() {
      return m_pSettings->readBoolEntry(AutoUpdate, false);
   }
   bool setAutoUpdate(bool val) {
      return m_pSettings->writeEntry(AutoUpdate, val);
   }
   long getAutoUpdateIntervall() {
      return m_pSettings->readNumEntry(AutoUpdateIntervall, 30L);
   }
   bool setAutoUpdateIntervall(int val) {
      return m_pSettings->writeEntry(AutoUpdateIntervall, val);
   }
   int splitterPosH() {
      return m_pSettings->readNumEntry(SplitterPosH, 150);
   }
   void setSplitterPosH(int val) {
      m_pSettings->writeEntry(SplitterPosH, val);
   }
   int splitterPosV() {
      return m_pSettings->readNumEntry(SplitterPosV, 150);
   }
   void setSplitterPosV(int val) {
      m_pSettings->writeEntry(SplitterPosV, val);
   }
   int workbenchColumnWidth() {
      return m_pSettings->readNumEntry(WorkbenchColumnWidth, 150);
   }
   void setWorkbenchColumnWidth(int val) {
      m_pSettings->writeEntry(WorkbenchColumnWidth, val);
   }
   QString getToolbarPos() {
      return m_pSettings->readEntry(ToolbarPos, "");
   }
   void setToolbarPos(const QString& fhpos) {
      m_pSettings->writeEntry(ToolbarPos, fhpos);
   }
   QString getFileHeaderPos() {
      return m_pSettings->readEntry(FileHeaderPos, "");
   }
   void setFileHeaderPos(const QString& tbpos) {
      m_pSettings->writeEntry(FileHeaderPos, tbpos);
   }
	
   int compression() {
      return m_pSettings->readNumEntry(Compression, 0);
   }
   void setCompression(int val) {
      if( val < 0 ) val = 0;   //0 means no compression
      if( val > 9 ) val = 9;
      m_pSettings->writeEntry(Compression, val);
   }
   bool rwPermission() {
      return m_pSettings->readBoolEntry(RwPermission, true);
   }
   void setRwPermission(bool permission) {
      m_pSettings->writeEntry(RwPermission, permission);
   }
   bool getShowVirtualInFiletab() {
      return m_pSettings->readBoolEntry(VirtualInFiletab, true);
   }
   void setShowVirtualInFiletab(bool state) {
      m_pSettings->writeEntry(VirtualInFiletab, state);
   }
   int getDiffPrecision() {
      return m_pSettings->readNumEntry(DiffPrecision,2);
   }
   void setDiffPrecision(int val) {
      m_pSettings->writeEntry(DiffPrecision,val);
   }
   bool getUnifiedDiffOutput() {
      return m_pSettings->readBoolEntry(UnifiedDiffOutput, true);
   }
   void setUnifiedDiffOutput(bool state) {
      m_pSettings->writeEntry(UnifiedDiffOutput, state);
   }
   bool pruneDirs() {
      return m_pSettings->readBoolEntry(PruneDirs, true);
   }
   void setPruneDirs(bool bPrune) {
      m_pSettings->writeEntry(PruneDirs, bPrune);
   }
   bool bringOverNewDirs() {
      return m_pSettings->readBoolEntry(BringOverNewDirs, true);
   }
   void setBringOverNewDirs(bool bBringOver) {
      m_pSettings->writeEntry(BringOverNewDirs, bBringOver);
   }
   bool keywordSuppression() {
      return m_pSettings->readBoolEntry(KeywordSuppression, true);
   }
   void setKeywordSuppression(bool bSupp) {
      m_pSettings->writeEntry(KeywordSuppression, bSupp);
   }
   bool getIgnoreWhiteSpace() {
      return m_pSettings->readBoolEntry(IgnoreWhiteSpace, false);
   }
   void setIgnoreWhiteSpace(bool bWS) {
      m_pSettings->writeEntry(IgnoreWhiteSpace, bWS);
   }
   int getHistoryPeriod() {
      return m_pSettings->readNumEntry(HistoryPeriod, -1);
   }
   void setHistoryPeriod(int period) {
      m_pSettings->writeEntry(HistoryPeriod, period);
   }
   bool getQuiet() {
      return m_pSettings->readBoolEntry(Quiet, false);
   }
   void setQuiet(bool bQuiet) {
      m_pSettings->writeEntry(Quiet, bQuiet);
   }

   bool useExtDiff() {
      return m_pSettings->readBoolEntry(UseExternalDiff, false);
   }
   void setUseExtDiff(bool useIt) {
      m_pSettings->writeEntry(UseExternalDiff, useIt);
   }
   QStringList getSshKeyList() {
      QStringList list = m_pSettings->readListEntry(SshKeyList);
      return list;
   }
   void setSshKeyList(QStringList list) {
      m_pSettings->writeEntry(SshKeyList,list);
   }
   QString sshAgent() {
      return m_pSettings->readEntry(SshAgent, defSshAgent);
   }
   void setSshAgent(const QString& prog) {
      m_pSettings->writeEntry(SshAgent, prog);
   }
   QString extDiffProgram() {
      return m_pSettings->readEntry(ExtDiffProgram, "");
   }
   void setExtDiffProgram(const QString& prog) {
      m_pSettings->writeEntry(ExtDiffProgram, prog);
   }
   QString localBrowser() {
      return m_pSettings->readEntry(LocalBrowser, defLocalBrowser);
   }
   void setLocalBrowser(const QString& cmd) {
      m_pSettings->writeEntry(LocalBrowser, cmd);
   }
   QString remoteBrowser() {
      return m_pSettings->readEntry(RemoteBrowser, defRemoteBrowser);
   }
   void setRemoteBrowser(const QString& cmd) {
      m_pSettings->writeEntry(RemoteBrowser, cmd);
   }
   QString localShell() {
      return m_pSettings->readEntry(LocalShell, defLocalShell);
   }
   void setLocalShell(const QString& cmd) {
      m_pSettings->writeEntry(LocalShell, cmd);
   }
   QString CvsRsh() {
      return m_pSettings->readEntry(CVSRsh, defCvsRsh);
   }
   void setCvsRsh(const QString& cmd) {
      m_pSettings->writeEntry(CVSRsh, cmd);
   }
   QRect geometry() {
      return QRect(geomX(), geomY(), geomWidth(), geomHeight());
   }
   void setGeometry(const QRect& rect) {
      setGeomX(rect.x());
      setGeomY(rect.y());
      setGeomWidth(rect.width());
      setGeomHeight(rect.height());
   }
   QString dirPopupMenu() {
      return m_pSettings->readEntry(DirPopupMenu, DEFDIRPOPUPMENU);
   }
   void setDirPopupMenu(const QString& items) {
      m_pSettings->writeEntry(DirPopupMenu, items);
   }
   QString filePopupMenu() {
      return m_pSettings->readEntry(FilePopupMenu, DEFFILEPOPUPMENU);
   }
   void setFilePopupMenu(const QString& items) {
      m_pSettings->writeEntry(FilePopupMenu, items);
   }
   QString getKeyboardShortcuts() {
      return m_pSettings->readEntry(KeyboarsShortcuts,defKeyboarsShortcuts);
   }
   void setKeyboardShortcuts(const QString& shortcuts) {
      m_pSettings->writeEntry(KeyboarsShortcuts,shortcuts);
   }
   QStringList getOpenFileList() {
      QStringList list = m_pSettings->readListEntry(OpenFileList);
      if (list.count() == 0) list.append(defOpenFileList);
      return list;
   }
   void setOpenFileList(QStringList list) {
      m_pSettings->writeEntry(OpenFileList,list);
   }
   QStringList getViewFileList() {
      QStringList list = m_pSettings->readListEntry(ViewFileList);
      if (list.count() == 0) list.append(defViewFileList);
      return list;
   }
   void setViewFileList(QStringList list) {
      m_pSettings->writeEntry(ViewFileList,list);
   }
   bool getOnTheFlyScanning() {
      return m_pSettings->readBoolEntry(ScanOnTheFly, false);
   }
   void setOnTheFlyScanning(bool scanmode) {
      m_pSettings->writeEntry(ScanOnTheFly, scanmode);
   }
   bool getScanNonCvs() {
      return m_pSettings->readBoolEntry(ScanNonCvs, true);
   }
   void setScanNonCvs(bool scanmode) {
      m_pSettings->writeEntry(ScanNonCvs, scanmode);
   }
   QString cvsIgnoreFiles() {
      return m_pSettings->readEntry(CvsIgnoreFiles, defCvsIgnoreFiles);
   }
   void setCvsIgnoreFiles(const QString& ignore) {
      m_pSettings->writeEntry(CvsIgnoreFiles, ignore);
   }
   QString iconDirectory() {
      return m_pSettings->readEntry(IconDir, "");
   }
   void setIconDirectory(const QString& dir) {
      m_pSettings->writeEntry(IconDir, dir);
   }

   int colorRev(bool bRevARevB_01) {//false: RevA; true: RevB
      if (bRevARevB_01) {
         return m_pSettings->readNumEntry(ColorRevA, 0x00ff0000L);
      } else {
         return m_pSettings->readNumEntry(ColorRevB, 0x0000ff00L);
      }
   }
   void setColorRev(bool bRevARevB_01, int val) {
      if (bRevARevB_01) {
         m_pSettings->writeEntry(ColorRevA, val);
      } else {
         m_pSettings->writeEntry(ColorRevB, val);
      }
   }

   bool getStdDlg() {
      return m_pSettings->readBoolEntry(UseStandardDialogs, true);
   }
   void setStdDlg(bool state) {
      m_pSettings->writeEntry(UseStandardDialogs,state);
   }
   int getDateTimeOrder() {
      return m_pSettings->readNumEntry(DateTimeOrder, QDateEdit().order());
   }
   void setDateTimeOrder( QDateEdit::Order order) {
      m_pSettings->writeEntry(DateTimeOrder,order);
   }
   QString getDateTimeFormat() {
      return m_pSettings->readEntry(DateTimeFormat, "yyyy/MM/dd hh:mm:ss");
   }
   void setDateTimeFormat( QString format) {
      m_pSettings->writeEntry(DateTimeFormat,format);
   }
   bool get0AsParent() {
      return m_pSettings->readBoolEntry(Use0AsParent, true);
   }
   void set0AsParent(bool state) {
      m_pSettings->writeEntry(Use0AsParent,state);
   }
   bool getTopLevelW() {
      return m_pSettings->readBoolEntry(TopLevelWidget, true);
   }
   void setTopLevelW(bool state) {
      m_pSettings->writeEntry(TopLevelWidget,state);
   }
   unsigned int historySizeComments() {
      return m_pSettings->readNumEntry(HistSizeComments, 20);
   }
   void setHistorySizeComments(int size) {
      m_pSettings->writeEntry(HistSizeComments, size);
   }
   unsigned int historySizeWorkdirs() {
      return m_pSettings->readNumEntry(HistSizeWorkdirs, 20);
   }
   void setHistorySizeWorkdirs(int size) {
      m_pSettings->writeEntry(HistSizeWorkdirs, size);
   }
   unsigned int historySizeProfiles() {
      return m_pSettings->readNumEntry(HistSizeProfiles, 20);
   }
   void setHistorySizeProfiles(int size) {
      m_pSettings->writeEntry(HistSizeProfiles, size);
   }
   QStringList userList() {
      return m_pSettings->readListEntry(UserList);
   }   
   void setUserList(const QStringList& l) {
      m_pSettings->writeEntry(UserList, l);
   }
   QStringList serverList() {
      return m_pSettings->readListEntry(ServerList);
   }   
   void setServerList(const QStringList& l) {
      m_pSettings->writeEntry(ServerList, l);
   }
   QStringList repositoryList() {
      return m_pSettings->readListEntry(RepositoryList);
   }   
   void setRepositoryList(const QStringList& l) {
      m_pSettings->writeEntry(RepositoryList, l);
   }
   QStringList profileList() {
      return m_pSettings->readListEntry(ProfileList);
   }   
   void setProfileList(const QStringList& l) {
      m_pSettings->writeEntry(ProfileList, l);
   }
   QStringList xprofileList() {
      return m_pSettings->readListEntry(XProfileList);
   }   
   void setxProfileList(const QStringList& l) {
      m_pSettings->writeEntry(XProfileList, l);
   }
   QStringList moduleList() {
      return m_pSettings->readListEntry(ModuleList);
   }   
   void setModuleList(const QStringList& l) {
      m_pSettings->writeEntry(ModuleList, l);
   }
   QStringList workdirList() {
      return m_pSettings->readListEntry(WorkdirList);
   }   
   void setWorkdirList(const QStringList& l) {
      m_pSettings->writeEntry(WorkdirList, l);
   }
   QStringList getCheckoutAsList() {
      return m_pSettings->readListEntry(CheckoutAsList);
   }   
   void setCheckoutAsList(const QStringList& l) {
      m_pSettings->writeEntry(CheckoutAsList, l);
   }
   QStringList getProxyList() {
      return m_pSettings->readListEntry(ProxyList);
   }   
   void setProxyList(const QStringList& l) {
      m_pSettings->writeEntry(ProxyList, l);
   }
   QStringList getBinaryFileSpecList() {
      return m_pSettings->readListEntry(BinaryFileSpecList);
   }   
   void setBinaryFileSpecList(const QStringList& l) {
      m_pSettings->writeEntry(BinaryFileSpecList, l);
   }

   //syntax highlighting   
   bool getUseSyntaxHighlighting() {
      return m_pSettings->readBoolEntry(UseSyntaxHighlight, true);
   }
   void setUseSyntaxHighlighting(bool bUse) {
      m_pSettings->writeEntry(UseSyntaxHighlight, bUse);
   }
   HighlightProperties::FontStyle getQuestionMarkStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighQuestionMarkStyle, HighlightProperties::FS_NORMAL);
   }
   void setQuestionMarkStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighQuestionMarkStyle, style);
   }
   QColor getQuestionMarkColor() {
      QColor c(Qt::gray);
      c.setRgb(m_pSettings->readNumEntry(SynHighQuestionMarkRgb, c.rgb()));
      return c;
   }
   void setQuestionMarkColor(QColor color) {
      m_pSettings->writeEntry(SynHighQuestionMarkRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getModifiedStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighModifiedStyle, HighlightProperties::FS_NORMAL);
   }
   void setModifiedStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighModifiedStyle, style);
   }
   QColor getModifiedColor() {
      QColor c(Qt::red);
      c.setRgb(m_pSettings->readNumEntry(SynHighModifiedRgb, c.rgb()));
      return c;
   }
   void setModifiedColor(QColor color) {
      m_pSettings->writeEntry(SynHighModifiedRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getNeedsUpdateStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighNeedsUpdateStyle, HighlightProperties::FS_NORMAL);
   }
   void setNeedsUpdateStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighNeedsUpdateStyle, style);
   }
   QColor getNeedsUpdateColor() {
      QColor c(Qt::blue);
      c.setRgb(m_pSettings->readNumEntry(SynHighNeedsUpdateRgb, c.rgb()));
      return c;
   }
   void setNeedsUpdateColor(QColor color) {
      m_pSettings->writeEntry(SynHighNeedsUpdateRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getMergingStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighMergingStyle, HighlightProperties::FS_ITALIC);
   }
   void setMergingStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighMergingStyle, style);
   }
   QColor getMergingColor() {
      QColor c(Qt::blue);
      c.setRgb(m_pSettings->readNumEntry(SynHighMergingRgb, c.rgb()));
      return c;
   }
   void setMergingColor(QColor color) {
      m_pSettings->writeEntry(SynHighMergingRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getConflictStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighConflictStyle, HighlightProperties::FS_BOLD);
   }
   void setConflictStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighConflictStyle, style);
   }
   QColor getConflictColor() {
      QColor c(Qt::magenta);
      c.setRgb(m_pSettings->readNumEntry(SynHighConflictRgb, c.rgb()));
      return c;
   }
   void setConflictColor(QColor color) {
      m_pSettings->writeEntry(SynHighConflictRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getAddedStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighAddedStyle, HighlightProperties::FS_BOLD | HighlightProperties::FS_ITALIC);
   }
   void setAddedStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighAddedStyle, style);
   }
   QColor getAddedColor() {
      QColor c(Qt::red);
      c.setRgb(m_pSettings->readNumEntry(SynHighAddedRgb, c.rgb()));
      return c;
   }
   void setAddedColor(QColor color) {
      m_pSettings->writeEntry(SynHighAddedRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getRemovedStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighRemovedStyle, HighlightProperties::FS_NORMAL);
   }
   void setRemovedStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighRemovedStyle, style);
   }
   QColor getRemovedColor() {
      QColor c(Qt::cyan);
      c.setRgb(m_pSettings->readNumEntry(SynHighRemovedRgb, c.rgb()));
      return c;
   }
   void setRemovedColor(QColor color) {
      m_pSettings->writeEntry(SynHighRemovedRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getRemovedByOtherStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighRemovedByOtherStyle, HighlightProperties::FS_BOLD);
   }
   void setRemovedByOtherStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighRemovedByOtherStyle, style);
   }
   QColor getRemovedByOtherColor() {
      QColor c(Qt::green);
      c.setRgb(m_pSettings->readNumEntry(SynHighRemovedByOtherRgb, c.rgb()));
      return c;
   }
   void setRemovedByOtherColor(QColor color) {
      m_pSettings->writeEntry(SynHighRemovedByOtherRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getDiffOldStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighDiffOldStyle, HighlightProperties::FS_NORMAL);
   }
   void setDiffOldStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighDiffOldStyle, style);
   }
   QColor getDiffOldColor() {
      QColor c(Qt::red);
      c.setRgb(m_pSettings->readNumEntry(SynHighDiffOldRgb, c.rgb()));
      return c;
   }
   void setDiffOldColor(QColor color) {
      m_pSettings->writeEntry(SynHighDiffOldRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getDiffNewStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighDiffNewStyle, HighlightProperties::FS_NORMAL);
   }
   void setDiffNewStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighDiffNewStyle, style);
   }
   QColor getDiffNewColor() {
      QColor c(Qt::blue);
      c.setRgb(m_pSettings->readNumEntry(SynHighDiffNewRgb, c.rgb()));
      return c;
   }
   void setDiffNewColor(QColor color) {
      m_pSettings->writeEntry(SynHighDiffNewRgb, (int)color.rgb());
   }
   HighlightProperties::FontStyle getScmErrStyle() {
      return (HighlightProperties::FontStyle)m_pSettings->readNumEntry(SynHighScmErrStyle, HighlightProperties::FS_BOLD);
   }
   void setScmErrStyle(HighlightProperties::FontStyle style) {
      m_pSettings->writeEntry(SynHighScmErrStyle, style);
   }
   QColor getScmErrColor() {
      QColor c(Qt::red);
      c.setRgb(m_pSettings->readNumEntry(SynHighScmErrRgb, c.rgb()));
      return c;
   }
   void setScmErrColor(QColor color) {
      m_pSettings->writeEntry(SynHighScmErrRgb, (int)color.rgb());
   }
   
   QString getFontGeneral() {
      return m_pSettings->readEntry(FontGeneral, "");  //empty string means default font
   }
   void setFontGeneral(const QString& font) {
      m_pSettings->writeEntry(FontGeneral, font);
   }
   QString getFontMessage() {
      return m_pSettings->readEntry(FontMessage, "");  //empty string means default font
   }
   void setFontMessage(const QString& font) {
      m_pSettings->writeEntry(FontMessage, font);
   }
   QString getFontDiff() {
      return m_pSettings->readEntry(FontDiff, "");  //empty string means default font
   }
   void setFontDiff(const QString& font) {
      m_pSettings->writeEntry(FontDiff, font);
   }

   QString getTextEncoder() {
      return m_pSettings->readEntry(TextEncoder, TextCodec::DEFAULT_CODEC);  //we should use codec for locale
   }
   void setTextEncoder(const QString& encoder) {
      m_pSettings->writeEntry(TextEncoder, encoder);
   }
   QString getTextDecoder() {
      return m_pSettings->readEntry(TextDecoder, TextCodec::DEFAULT_CODEC);  //we should use codec for locale
   }
   void setTextDecoder(const QString& decoder) {
      m_pSettings->writeEntry(TextDecoder, decoder);
   }
   
 protected:
   int geomX() {
      return m_pSettings->readNumEntry(GeomX, 50);
   }
   void setGeomX(int val) {
      m_pSettings->writeEntry(GeomX, val);
   }
   int geomY() {
      return m_pSettings->readNumEntry(GeomY, 50);
   }
   void setGeomY(int val) {
      m_pSettings->writeEntry(GeomY, val);
   }
   int geomWidth() {
      return m_pSettings->readNumEntry(GeomWidth, 400);
   }
   void setGeomWidth(int val) {
      m_pSettings->writeEntry(GeomWidth, val);
   }
   int geomHeight() {
      return m_pSettings->readNumEntry(GeomHeight, 300);
   }
   void setGeomHeight(int val) {
      m_pSettings->writeEntry(GeomHeight, val);
   }

protected:

   QSettings* m_pSettings;

private:
      
   void readProjectSettings( QString);
   void writeProjectSettings( QString);
   void removeProjectSettings( QString);
   
   void updateVersionOnRead(const QString&,const QString&);
   QString updateVersionOnWrite(const QString&,const QString&);
   void readProfiles(QStringList tmpList);
   
   void readExtApps();
   void writeExtApps();
   
   Mapping::FileAppList extractMapping(const QStringList&);
   QStringList joinMapping(const Mapping::FileAppList&);
   bool m_needUpdate;
};

//----------------------------------------------------------------------------

#endif

