summaryrefslogtreecommitdiffstats
path: root/kate/part/kateconfig.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kate/part/kateconfig.cpp')
-rw-r--r--kate/part/kateconfig.cpp1429
1 files changed, 1429 insertions, 0 deletions
diff --git a/kate/part/kateconfig.cpp b/kate/part/kateconfig.cpp
new file mode 100644
index 000000000..c580ed5c1
--- /dev/null
+++ b/kate/part/kateconfig.cpp
@@ -0,0 +1,1429 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 2003 Christoph Cullmann <cullmann@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kateconfig.h"
+
+#include "katefactory.h"
+#include "katerenderer.h"
+#include "kateview.h"
+#include "katedocument.h"
+#include "katefont.h"
+#include "kateschema.h"
+
+#include <math.h>
+
+#include <kapplication.h>
+#include <kconfig.h>
+#include <kglobalsettings.h>
+#include <kcharsets.h>
+#include <klocale.h>
+#include <kfinddialog.h>
+#include <kreplacedialog.h>
+#include <kinstance.h>
+#include <kstaticdeleter.h>
+
+#include <qpopupmenu.h>
+#include <qtextcodec.h>
+
+#include <kdebug.h>
+
+//BEGIN KateConfig
+KateConfig::KateConfig ()
+ : configSessionNumber (0), configIsRunning (false)
+{
+}
+
+KateConfig::~KateConfig ()
+{
+}
+
+void KateConfig::configStart ()
+{
+ configSessionNumber++;
+
+ if (configSessionNumber > 1)
+ return;
+
+ configIsRunning = true;
+}
+
+void KateConfig::configEnd ()
+{
+ if (configSessionNumber == 0)
+ return;
+
+ configSessionNumber--;
+
+ if (configSessionNumber > 0)
+ return;
+
+ configIsRunning = false;
+
+ updateConfig ();
+}
+//END
+
+//BEGIN KateDocumentConfig
+KateDocumentConfig *KateDocumentConfig::s_global = 0;
+KateViewConfig *KateViewConfig::s_global = 0;
+KateRendererConfig *KateRendererConfig::s_global = 0;
+
+KateDocumentConfig::KateDocumentConfig ()
+ : m_tabWidth (8),
+ m_indentationWidth (2),
+ m_wordWrapAt (80),
+ m_configFlags (0),
+ m_plugins (KateFactory::self()->plugins().count()),
+ m_tabWidthSet (true),
+ m_indentationWidthSet (true),
+ m_indentationModeSet (true),
+ m_wordWrapSet (true),
+ m_wordWrapAtSet (true),
+ m_pageUpDownMovesCursorSet (true),
+ m_undoStepsSet (true),
+ m_configFlagsSet (0xFFFF),
+ m_encodingSet (true),
+ m_eolSet (true),
+ m_allowEolDetectionSet (true),
+ m_backupFlagsSet (true),
+ m_searchDirConfigDepthSet (true),
+ m_backupPrefixSet (true),
+ m_backupSuffixSet (true),
+ m_pluginsSet (m_plugins.size()),
+ m_doc (0)
+{
+ s_global = this;
+
+ // init plugin array
+ m_plugins.fill (false);
+ m_pluginsSet.fill (true);
+
+ // init with defaults from config or really hardcoded ones
+ KConfig *config = kapp->config();
+ config->setGroup("Kate Document Defaults");
+ readConfig (config);
+}
+
+KateDocumentConfig::KateDocumentConfig (KateDocument *doc)
+ : m_configFlags (0),
+ m_plugins (KateFactory::self()->plugins().count()),
+ m_tabWidthSet (false),
+ m_indentationWidthSet (false),
+ m_indentationModeSet (false),
+ m_wordWrapSet (false),
+ m_wordWrapAtSet (false),
+ m_pageUpDownMovesCursorSet (false),
+ m_undoStepsSet (false),
+ m_configFlagsSet (0),
+ m_encodingSet (false),
+ m_eolSet (false),
+ m_allowEolDetectionSet (false),
+ m_backupFlagsSet (false),
+ m_searchDirConfigDepthSet (false),
+ m_backupPrefixSet (false),
+ m_backupSuffixSet (false),
+ m_pluginsSet (m_plugins.size()),
+ m_doc (doc)
+{
+ // init plugin array
+ m_plugins.fill (false);
+ m_pluginsSet.fill (false);
+}
+
+KateDocumentConfig::~KateDocumentConfig ()
+{
+}
+
+void KateDocumentConfig::readConfig (KConfig *config)
+{
+ configStart ();
+
+ setTabWidth (config->readNumEntry("Tab Width", 8));
+
+ setIndentationWidth (config->readNumEntry("Indentation Width", 2));
+
+ setIndentationMode (config->readNumEntry("Indentation Mode", KateDocumentConfig::imNone));
+
+ setWordWrap (config->readBoolEntry("Word Wrap", false));
+ setWordWrapAt (config->readNumEntry("Word Wrap Column", 80));
+ setPageUpDownMovesCursor (config->readBoolEntry("PageUp/PageDown Moves Cursor", false));
+ setUndoSteps(config->readNumEntry("Undo Steps", 0));
+
+ setConfigFlags (config->readNumEntry("Basic Config Flags", KateDocumentConfig::cfTabIndents
+ | KateDocumentConfig::cfKeepIndentProfile
+ | KateDocumentConfig::cfWrapCursor
+ | KateDocumentConfig::cfShowTabs
+ | KateDocumentConfig::cfSmartHome
+ | KateDocumentConfig::cfIndentPastedText));
+
+ setEncoding (config->readEntry("Encoding", ""));
+
+ setEol (config->readNumEntry("End of Line", 0));
+ setAllowEolDetection (config->readBoolEntry("Allow End of Line Detection", true));
+
+ setBackupFlags (config->readNumEntry("Backup Config Flags", 1));
+
+ setSearchDirConfigDepth (config->readNumEntry("Search Dir Config Depth", 3));
+
+ setBackupPrefix (config->readEntry("Backup Prefix", QString ("")));
+
+ setBackupSuffix (config->readEntry("Backup Suffix", QString ("~")));
+
+ // plugins
+ for (uint i=0; i<KateFactory::self()->plugins().count(); i++)
+ setPlugin (i, config->readBoolEntry("KTextEditor Plugin " + (KateFactory::self()->plugins())[i]->library(), false));
+
+ configEnd ();
+}
+
+void KateDocumentConfig::writeConfig (KConfig *config)
+{
+ config->writeEntry("Tab Width", tabWidth());
+
+ config->writeEntry("Indentation Width", indentationWidth());
+ config->writeEntry("Indentation Mode", indentationMode());
+
+ config->writeEntry("Word Wrap", wordWrap());
+ config->writeEntry("Word Wrap Column", wordWrapAt());
+
+ config->writeEntry("PageUp/PageDown Moves Cursor", pageUpDownMovesCursor());
+
+ config->writeEntry("Undo Steps", undoSteps());
+
+ config->writeEntry("Basic Config Flags", configFlags());
+
+ config->writeEntry("Encoding", encoding());
+
+ config->writeEntry("End of Line", eol());
+ config->writeEntry("Allow End of Line Detection", allowEolDetection());
+
+ config->writeEntry("Backup Config Flags", backupFlags());
+
+ config->writeEntry("Search Dir Config Depth", searchDirConfigDepth());
+
+ config->writeEntry("Backup Prefix", backupPrefix());
+
+ config->writeEntry("Backup Suffix", backupSuffix());
+
+ // plugins
+ for (uint i=0; i<KateFactory::self()->plugins().count(); i++)
+ config->writeEntry("KTextEditor Plugin " + (KateFactory::self()->plugins())[i]->library(), plugin(i));
+}
+
+void KateDocumentConfig::updateConfig ()
+{
+ if (m_doc)
+ {
+ m_doc->updateConfig ();
+ return;
+ }
+
+ if (isGlobal())
+ {
+ for (uint z=0; z < KateFactory::self()->documents()->count(); z++)
+ {
+ KateFactory::self()->documents()->at(z)->updateConfig ();
+ }
+ }
+}
+
+int KateDocumentConfig::tabWidth () const
+{
+ if (m_tabWidthSet || isGlobal())
+ return m_tabWidth;
+
+ return s_global->tabWidth();
+}
+
+void KateDocumentConfig::setTabWidth (int tabWidth)
+{
+ if (tabWidth < 1)
+ return;
+
+ configStart ();
+
+ m_tabWidthSet = true;
+ m_tabWidth = tabWidth;
+
+ configEnd ();
+}
+
+int KateDocumentConfig::indentationWidth () const
+{
+ if (m_indentationWidthSet || isGlobal())
+ return m_indentationWidth;
+
+ return s_global->indentationWidth();
+}
+
+void KateDocumentConfig::setIndentationWidth (int indentationWidth)
+{
+ if (indentationWidth < 1)
+ return;
+
+ configStart ();
+
+ m_indentationWidthSet = true;
+ m_indentationWidth = indentationWidth;
+
+ configEnd ();
+}
+
+uint KateDocumentConfig::indentationMode () const
+{
+ if (m_indentationModeSet || isGlobal())
+ return m_indentationMode;
+
+ return s_global->indentationMode();
+}
+
+void KateDocumentConfig::setIndentationMode (uint indentationMode)
+{
+ configStart ();
+
+ m_indentationModeSet = true;
+ m_indentationMode = indentationMode;
+
+ configEnd ();
+}
+
+bool KateDocumentConfig::wordWrap () const
+{
+ if (m_wordWrapSet || isGlobal())
+ return m_wordWrap;
+
+ return s_global->wordWrap();
+}
+
+void KateDocumentConfig::setWordWrap (bool on)
+{
+ configStart ();
+
+ m_wordWrapSet = true;
+ m_wordWrap = on;
+
+ configEnd ();
+}
+
+unsigned int KateDocumentConfig::wordWrapAt () const
+{
+ if (m_wordWrapAtSet || isGlobal())
+ return m_wordWrapAt;
+
+ return s_global->wordWrapAt();
+}
+
+void KateDocumentConfig::setWordWrapAt (unsigned int col)
+{
+ if (col < 1)
+ return;
+
+ configStart ();
+
+ m_wordWrapAtSet = true;
+ m_wordWrapAt = col;
+
+ configEnd ();
+}
+
+uint KateDocumentConfig::undoSteps () const
+{
+ if (m_undoStepsSet || isGlobal())
+ return m_undoSteps;
+
+ return s_global->undoSteps();
+}
+
+void KateDocumentConfig::setUndoSteps (uint undoSteps)
+{
+ configStart ();
+
+ m_undoStepsSet = true;
+ m_undoSteps = undoSteps;
+
+ configEnd ();
+}
+
+bool KateDocumentConfig::pageUpDownMovesCursor () const
+{
+ if (m_pageUpDownMovesCursorSet || isGlobal())
+ return m_pageUpDownMovesCursor;
+
+ return s_global->pageUpDownMovesCursor();
+}
+
+void KateDocumentConfig::setPageUpDownMovesCursor (bool on)
+{
+ configStart ();
+
+ m_pageUpDownMovesCursorSet = true;
+ m_pageUpDownMovesCursor = on;
+
+ configEnd ();
+}
+
+uint KateDocumentConfig::configFlags () const
+{
+ if (isGlobal())
+ return m_configFlags;
+
+ return ((s_global->configFlags() & ~ m_configFlagsSet) | m_configFlags);
+}
+
+void KateDocumentConfig::setConfigFlags (KateDocumentConfig::ConfigFlags flag, bool enable)
+{
+ configStart ();
+
+ m_configFlagsSet |= flag;
+
+ if (enable)
+ m_configFlags = m_configFlags | flag;
+ else
+ m_configFlags = m_configFlags & ~ flag;
+
+ configEnd ();
+}
+
+void KateDocumentConfig::setConfigFlags (uint fullFlags)
+{
+ configStart ();
+
+ m_configFlagsSet = 0xFFFF;
+ m_configFlags = fullFlags;
+
+ configEnd ();
+}
+
+const QString &KateDocumentConfig::encoding () const
+{
+ if (m_encodingSet || isGlobal())
+ return m_encoding;
+
+ return s_global->encoding();
+}
+
+QTextCodec *KateDocumentConfig::codec ()
+{
+ if (m_encodingSet || isGlobal())
+ {
+ if (m_encoding.isEmpty() && isGlobal())
+ return KGlobal::charsets()->codecForName (QString::fromLatin1(KGlobal::locale()->encoding()));
+ else if (m_encoding.isEmpty())
+ return s_global->codec ();
+ else
+ return KGlobal::charsets()->codecForName (m_encoding);
+ }
+
+ return s_global->codec ();
+}
+
+void KateDocumentConfig::setEncoding (const QString &encoding)
+{
+ QString enc = encoding;
+
+ if (!enc.isEmpty())
+ {
+ bool found = false;
+ QTextCodec *codec = KGlobal::charsets()->codecForName (encoding, found);
+
+ if (!found || !codec)
+ return;
+
+ enc = codec->name();
+ }
+
+ configStart ();
+
+ if (isGlobal())
+ KateDocument::setDefaultEncoding (enc);
+
+ m_encodingSet = true;
+ m_encoding = enc;
+
+ configEnd ();
+}
+
+bool KateDocumentConfig::isSetEncoding () const
+{
+ return m_encodingSet;
+}
+
+int KateDocumentConfig::eol () const
+{
+ if (m_eolSet || isGlobal())
+ return m_eol;
+
+ return s_global->eol();
+}
+
+QString KateDocumentConfig::eolString ()
+{
+ if (eol() == KateDocumentConfig::eolUnix)
+ return QString ("\n");
+ else if (eol() == KateDocumentConfig::eolDos)
+ return QString ("\r\n");
+ else if (eol() == KateDocumentConfig::eolMac)
+ return QString ("\r");
+
+ return QString ("\n");
+}
+
+void KateDocumentConfig::setEol (int mode)
+{
+ configStart ();
+
+ m_eolSet = true;
+ m_eol = mode;
+
+ configEnd ();
+}
+
+bool KateDocumentConfig::allowEolDetection () const
+{
+ if (m_allowEolDetectionSet || isGlobal())
+ return m_allowEolDetection;
+
+ return s_global->allowEolDetection();
+}
+
+void KateDocumentConfig::setAllowEolDetection (bool on)
+{
+ configStart ();
+
+ m_allowEolDetectionSet = true;
+ m_allowEolDetection = on;
+
+ configEnd ();
+}
+
+uint KateDocumentConfig::backupFlags () const
+{
+ if (m_backupFlagsSet || isGlobal())
+ return m_backupFlags;
+
+ return s_global->backupFlags();
+}
+
+void KateDocumentConfig::setBackupFlags (uint flags)
+ {
+ configStart ();
+
+ m_backupFlagsSet = true;
+ m_backupFlags = flags;
+
+ configEnd ();
+}
+
+const QString &KateDocumentConfig::backupPrefix () const
+{
+ if (m_backupPrefixSet || isGlobal())
+ return m_backupPrefix;
+
+ return s_global->backupPrefix();
+}
+
+const QString &KateDocumentConfig::backupSuffix () const
+{
+ if (m_backupSuffixSet || isGlobal())
+ return m_backupSuffix;
+
+ return s_global->backupSuffix();
+}
+
+void KateDocumentConfig::setBackupPrefix (const QString &prefix)
+{
+ configStart ();
+
+ m_backupPrefixSet = true;
+ m_backupPrefix = prefix;
+
+ configEnd ();
+}
+
+void KateDocumentConfig::setBackupSuffix (const QString &suffix)
+{
+ configStart ();
+
+ m_backupSuffixSet = true;
+ m_backupSuffix = suffix;
+
+ configEnd ();
+}
+
+bool KateDocumentConfig::plugin (uint index) const
+{
+ if (index >= m_plugins.size())
+ return false;
+
+ if (m_pluginsSet.at(index) || isGlobal())
+ return m_plugins.at(index);
+
+ return s_global->plugin (index);
+}
+
+void KateDocumentConfig::setPlugin (uint index, bool load)
+{
+ if (index >= m_plugins.size())
+ return;
+
+ configStart ();
+
+ m_pluginsSet.setBit(index);
+ m_plugins.setBit(index, load);
+
+ configEnd ();
+}
+
+int KateDocumentConfig::searchDirConfigDepth () const
+{
+ if (m_searchDirConfigDepthSet || isGlobal())
+ return m_searchDirConfigDepth;
+
+ return s_global->searchDirConfigDepth ();
+}
+
+void KateDocumentConfig::setSearchDirConfigDepth (int depth)
+{
+ configStart ();
+
+ m_searchDirConfigDepthSet = true;
+ m_searchDirConfigDepth = depth;
+
+ configEnd ();
+}
+
+//END
+
+//BEGIN KateViewConfig
+KateViewConfig::KateViewConfig ()
+ :
+ m_dynWordWrapSet (true),
+ m_dynWordWrapIndicatorsSet (true),
+ m_dynWordWrapAlignIndentSet (true),
+ m_lineNumbersSet (true),
+ m_scrollBarMarksSet (true),
+ m_iconBarSet (true),
+ m_foldingBarSet (true),
+ m_bookmarkSortSet (true),
+ m_autoCenterLinesSet (true),
+ m_searchFlagsSet (true),
+ m_cmdLineSet (true),
+ m_defaultMarkTypeSet (true),
+ m_persistentSelectionSet (true),
+ m_textToSearchModeSet (true),
+ m_view (0)
+{
+ s_global = this;
+
+ // init with defaults from config or really hardcoded ones
+ KConfig *config = kapp->config();
+ config->setGroup("Kate View Defaults");
+ readConfig (config);
+}
+
+KateViewConfig::KateViewConfig (KateView *view)
+ :
+ m_dynWordWrapSet (false),
+ m_dynWordWrapIndicatorsSet (false),
+ m_dynWordWrapAlignIndentSet (false),
+ m_lineNumbersSet (false),
+ m_scrollBarMarksSet (false),
+ m_iconBarSet (false),
+ m_foldingBarSet (false),
+ m_bookmarkSortSet (false),
+ m_autoCenterLinesSet (false),
+ m_searchFlagsSet (false),
+ m_cmdLineSet (false),
+ m_defaultMarkTypeSet (false),
+ m_persistentSelectionSet (false),
+ m_textToSearchModeSet (false),
+ m_view (view)
+{
+}
+
+KateViewConfig::~KateViewConfig ()
+{
+}
+
+void KateViewConfig::readConfig (KConfig *config)
+{
+ configStart ();
+
+ setDynWordWrap (config->readBoolEntry( "Dynamic Word Wrap", true ));
+ setDynWordWrapIndicators (config->readNumEntry( "Dynamic Word Wrap Indicators", 1 ));
+ setDynWordWrapAlignIndent (config->readNumEntry( "Dynamic Word Wrap Align Indent", 80 ));
+
+ setLineNumbers (config->readBoolEntry( "Line Numbers", false));
+
+ setScrollBarMarks (config->readBoolEntry( "Scroll Bar Marks", false));
+
+ setIconBar (config->readBoolEntry( "Icon Bar", false ));
+
+ setFoldingBar (config->readBoolEntry( "Folding Bar", true));
+
+ setBookmarkSort (config->readNumEntry( "Bookmark Menu Sorting", 0 ));
+
+ setAutoCenterLines (config->readNumEntry( "Auto Center Lines", 0 ));
+
+ setSearchFlags (config->readNumEntry("Search Config Flags", KFindDialog::FromCursor | KFindDialog::CaseSensitive | KReplaceDialog::PromptOnReplace));
+
+ setCmdLine (config->readBoolEntry( "Command Line", false));
+
+ setDefaultMarkType (config->readNumEntry( "Default Mark Type", KTextEditor::MarkInterface::markType01 ));
+
+ setPersistentSelection (config->readNumEntry( "Persistent Selection", false ));
+
+ setTextToSearchMode (config->readNumEntry( "Text To Search Mode", KateViewConfig::SelectionWord));
+
+ configEnd ();
+}
+
+void KateViewConfig::writeConfig (KConfig *config)
+{
+ config->writeEntry( "Dynamic Word Wrap", dynWordWrap() );
+ config->writeEntry( "Dynamic Word Wrap Indicators", dynWordWrapIndicators() );
+ config->writeEntry( "Dynamic Word Wrap Align Indent", dynWordWrapAlignIndent() );
+
+ config->writeEntry( "Line Numbers", lineNumbers() );
+
+ config->writeEntry( "Scroll Bar Marks", scrollBarMarks() );
+
+ config->writeEntry( "Icon Bar", iconBar() );
+
+ config->writeEntry( "Folding Bar", foldingBar() );
+
+ config->writeEntry( "Bookmark Menu Sorting", bookmarkSort() );
+
+ config->writeEntry( "Auto Center Lines", autoCenterLines() );
+
+ config->writeEntry("Search Config Flags", searchFlags());
+
+ config->writeEntry("Command Line", cmdLine());
+
+ config->writeEntry("Default Mark Type", defaultMarkType());
+
+ config->writeEntry("Persistent Selection", persistentSelection());
+
+ config->writeEntry("Text To Search Mode", textToSearchMode());
+}
+
+void KateViewConfig::updateConfig ()
+{
+ if (m_view)
+ {
+ m_view->updateConfig ();
+ return;
+ }
+
+ if (isGlobal())
+ {
+ for (uint z=0; z < KateFactory::self()->views()->count(); z++)
+ {
+ KateFactory::self()->views()->at(z)->updateConfig ();
+ }
+ }
+}
+
+bool KateViewConfig::dynWordWrap () const
+{
+ if (m_dynWordWrapSet || isGlobal())
+ return m_dynWordWrap;
+
+ return s_global->dynWordWrap();
+}
+
+void KateViewConfig::setDynWordWrap (bool wrap)
+{
+ configStart ();
+
+ m_dynWordWrapSet = true;
+ m_dynWordWrap = wrap;
+
+ configEnd ();
+}
+
+int KateViewConfig::dynWordWrapIndicators () const
+{
+ if (m_dynWordWrapIndicatorsSet || isGlobal())
+ return m_dynWordWrapIndicators;
+
+ return s_global->dynWordWrapIndicators();
+}
+
+void KateViewConfig::setDynWordWrapIndicators (int mode)
+{
+ configStart ();
+
+ m_dynWordWrapIndicatorsSet = true;
+ m_dynWordWrapIndicators = kMin(80, kMax(0, mode));
+
+ configEnd ();
+}
+
+int KateViewConfig::dynWordWrapAlignIndent () const
+{
+ if (m_dynWordWrapAlignIndentSet || isGlobal())
+ return m_dynWordWrapAlignIndent;
+
+ return s_global->dynWordWrapAlignIndent();
+}
+
+void KateViewConfig::setDynWordWrapAlignIndent (int indent)
+{
+ configStart ();
+
+ m_dynWordWrapAlignIndentSet = true;
+ m_dynWordWrapAlignIndent = indent;
+
+ configEnd ();
+}
+
+bool KateViewConfig::lineNumbers () const
+{
+ if (m_lineNumbersSet || isGlobal())
+ return m_lineNumbers;
+
+ return s_global->lineNumbers();
+}
+
+void KateViewConfig::setLineNumbers (bool on)
+{
+ configStart ();
+
+ m_lineNumbersSet = true;
+ m_lineNumbers = on;
+
+ configEnd ();
+}
+
+bool KateViewConfig::scrollBarMarks () const
+{
+ if (m_scrollBarMarksSet || isGlobal())
+ return m_scrollBarMarks;
+
+ return s_global->scrollBarMarks();
+}
+
+void KateViewConfig::setScrollBarMarks (bool on)
+{
+ configStart ();
+
+ m_scrollBarMarksSet = true;
+ m_scrollBarMarks = on;
+
+ configEnd ();
+}
+
+bool KateViewConfig::iconBar () const
+{
+ if (m_iconBarSet || isGlobal())
+ return m_iconBar;
+
+ return s_global->iconBar();
+}
+
+void KateViewConfig::setIconBar (bool on)
+{
+ configStart ();
+
+ m_iconBarSet = true;
+ m_iconBar = on;
+
+ configEnd ();
+}
+
+bool KateViewConfig::foldingBar () const
+{
+ if (m_foldingBarSet || isGlobal())
+ return m_foldingBar;
+
+ return s_global->foldingBar();
+}
+
+void KateViewConfig::setFoldingBar (bool on)
+{
+ configStart ();
+
+ m_foldingBarSet = true;
+ m_foldingBar = on;
+
+ configEnd ();
+}
+
+int KateViewConfig::bookmarkSort () const
+{
+ if (m_bookmarkSortSet || isGlobal())
+ return m_bookmarkSort;
+
+ return s_global->bookmarkSort();
+}
+
+void KateViewConfig::setBookmarkSort (int mode)
+{
+ configStart ();
+
+ m_bookmarkSortSet = true;
+ m_bookmarkSort = mode;
+
+ configEnd ();
+}
+
+int KateViewConfig::autoCenterLines () const
+{
+ if (m_autoCenterLinesSet || isGlobal())
+ return m_autoCenterLines;
+
+ return s_global->autoCenterLines();
+}
+
+void KateViewConfig::setAutoCenterLines (int lines)
+{
+ if (lines < 0)
+ return;
+
+ configStart ();
+
+ m_autoCenterLinesSet = true;
+ m_autoCenterLines = lines;
+
+ configEnd ();
+}
+
+long KateViewConfig::searchFlags () const
+{
+ if (m_searchFlagsSet || isGlobal())
+ return m_searchFlags;
+
+ return s_global->searchFlags();
+}
+
+void KateViewConfig::setSearchFlags (long flags)
+ {
+ configStart ();
+
+ m_searchFlagsSet = true;
+ m_searchFlags = flags;
+
+ configEnd ();
+}
+
+bool KateViewConfig::cmdLine () const
+{
+ if (m_cmdLineSet || isGlobal())
+ return m_cmdLine;
+
+ return s_global->cmdLine();
+}
+
+void KateViewConfig::setCmdLine (bool on)
+{
+ configStart ();
+
+ m_cmdLineSet = true;
+ m_cmdLine = on;
+
+ configEnd ();
+}
+
+uint KateViewConfig::defaultMarkType () const
+{
+ if (m_defaultMarkTypeSet || isGlobal())
+ return m_defaultMarkType;
+
+ return s_global->defaultMarkType();
+}
+
+void KateViewConfig::setDefaultMarkType (uint type)
+{
+ configStart ();
+
+ m_defaultMarkTypeSet = true;
+ m_defaultMarkType = type;
+
+ configEnd ();
+}
+
+bool KateViewConfig::persistentSelection () const
+{
+ if (m_persistentSelectionSet || isGlobal())
+ return m_persistentSelection;
+
+ return s_global->persistentSelection();
+}
+
+void KateViewConfig::setPersistentSelection (bool on)
+{
+ configStart ();
+
+ m_persistentSelectionSet = true;
+ m_persistentSelection = on;
+
+ configEnd ();
+}
+
+int KateViewConfig::textToSearchMode () const
+{
+ if (m_textToSearchModeSet || isGlobal())
+ return m_textToSearchMode;
+
+ return s_global->textToSearchMode();
+}
+
+void KateViewConfig::setTextToSearchMode (int mode)
+{
+ configStart ();
+
+ m_textToSearchModeSet = true;
+ m_textToSearchMode = mode;
+
+ configEnd ();
+}
+
+//END
+
+//BEGIN KateRendererConfig
+KateRendererConfig::KateRendererConfig ()
+ :
+ m_font (new KateFontStruct ()),
+ m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
+ m_schemaSet (true),
+ m_fontSet (true),
+ m_wordWrapMarkerSet (true),
+ m_showIndentationLinesSet (true),
+ m_backgroundColorSet (true),
+ m_selectionColorSet (true),
+ m_highlightedLineColorSet (true),
+ m_highlightedBracketColorSet (true),
+ m_wordWrapMarkerColorSet (true),
+ m_tabMarkerColorSet(true),
+ m_iconBarColorSet (true),
+ m_lineNumberColorSet (true),
+ m_lineMarkerColorSet (m_lineMarkerColor.size()),
+ m_renderer (0)
+{
+ // init bitarray
+ m_lineMarkerColorSet.fill (true);
+
+ s_global = this;
+
+ // init with defaults from config or really hardcoded ones
+ KConfig *config = kapp->config();
+ config->setGroup("Kate Renderer Defaults");
+ readConfig (config);
+}
+
+KateRendererConfig::KateRendererConfig (KateRenderer *renderer)
+ : m_font (0),
+ m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
+ m_schemaSet (false),
+ m_fontSet (false),
+ m_wordWrapMarkerSet (false),
+ m_showIndentationLinesSet (false),
+ m_backgroundColorSet (false),
+ m_selectionColorSet (false),
+ m_highlightedLineColorSet (false),
+ m_highlightedBracketColorSet (false),
+ m_wordWrapMarkerColorSet (false),
+ m_tabMarkerColorSet(false),
+ m_iconBarColorSet (false),
+ m_lineNumberColorSet (false),
+ m_lineMarkerColorSet (m_lineMarkerColor.size()),
+ m_renderer (renderer)
+{
+ // init bitarray
+ m_lineMarkerColorSet.fill (false);
+}
+
+KateRendererConfig::~KateRendererConfig ()
+{
+ delete m_font;
+}
+
+void KateRendererConfig::readConfig (KConfig *config)
+{
+ configStart ();
+
+ setSchema (KateFactory::self()->schemaManager()->number (config->readEntry("Schema", KateSchemaManager::normalSchema())));
+
+ setWordWrapMarker (config->readBoolEntry("Word Wrap Marker", false ));
+
+ setShowIndentationLines (config->readBoolEntry( "Show Indentation Lines", false));
+
+ configEnd ();
+}
+
+void KateRendererConfig::writeConfig (KConfig *config)
+{
+ config->writeEntry ("Schema", KateFactory::self()->schemaManager()->name(schema()));
+
+ config->writeEntry("Word Wrap Marker", wordWrapMarker() );
+
+ config->writeEntry("Show Indentation Lines", showIndentationLines());
+}
+
+void KateRendererConfig::updateConfig ()
+{
+ if (m_renderer)
+ {
+ m_renderer->updateConfig ();
+ return;
+ }
+
+ if (isGlobal())
+ {
+ for (uint z=0; z < KateFactory::self()->renderers()->count(); z++)
+ {
+ KateFactory::self()->renderers()->at(z)->updateConfig ();
+ }
+ }
+}
+
+uint KateRendererConfig::schema () const
+{
+ if (m_schemaSet || isGlobal())
+ return m_schema;
+
+ return s_global->schema();
+}
+
+void KateRendererConfig::setSchema (uint schema)
+{
+ configStart ();
+ m_schemaSet = true;
+ m_schema = schema;
+ setSchemaInternal( schema );
+ configEnd ();
+}
+
+void KateRendererConfig::reloadSchema()
+{
+ if ( isGlobal() )
+ for ( uint z=0; z < KateFactory::self()->renderers()->count(); z++ )
+ KateFactory::self()->renderers()->at(z)->config()->reloadSchema();
+
+ else if ( m_renderer && m_schemaSet )
+ setSchemaInternal( m_schema );
+}
+
+void KateRendererConfig::setSchemaInternal( int schema )
+{
+ m_schemaSet = true;
+ m_schema = schema;
+
+ KConfig *config (KateFactory::self()->schemaManager()->schema(schema));
+
+ QColor tmp0 (KGlobalSettings::baseColor());
+ QColor tmp1 (KGlobalSettings::highlightColor());
+ QColor tmp2 (KGlobalSettings::alternateBackgroundColor());
+ QColor tmp3 ( "#FFFF99" );
+ QColor tmp4 (tmp2.dark());
+ QColor tmp5 ( KGlobalSettings::textColor() );
+ QColor tmp6 ( "#EAE9E8" );
+ QColor tmp7 ( "#000000" );
+
+ m_backgroundColor = config->readColorEntry("Color Background", &tmp0);
+ m_backgroundColorSet = true;
+ m_selectionColor = config->readColorEntry("Color Selection", &tmp1);
+ m_selectionColorSet = true;
+ m_highlightedLineColor = config->readColorEntry("Color Highlighted Line", &tmp2);
+ m_highlightedLineColorSet = true;
+ m_highlightedBracketColor = config->readColorEntry("Color Highlighted Bracket", &tmp3);
+ m_highlightedBracketColorSet = true;
+ m_wordWrapMarkerColor = config->readColorEntry("Color Word Wrap Marker", &tmp4);
+ m_wordWrapMarkerColorSet = true;
+ m_tabMarkerColor = config->readColorEntry("Color Tab Marker", &tmp5);
+ m_tabMarkerColorSet = true;
+ m_iconBarColor = config->readColorEntry("Color Icon Bar", &tmp6);
+ m_iconBarColorSet = true;
+ m_lineNumberColor = config->readColorEntry("Color Line Number", &tmp7);
+ m_lineNumberColorSet = true;
+
+ // same std colors like in KateDocument::markColor
+ QColor mark[7];
+ mark[0] = Qt::blue;
+ mark[1] = Qt::red;
+ mark[2] = Qt::yellow;
+ mark[3] = Qt::magenta;
+ mark[4] = Qt::gray;
+ mark[5] = Qt::green;
+ mark[6] = Qt::red;
+
+ for (int i = 1; i <= KTextEditor::MarkInterface::reservedMarkersCount(); i++) {
+ QColor col = config->readColorEntry(QString("Color MarkType%1").arg(i), &mark[i - 1]);
+ int index = i-1;
+ m_lineMarkerColorSet[index] = true;
+ m_lineMarkerColor[index] = col;
+ }
+
+ QFont f (KGlobalSettings::fixedFont());
+
+ if (!m_fontSet)
+ {
+ m_fontSet = true;
+ m_font = new KateFontStruct ();
+ }
+
+ m_font->setFont(config->readFontEntry("Font", &f));
+}
+
+KateFontStruct *KateRendererConfig::fontStruct ()
+{
+ if (m_fontSet || isGlobal())
+ return m_font;
+
+ return s_global->fontStruct ();
+}
+
+QFont *KateRendererConfig::font()
+{
+ return &(fontStruct ()->myFont);
+}
+
+KateFontMetrics *KateRendererConfig::fontMetrics()
+{
+ return &(fontStruct ()->myFontMetrics);
+}
+
+void KateRendererConfig::setFont(const QFont &font)
+{
+ configStart ();
+
+ if (!m_fontSet)
+ {
+ m_fontSet = true;
+ m_font = new KateFontStruct ();
+ }
+
+ m_font->setFont(font);
+
+ configEnd ();
+}
+
+bool KateRendererConfig::wordWrapMarker () const
+{
+ if (m_wordWrapMarkerSet || isGlobal())
+ return m_wordWrapMarker;
+
+ return s_global->wordWrapMarker();
+}
+
+void KateRendererConfig::setWordWrapMarker (bool on)
+{
+ configStart ();
+
+ m_wordWrapMarkerSet = true;
+ m_wordWrapMarker = on;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::backgroundColor() const
+{
+ if (m_backgroundColorSet || isGlobal())
+ return m_backgroundColor;
+
+ return s_global->backgroundColor();
+}
+
+void KateRendererConfig::setBackgroundColor (const QColor &col)
+{
+ configStart ();
+
+ m_backgroundColorSet = true;
+ m_backgroundColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::selectionColor() const
+{
+ if (m_selectionColorSet || isGlobal())
+ return m_selectionColor;
+
+ return s_global->selectionColor();
+}
+
+void KateRendererConfig::setSelectionColor (const QColor &col)
+{
+ configStart ();
+
+ m_selectionColorSet = true;
+ m_selectionColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::highlightedLineColor() const
+{
+ if (m_highlightedLineColorSet || isGlobal())
+ return m_highlightedLineColor;
+
+ return s_global->highlightedLineColor();
+}
+
+void KateRendererConfig::setHighlightedLineColor (const QColor &col)
+{
+ configStart ();
+
+ m_highlightedLineColorSet = true;
+ m_highlightedLineColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::lineMarkerColor(KTextEditor::MarkInterface::MarkTypes type) const
+{
+ int index = 0;
+ if (type > 0) { while((type >> index++) ^ 1) {} }
+ index -= 1;
+
+ if ( index < 0 || index >= KTextEditor::MarkInterface::reservedMarkersCount() )
+ {
+ static QColor dummy;
+ return dummy;
+ }
+
+ if (m_lineMarkerColorSet[index] || isGlobal())
+ return m_lineMarkerColor[index];
+
+ return s_global->lineMarkerColor( type );
+}
+
+void KateRendererConfig::setLineMarkerColor (const QColor &col, KTextEditor::MarkInterface::MarkTypes type)
+{
+ int index = static_cast<int>( log(static_cast<double>(type)) / log(2.0) );
+ Q_ASSERT( index >= 0 && index < KTextEditor::MarkInterface::reservedMarkersCount() );
+ configStart ();
+
+ m_lineMarkerColorSet[index] = true;
+ m_lineMarkerColor[index] = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::highlightedBracketColor() const
+{
+ if (m_highlightedBracketColorSet || isGlobal())
+ return m_highlightedBracketColor;
+
+ return s_global->highlightedBracketColor();
+}
+
+void KateRendererConfig::setHighlightedBracketColor (const QColor &col)
+{
+ configStart ();
+
+ m_highlightedBracketColorSet = true;
+ m_highlightedBracketColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::wordWrapMarkerColor() const
+{
+ if (m_wordWrapMarkerColorSet || isGlobal())
+ return m_wordWrapMarkerColor;
+
+ return s_global->wordWrapMarkerColor();
+}
+
+void KateRendererConfig::setWordWrapMarkerColor (const QColor &col)
+{
+ configStart ();
+
+ m_wordWrapMarkerColorSet = true;
+ m_wordWrapMarkerColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::tabMarkerColor() const
+{
+ if (m_tabMarkerColorSet || isGlobal())
+ return m_tabMarkerColor;
+
+ return s_global->tabMarkerColor();
+}
+
+void KateRendererConfig::setTabMarkerColor (const QColor &col)
+{
+ configStart ();
+
+ m_tabMarkerColorSet = true;
+ m_tabMarkerColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::iconBarColor() const
+{
+ if (m_iconBarColorSet || isGlobal())
+ return m_iconBarColor;
+
+ return s_global->iconBarColor();
+}
+
+void KateRendererConfig::setIconBarColor (const QColor &col)
+{
+ configStart ();
+
+ m_iconBarColorSet = true;
+ m_iconBarColor = col;
+
+ configEnd ();
+}
+
+const QColor& KateRendererConfig::lineNumberColor() const
+{
+ if (m_lineNumberColorSet || isGlobal())
+ return m_lineNumberColor;
+
+ return s_global->lineNumberColor();
+}
+
+void KateRendererConfig::setLineNumberColor (const QColor &col)
+{
+ configStart ();
+
+ m_lineNumberColorSet = true;
+ m_lineNumberColor = col;
+
+ configEnd ();
+}
+
+bool KateRendererConfig::showIndentationLines () const
+{
+ if (m_showIndentationLinesSet || isGlobal())
+ return m_showIndentationLines;
+
+ return s_global->showIndentationLines();
+}
+
+void KateRendererConfig::setShowIndentationLines (bool on)
+{
+ configStart ();
+
+ m_showIndentationLinesSet = true;
+ m_showIndentationLines = on;
+
+ configEnd ();
+}
+
+//END
+
+// kate: space-indent on; indent-width 2; replace-tabs on;