mirror of
https://bitbucket.org/smil3y/kde-workspace.git
synced 2025-02-24 19:02:51 +00:00
2733 lines
64 KiB
C++
2733 lines
64 KiB
C++
/* This file is part of the KDE libraries
|
|
Copyright (C) 2007, 2008 Matthew Woehlke <mw_triad@users.sourceforge.net>
|
|
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 "kateglobal.h"
|
|
#include "katedefaultcolors.h"
|
|
#include "katerenderer.h"
|
|
#include "kateview.h"
|
|
#include "katedocument.h"
|
|
#include "kateschema.h"
|
|
|
|
#include <math.h>
|
|
|
|
#include <kconfig.h>
|
|
#include <kconfiggroup.h>
|
|
#include <kglobalsettings.h>
|
|
#include <kcolorscheme.h>
|
|
#include <kcolorutils.h>
|
|
#include <kcharsets.h>
|
|
#include <klocale.h>
|
|
#include <kcomponentdata.h>
|
|
#include <kdebug.h>
|
|
|
|
#include <QtCore/QTextCodec>
|
|
#include <QStringListModel>
|
|
|
|
//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
|
|
KateGlobalConfig *KateGlobalConfig::s_global = 0;
|
|
KateDocumentConfig *KateDocumentConfig::s_global = 0;
|
|
KateViewConfig *KateViewConfig::s_global = 0;
|
|
KateRendererConfig *KateRendererConfig::s_global = 0;
|
|
|
|
KateGlobalConfig::KateGlobalConfig ()
|
|
{
|
|
s_global = this;
|
|
|
|
// init with defaults from config or really hardcoded ones
|
|
KConfigGroup cg( KGlobal::config(), "Kate Part Defaults");
|
|
readConfig (cg);
|
|
}
|
|
|
|
KateGlobalConfig::~KateGlobalConfig ()
|
|
{
|
|
}
|
|
|
|
namespace
|
|
{
|
|
const char * const KEY_FALLBACK_ENCODING = "Fallback Encoding";
|
|
}
|
|
|
|
void KateGlobalConfig::readConfig (const KConfigGroup &config)
|
|
{
|
|
configStart ();
|
|
|
|
setFallbackEncoding (config.readEntry(KEY_FALLBACK_ENCODING, ""));
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateGlobalConfig::writeConfig (KConfigGroup &config)
|
|
{
|
|
config.writeEntry(KEY_FALLBACK_ENCODING, fallbackEncoding());
|
|
}
|
|
|
|
void KateGlobalConfig::updateConfig ()
|
|
{
|
|
}
|
|
|
|
const QString &KateGlobalConfig::fallbackEncoding () const
|
|
{
|
|
return m_fallbackEncoding;
|
|
}
|
|
|
|
QTextCodec *KateGlobalConfig::fallbackCodec () const
|
|
{
|
|
if (m_fallbackEncoding.isEmpty())
|
|
return QTextCodec::codecForName("ISO-8859-15");
|
|
|
|
return KGlobal::charsets()->codecForName (m_fallbackEncoding);
|
|
}
|
|
|
|
bool KateGlobalConfig::setFallbackEncoding (const QString &encoding)
|
|
{
|
|
QTextCodec *codec;
|
|
bool found = false;
|
|
if (encoding.isEmpty())
|
|
{
|
|
codec = s_global->fallbackCodec();
|
|
found = true;
|
|
}
|
|
else
|
|
codec = KGlobal::charsets()->codecForName (encoding, found);
|
|
|
|
if (!found || !codec)
|
|
return false;
|
|
|
|
configStart ();
|
|
m_fallbackEncoding = codec->name();
|
|
configEnd ();
|
|
return true;
|
|
}
|
|
|
|
KateDocumentConfig::KateDocumentConfig ()
|
|
: m_indentationWidth (2),
|
|
m_tabWidth (8),
|
|
m_tabHandling (tabSmart),
|
|
m_configFlags (0),
|
|
m_wordWrapAt (80),
|
|
m_tabWidthSet (false),
|
|
m_indentationWidthSet (false),
|
|
m_indentationModeSet (false),
|
|
m_wordWrapSet (false),
|
|
m_wordWrapAtSet (false),
|
|
m_pageUpDownMovesCursorSet (false),
|
|
m_keepExtraSpacesSet (false),
|
|
m_indentPastedTextSet (false),
|
|
m_backspaceIndentsSet (false),
|
|
m_smartHomeSet (false),
|
|
m_showTabsSet (false),
|
|
m_showSpacesSet (false),
|
|
m_replaceTabsDynSet (false),
|
|
m_removeSpacesSet (false),
|
|
m_newLineAtEofSet (false),
|
|
m_overwiteModeSet (false),
|
|
m_tabIndentsSet (false),
|
|
m_encodingSet (false),
|
|
m_eolSet (false),
|
|
m_bomSet (false),
|
|
m_allowEolDetectionSet (false),
|
|
m_allowSimpleModeSet (false),
|
|
m_backupFlagsSet (false),
|
|
m_searchDirConfigDepthSet (false),
|
|
m_backupPrefixSet (false),
|
|
m_backupSuffixSet (false),
|
|
m_swapFileNoSyncSet (false),
|
|
m_onTheFlySpellCheckSet (false),
|
|
m_lineLengthLimitSet (false),
|
|
m_doc (0)
|
|
{
|
|
s_global = this;
|
|
|
|
// init with defaults from config or really hardcoded ones
|
|
KConfigGroup cg( KGlobal::config(), "Kate Document Defaults");
|
|
readConfig (cg);
|
|
}
|
|
|
|
KateDocumentConfig::KateDocumentConfig (const KConfigGroup &cg)
|
|
: m_indentationWidth (2),
|
|
m_tabWidth (8),
|
|
m_tabHandling (tabSmart),
|
|
m_configFlags (0),
|
|
m_wordWrapAt (80),
|
|
m_tabWidthSet (false),
|
|
m_indentationWidthSet (false),
|
|
m_indentationModeSet (false),
|
|
m_wordWrapSet (false),
|
|
m_wordWrapAtSet (false),
|
|
m_pageUpDownMovesCursorSet (false),
|
|
m_keepExtraSpacesSet (false),
|
|
m_indentPastedTextSet (false),
|
|
m_backspaceIndentsSet (false),
|
|
m_smartHomeSet (false),
|
|
m_showTabsSet (false),
|
|
m_showSpacesSet (false),
|
|
m_replaceTabsDynSet (false),
|
|
m_removeSpacesSet (false),
|
|
m_newLineAtEofSet (false),
|
|
m_overwiteModeSet (false),
|
|
m_tabIndentsSet (false),
|
|
m_encodingSet (false),
|
|
m_eolSet (false),
|
|
m_bomSet (false),
|
|
m_allowEolDetectionSet (false),
|
|
m_allowSimpleModeSet (false),
|
|
m_backupFlagsSet (false),
|
|
m_searchDirConfigDepthSet (false),
|
|
m_backupPrefixSet (false),
|
|
m_backupSuffixSet (false),
|
|
m_swapFileNoSyncSet (false),
|
|
m_onTheFlySpellCheckSet (false),
|
|
m_lineLengthLimitSet (false),
|
|
m_doc (0)
|
|
{
|
|
// init with defaults from config or really hardcoded ones
|
|
readConfig (cg);
|
|
}
|
|
|
|
KateDocumentConfig::KateDocumentConfig (KateDocument *doc)
|
|
: m_tabHandling (tabSmart),
|
|
m_configFlags (0),
|
|
m_tabWidthSet (false),
|
|
m_indentationWidthSet (false),
|
|
m_indentationModeSet (false),
|
|
m_wordWrapSet (false),
|
|
m_wordWrapAtSet (false),
|
|
m_pageUpDownMovesCursorSet (false),
|
|
m_keepExtraSpacesSet (false),
|
|
m_indentPastedTextSet (false),
|
|
m_backspaceIndentsSet (false),
|
|
m_smartHomeSet (false),
|
|
m_showTabsSet (false),
|
|
m_showSpacesSet (false),
|
|
m_replaceTabsDynSet (false),
|
|
m_removeSpacesSet (false),
|
|
m_newLineAtEofSet (false),
|
|
m_overwiteModeSet (false),
|
|
m_tabIndentsSet (false),
|
|
m_encodingSet (false),
|
|
m_eolSet (false),
|
|
m_bomSet (false),
|
|
m_allowEolDetectionSet (false),
|
|
m_allowSimpleModeSet (false),
|
|
m_backupFlagsSet (false),
|
|
m_searchDirConfigDepthSet (false),
|
|
m_backupPrefixSet (false),
|
|
m_backupSuffixSet (false),
|
|
m_swapFileNoSyncSet (false),
|
|
m_onTheFlySpellCheckSet (false),
|
|
m_lineLengthLimitSet (false),
|
|
m_doc (doc)
|
|
{
|
|
}
|
|
|
|
KateDocumentConfig::~KateDocumentConfig ()
|
|
{
|
|
}
|
|
|
|
namespace
|
|
{
|
|
const char * const KEY_TAB_WIDTH = "Tab Width";
|
|
const char * const KEY_INDENTATION_WIDTH = "Indentation Width";
|
|
const char * const KEY_INDENTATION_MODE = "Indentation Mode";
|
|
const char * const KEY_TAB_HANDLING = "Tab Handling";
|
|
const char * const KEY_WORD_WRAP = "Word Wrap";
|
|
const char * const KEY_WORD_WRAP_AT = "Word Wrap Column";
|
|
const char * const KEY_PAGEUP_DOWN_MOVES_CURSOR = "PageUp/PageDown Moves Cursor";
|
|
const char * const KEY_SMART_HOME = "Smart Home";
|
|
const char * const KEY_SHOW_TABS = "Show Tabs";
|
|
const char * const KEY_TAB_INDENTS = "Indent On Tab";
|
|
const char * const KEY_KEEP_EXTRA_SPACES = "Keep Extra Spaces";
|
|
const char * const KEY_INDENT_PASTED_TEXT = "Indent On Text Paste";
|
|
const char * const KEY_BACKSPACE_INDENTS = "Indent On Backspace";
|
|
const char * const KEY_SHOW_SPACES = "Show Spaces";
|
|
const char * const KEY_REPLACE_TABS_DYN = "ReplaceTabsDyn";
|
|
const char * const KEY_REMOVE_SPACES = "Remove Spaces";
|
|
const char * const KEY_NEWLINE_AT_EOF = "Newline At EOF";
|
|
const char * const KEY_OVR = "Overwrite Mode";
|
|
const char * const KEY_ENCODING = "Encoding";
|
|
const char * const KEY_EOL = "End of Line";
|
|
const char * const KEY_ALLOW_EOL_DETECTION = "Allow End of Line Detection";
|
|
const char * const KEY_BOM = "BOM";
|
|
const char * const KEY_ALLOW_SIMPLE_MODE = "Allow Simple Mode";
|
|
const char * const KEY_BACKUP_FLAGS = "Backup Flags";
|
|
const char * const KEY_SEARCH_DIR_CONFIG_DEPTH = "Search Dir Config Depth";
|
|
const char * const KEY_BACKUP_PREFIX = "Backup Prefix";
|
|
const char * const KEY_BACKUP_SUFFIX = "Backup Suffix";
|
|
const char * const KEY_SWAP_FILE_NO_SYNC = "No sync";
|
|
const char * const KEY_ON_THE_FLY_SPELLCHECK = "On-The-Fly Spellcheck";
|
|
const char * const KEY_LINE_LENGTH_LIMIT = "Line Length Limit";
|
|
}
|
|
|
|
void KateDocumentConfig::readConfig (const KConfigGroup &config)
|
|
{
|
|
configStart ();
|
|
|
|
setTabWidth (config.readEntry(KEY_TAB_WIDTH, 8));
|
|
|
|
setIndentationWidth (config.readEntry(KEY_INDENTATION_WIDTH, 2));
|
|
|
|
setIndentationMode (config.readEntry(KEY_INDENTATION_MODE, "normal"));
|
|
|
|
setTabHandling (config.readEntry(KEY_TAB_HANDLING, int(KateDocumentConfig::tabSmart)));
|
|
|
|
setWordWrap (config.readEntry(KEY_WORD_WRAP, false));
|
|
setWordWrapAt (config.readEntry(KEY_WORD_WRAP_AT, 80));
|
|
setPageUpDownMovesCursor (config.readEntry(KEY_PAGEUP_DOWN_MOVES_CURSOR, false));
|
|
|
|
setSmartHome (config.readEntry(KEY_SMART_HOME, true));
|
|
setShowTabs (config.readEntry(KEY_SHOW_TABS, true));
|
|
setTabIndents (config.readEntry(KEY_TAB_INDENTS, true));
|
|
setKeepExtraSpaces (config.readEntry(KEY_KEEP_EXTRA_SPACES, false));
|
|
setIndentPastedText (config.readEntry(KEY_INDENT_PASTED_TEXT, false));
|
|
setBackspaceIndents (config.readEntry(KEY_BACKSPACE_INDENTS, false));
|
|
setShowSpaces (config.readEntry(KEY_SHOW_SPACES, false));
|
|
setReplaceTabsDyn (config.readEntry(KEY_REPLACE_TABS_DYN, false));
|
|
setRemoveSpaces (config.readEntry(KEY_REMOVE_SPACES, 0));
|
|
setNewLineAtEof (config.readEntry(KEY_NEWLINE_AT_EOF, false));
|
|
setOvr (config.readEntry(KEY_OVR, false));
|
|
|
|
setEncoding (config.readEntry(KEY_ENCODING, ""));
|
|
|
|
setEol (config.readEntry(KEY_EOL, 0));
|
|
setAllowEolDetection (config.readEntry(KEY_ALLOW_EOL_DETECTION, true));
|
|
|
|
setBom (config.readEntry(KEY_BOM,false));
|
|
|
|
setAllowSimpleMode (config.readEntry(KEY_ALLOW_SIMPLE_MODE, true));
|
|
|
|
setBackupFlags (config.readEntry(KEY_BACKUP_FLAGS, 0));
|
|
|
|
setSearchDirConfigDepth (config.readEntry(KEY_SEARCH_DIR_CONFIG_DEPTH, 9));
|
|
|
|
setBackupPrefix (config.readEntry(KEY_BACKUP_PREFIX, QString ("")));
|
|
|
|
setBackupSuffix (config.readEntry(KEY_BACKUP_SUFFIX, QString ("~")));
|
|
|
|
setSwapFileNoSync (config.readEntry(KEY_SWAP_FILE_NO_SYNC, false));
|
|
|
|
setOnTheFlySpellCheck(config.readEntry(KEY_ON_THE_FLY_SPELLCHECK, false));
|
|
|
|
setLineLengthLimit(config.readEntry(KEY_LINE_LENGTH_LIMIT, 4096));
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateDocumentConfig::writeConfig (KConfigGroup &config)
|
|
{
|
|
config.writeEntry(KEY_TAB_WIDTH, tabWidth());
|
|
|
|
config.writeEntry(KEY_INDENTATION_WIDTH, indentationWidth());
|
|
config.writeEntry(KEY_INDENTATION_MODE, indentationMode());
|
|
|
|
config.writeEntry(KEY_TAB_HANDLING, tabHandling());
|
|
|
|
config.writeEntry(KEY_WORD_WRAP, wordWrap());
|
|
config.writeEntry(KEY_WORD_WRAP_AT, wordWrapAt());
|
|
|
|
config.writeEntry(KEY_PAGEUP_DOWN_MOVES_CURSOR, pageUpDownMovesCursor());
|
|
|
|
config.writeEntry(KEY_SMART_HOME, smartHome());
|
|
config.writeEntry(KEY_SHOW_TABS, showTabs());
|
|
config.writeEntry(KEY_TAB_INDENTS, tabIndentsEnabled());
|
|
config.writeEntry(KEY_KEEP_EXTRA_SPACES, keepExtraSpaces());
|
|
config.writeEntry(KEY_INDENT_PASTED_TEXT, indentPastedText());
|
|
config.writeEntry(KEY_BACKSPACE_INDENTS, backspaceIndents());
|
|
config.writeEntry(KEY_SHOW_SPACES, showSpaces());
|
|
config.writeEntry(KEY_REPLACE_TABS_DYN, replaceTabsDyn());
|
|
config.writeEntry(KEY_REMOVE_SPACES, removeSpaces());
|
|
config.writeEntry(KEY_NEWLINE_AT_EOF, newLineAtEof());
|
|
config.writeEntry(KEY_OVR, ovr());
|
|
|
|
config.writeEntry(KEY_ENCODING, encoding());
|
|
|
|
config.writeEntry(KEY_EOL, eol());
|
|
config.writeEntry(KEY_ALLOW_EOL_DETECTION, allowEolDetection());
|
|
|
|
config.writeEntry(KEY_BOM,bom());
|
|
|
|
config.writeEntry(KEY_ALLOW_SIMPLE_MODE, allowSimpleMode());
|
|
|
|
config.writeEntry(KEY_BACKUP_FLAGS, backupFlags());
|
|
|
|
config.writeEntry(KEY_SEARCH_DIR_CONFIG_DEPTH, searchDirConfigDepth());
|
|
|
|
config.writeEntry(KEY_BACKUP_PREFIX, backupPrefix());
|
|
|
|
config.writeEntry(KEY_BACKUP_SUFFIX, backupSuffix());
|
|
|
|
config.writeEntry(KEY_SWAP_FILE_NO_SYNC, swapFileNoSync());
|
|
|
|
config.writeEntry(KEY_ON_THE_FLY_SPELLCHECK, onTheFlySpellCheck());
|
|
|
|
config.writeEntry(KEY_LINE_LENGTH_LIMIT, lineLengthLimit());
|
|
}
|
|
|
|
void KateDocumentConfig::updateConfig ()
|
|
{
|
|
if (m_doc)
|
|
{
|
|
m_doc->updateConfig ();
|
|
return;
|
|
}
|
|
|
|
if (isGlobal())
|
|
{
|
|
for (int z=0; z < KateGlobal::self()->kateDocuments().size(); ++z)
|
|
(KateGlobal::self()->kateDocuments())[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;
|
|
|
|
if (m_tabWidthSet && m_tabWidth == tabWidth)
|
|
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;
|
|
|
|
if (m_indentationWidthSet && m_indentationWidth == indentationWidth)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_indentationWidthSet = true;
|
|
m_indentationWidth = indentationWidth;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QString &KateDocumentConfig::indentationMode () const
|
|
{
|
|
if (m_indentationModeSet || isGlobal())
|
|
return m_indentationMode;
|
|
|
|
return s_global->indentationMode();
|
|
}
|
|
|
|
void KateDocumentConfig::setIndentationMode (const QString &indentationMode)
|
|
{
|
|
if (m_indentationModeSet && m_indentationMode == indentationMode)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_indentationModeSet = true;
|
|
m_indentationMode = indentationMode;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
uint KateDocumentConfig::tabHandling () const
|
|
{
|
|
// This setting is purly a user preference,
|
|
// hence, there exists only the global setting.
|
|
if (isGlobal())
|
|
return m_tabHandling;
|
|
|
|
return s_global->tabHandling();
|
|
}
|
|
|
|
void KateDocumentConfig::setTabHandling (uint tabHandling)
|
|
{
|
|
configStart ();
|
|
|
|
m_tabHandling = tabHandling;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::wordWrap () const
|
|
{
|
|
if (m_wordWrapSet || isGlobal())
|
|
return m_wordWrap;
|
|
|
|
return s_global->wordWrap();
|
|
}
|
|
|
|
void KateDocumentConfig::setWordWrap (bool on)
|
|
{
|
|
if (m_wordWrapSet && m_wordWrap == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_wordWrapSet = true;
|
|
m_wordWrap = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateDocumentConfig::wordWrapAt () const
|
|
{
|
|
if (m_wordWrapAtSet || isGlobal())
|
|
return m_wordWrapAt;
|
|
|
|
return s_global->wordWrapAt();
|
|
}
|
|
|
|
void KateDocumentConfig::setWordWrapAt (int col)
|
|
{
|
|
if (col < 1)
|
|
return;
|
|
|
|
if (m_wordWrapAtSet && m_wordWrapAt == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_wordWrapAtSet = true;
|
|
m_wordWrapAt = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::pageUpDownMovesCursor () const
|
|
{
|
|
if (m_pageUpDownMovesCursorSet || isGlobal())
|
|
return m_pageUpDownMovesCursor;
|
|
|
|
return s_global->pageUpDownMovesCursor();
|
|
}
|
|
|
|
void KateDocumentConfig::setPageUpDownMovesCursor (bool on)
|
|
{
|
|
if (m_pageUpDownMovesCursorSet && m_pageUpDownMovesCursor == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_pageUpDownMovesCursorSet = true;
|
|
m_pageUpDownMovesCursor = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateDocumentConfig::setKeepExtraSpaces(bool on)
|
|
{
|
|
if (m_keepExtraSpacesSet && m_keepExtraSpaces == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_keepExtraSpacesSet = true;
|
|
m_keepExtraSpaces = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::keepExtraSpaces() const
|
|
{
|
|
if (m_keepExtraSpacesSet || isGlobal())
|
|
return m_keepExtraSpaces;
|
|
|
|
return s_global->keepExtraSpaces();
|
|
}
|
|
|
|
void KateDocumentConfig::setIndentPastedText(bool on)
|
|
{
|
|
if (m_indentPastedTextSet && m_indentPastedText == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_indentPastedTextSet = true;
|
|
m_indentPastedText = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::indentPastedText() const
|
|
{
|
|
if (m_indentPastedTextSet || isGlobal())
|
|
return m_indentPastedText;
|
|
|
|
return s_global->indentPastedText();
|
|
}
|
|
|
|
void KateDocumentConfig::setBackspaceIndents(bool on)
|
|
{
|
|
if (m_backspaceIndentsSet && m_backspaceIndents == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_backspaceIndentsSet = true;
|
|
m_backspaceIndents = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::backspaceIndents() const
|
|
{
|
|
if (m_backspaceIndentsSet || isGlobal())
|
|
return m_backspaceIndents;
|
|
|
|
return s_global->backspaceIndents();
|
|
}
|
|
|
|
void KateDocumentConfig::setSmartHome(bool on)
|
|
{
|
|
if (m_smartHomeSet && m_smartHome == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_smartHomeSet = true;
|
|
m_smartHome = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::smartHome() const
|
|
{
|
|
if (m_smartHomeSet || isGlobal())
|
|
return m_smartHome;
|
|
|
|
return s_global->smartHome();
|
|
}
|
|
|
|
void KateDocumentConfig::setShowTabs(bool on)
|
|
{
|
|
if (m_showTabsSet && m_showTabs == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_showTabsSet = true;
|
|
m_showTabs = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::showTabs() const
|
|
{
|
|
if (m_showTabsSet || isGlobal())
|
|
return m_showTabs;
|
|
|
|
return s_global->showTabs();
|
|
}
|
|
|
|
void KateDocumentConfig::setShowSpaces(bool on)
|
|
{
|
|
if (m_showSpacesSet && m_showSpaces == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_showSpacesSet = true;
|
|
m_showSpaces = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::showSpaces() const
|
|
{
|
|
if (m_showSpacesSet || isGlobal())
|
|
return m_showSpaces;
|
|
|
|
return s_global->showSpaces();
|
|
}
|
|
|
|
void KateDocumentConfig::setReplaceTabsDyn(bool on)
|
|
{
|
|
if (m_replaceTabsDynSet && m_replaceTabsDyn == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_replaceTabsDynSet = true;
|
|
m_replaceTabsDyn = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::replaceTabsDyn() const
|
|
{
|
|
if (m_replaceTabsDynSet || isGlobal())
|
|
return m_replaceTabsDyn;
|
|
|
|
return s_global->replaceTabsDyn();
|
|
}
|
|
|
|
void KateDocumentConfig::setRemoveSpaces(int triState)
|
|
{
|
|
if (m_removeSpacesSet && m_removeSpaces == triState)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_removeSpacesSet = true;
|
|
m_removeSpaces = triState;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateDocumentConfig::removeSpaces() const
|
|
{
|
|
if (m_removeSpacesSet || isGlobal())
|
|
return m_removeSpaces;
|
|
|
|
return s_global->removeSpaces();
|
|
}
|
|
|
|
void KateDocumentConfig::setNewLineAtEof (bool on)
|
|
{
|
|
if (m_newLineAtEofSet && m_newLineAtEof == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_newLineAtEofSet = true;
|
|
m_newLineAtEof = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::newLineAtEof () const
|
|
{
|
|
if (m_newLineAtEofSet || isGlobal())
|
|
return m_newLineAtEof;
|
|
|
|
return s_global->newLineAtEof();
|
|
}
|
|
|
|
void KateDocumentConfig::setOvr(bool on)
|
|
{
|
|
if (m_overwiteModeSet && m_overwiteMode == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_overwiteModeSet = true;
|
|
m_overwiteMode = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::ovr() const
|
|
{
|
|
if (m_overwiteModeSet || isGlobal())
|
|
return m_overwiteMode;
|
|
|
|
return s_global->ovr();
|
|
}
|
|
|
|
void KateDocumentConfig::setTabIndents(bool on)
|
|
{
|
|
if (m_tabIndentsSet && m_tabIndents == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_tabIndentsSet = true;
|
|
m_tabIndents = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::tabIndentsEnabled() const
|
|
{
|
|
if (m_tabIndentsSet || isGlobal())
|
|
return m_tabIndents;
|
|
|
|
return s_global->tabIndentsEnabled();
|
|
}
|
|
|
|
const QString &KateDocumentConfig::encoding () const
|
|
{
|
|
if (m_encodingSet || isGlobal())
|
|
return m_encoding;
|
|
|
|
return s_global->encoding();
|
|
}
|
|
|
|
QTextCodec *KateDocumentConfig::codec () const
|
|
{
|
|
if (m_encodingSet || isGlobal())
|
|
{
|
|
if (m_encoding.isEmpty() && isGlobal())
|
|
return KGlobal::locale()->codecForEncoding();
|
|
else if (m_encoding.isEmpty())
|
|
return s_global->codec ();
|
|
else
|
|
return KGlobal::charsets()->codecForName (m_encoding);
|
|
}
|
|
|
|
return s_global->codec ();
|
|
}
|
|
|
|
bool KateDocumentConfig::setEncoding (const QString &encoding)
|
|
{
|
|
QTextCodec *codec;
|
|
bool found = false;
|
|
if (encoding.isEmpty())
|
|
{
|
|
codec = s_global->codec();
|
|
found=true;
|
|
}
|
|
else
|
|
codec = KGlobal::charsets()->codecForName (encoding, found);
|
|
|
|
if (!found || !codec)
|
|
return false;
|
|
|
|
configStart ();
|
|
m_encodingSet = true;
|
|
m_encoding = codec->name();
|
|
|
|
if (isGlobal())
|
|
KateGlobal::self()->setDefaultEncoding (m_encoding);
|
|
|
|
configEnd ();
|
|
return true;
|
|
}
|
|
|
|
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)
|
|
{
|
|
if (m_eolSet && m_eol == mode)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_eolSet = true;
|
|
m_eol = mode;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateDocumentConfig::setBom (bool bom)
|
|
{
|
|
if (m_bomSet && m_bom == bom)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_bomSet = true;
|
|
m_bom = bom;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::bom() const
|
|
{
|
|
if (m_bomSet || isGlobal())
|
|
return m_bom;
|
|
|
|
return s_global->bom();
|
|
}
|
|
|
|
bool KateDocumentConfig::allowEolDetection () const
|
|
{
|
|
if (m_allowEolDetectionSet || isGlobal())
|
|
return m_allowEolDetection;
|
|
|
|
return s_global->allowEolDetection();
|
|
}
|
|
|
|
void KateDocumentConfig::setAllowEolDetection (bool on)
|
|
{
|
|
if (m_allowEolDetectionSet && m_allowEolDetection == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_allowEolDetectionSet = true;
|
|
m_allowEolDetection = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::allowSimpleMode () const
|
|
{
|
|
if (m_allowSimpleModeSet || isGlobal())
|
|
return m_allowSimpleMode;
|
|
|
|
return s_global->allowSimpleMode();
|
|
}
|
|
|
|
void KateDocumentConfig::setAllowSimpleMode (bool on)
|
|
{
|
|
if (m_allowSimpleModeSet && m_allowSimpleMode == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_allowSimpleModeSet = true;
|
|
m_allowSimpleMode = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
uint KateDocumentConfig::backupFlags () const
|
|
{
|
|
if (m_backupFlagsSet || isGlobal())
|
|
return m_backupFlags;
|
|
|
|
return s_global->backupFlags();
|
|
}
|
|
|
|
void KateDocumentConfig::setBackupFlags (uint flags)
|
|
{
|
|
if (m_backupFlagsSet && m_backupFlags == flags)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_backupPrefixSet && m_backupPrefix == prefix)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_backupPrefixSet = true;
|
|
m_backupPrefix = prefix;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateDocumentConfig::setBackupSuffix (const QString &suffix)
|
|
{
|
|
if (m_backupSuffixSet && m_backupSuffix == suffix)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_backupSuffixSet = true;
|
|
m_backupSuffix = suffix;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::swapFileNoSync() const
|
|
{
|
|
if (m_swapFileNoSyncSet || isGlobal())
|
|
return m_swapFileNoSync;
|
|
|
|
return s_global->swapFileNoSync();
|
|
}
|
|
|
|
void KateDocumentConfig::setSwapFileNoSync(bool on)
|
|
{
|
|
if (m_swapFileNoSyncSet && m_swapFileNoSync == on)
|
|
return;
|
|
|
|
configStart();
|
|
|
|
m_swapFileNoSyncSet = true;
|
|
m_swapFileNoSync = on;
|
|
|
|
configEnd();
|
|
}
|
|
|
|
int KateDocumentConfig::searchDirConfigDepth () const
|
|
{
|
|
if (m_searchDirConfigDepthSet || isGlobal())
|
|
return m_searchDirConfigDepth;
|
|
|
|
return s_global->searchDirConfigDepth ();
|
|
}
|
|
|
|
void KateDocumentConfig::setSearchDirConfigDepth (int depth)
|
|
{
|
|
if (m_searchDirConfigDepthSet && m_searchDirConfigDepth == depth)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_searchDirConfigDepthSet = true;
|
|
m_searchDirConfigDepth = depth;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateDocumentConfig::onTheFlySpellCheck() const
|
|
{
|
|
if(isGlobal()) {
|
|
// WARNING: this is slightly hackish, but it's currently the only way to
|
|
// do it, see also the KTextEdit class
|
|
KConfigGroup configGroup(KGlobal::config(), "Spelling");
|
|
return configGroup.readEntry("checkerEnabledByDefault", false);
|
|
}
|
|
if (m_onTheFlySpellCheckSet) {
|
|
return m_onTheFlySpellCheck;
|
|
}
|
|
|
|
return s_global->onTheFlySpellCheck();
|
|
}
|
|
|
|
void KateDocumentConfig::setOnTheFlySpellCheck(bool on)
|
|
{
|
|
if (m_onTheFlySpellCheckSet && m_onTheFlySpellCheck == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_onTheFlySpellCheckSet = true;
|
|
m_onTheFlySpellCheck = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
|
|
int KateDocumentConfig::lineLengthLimit() const
|
|
{
|
|
if (m_lineLengthLimitSet || isGlobal())
|
|
return m_lineLengthLimit;
|
|
|
|
return s_global->lineLengthLimit();
|
|
}
|
|
|
|
void KateDocumentConfig::setLineLengthLimit(int lineLengthLimit)
|
|
{
|
|
if (m_lineLengthLimitSet && m_lineLengthLimit == lineLengthLimit)
|
|
return;
|
|
|
|
configStart();
|
|
|
|
m_lineLengthLimitSet = true;
|
|
m_lineLengthLimit = lineLengthLimit;
|
|
|
|
configEnd();
|
|
}
|
|
|
|
|
|
|
|
//END
|
|
|
|
//BEGIN KateViewConfig
|
|
KateViewConfig::KateViewConfig ()
|
|
:
|
|
m_dynWordWrapSet (false),
|
|
m_dynWordWrapIndicatorsSet (false),
|
|
m_dynWordWrapAlignIndentSet (false),
|
|
m_lineNumbersSet (false),
|
|
m_scrollBarMarksSet (false),
|
|
m_scrollBarMiniMapSet (false),
|
|
m_scrollBarMiniMapAllSet (false),
|
|
m_scrollBarMiniMapWidthSet (false),
|
|
m_showScrollbarsSet (false),
|
|
m_iconBarSet (false),
|
|
m_foldingBarSet (false),
|
|
m_lineModificationSet (false),
|
|
m_bookmarkSortSet (false),
|
|
m_autoCenterLinesSet (false),
|
|
m_searchFlagsSet (false),
|
|
m_defaultMarkTypeSet (false),
|
|
m_persistentSelectionSet (false),
|
|
m_viInputModeSet (false),
|
|
m_viInputModeStealKeysSet (false),
|
|
m_viRelativeLineNumbersSet (false),
|
|
m_viInputModeEmulateCommandBarSet(false),
|
|
m_automaticCompletionInvocationSet (false),
|
|
m_wordCompletionSet (false),
|
|
m_keywordCompletionSet (false),
|
|
m_wordCompletionMinimalWordLengthSet (false),
|
|
m_smartCopyCutSet (false),
|
|
m_scrollPastEndSet (false),
|
|
m_allowMarkMenu (true),
|
|
m_wordCompletionRemoveTailSet (false),
|
|
m_foldFirstLineSet (false),
|
|
m_view (0)
|
|
{
|
|
s_global = this;
|
|
|
|
// init with defaults from config or really hardcoded ones
|
|
KConfigGroup config( KGlobal::config(), "Kate View Defaults");
|
|
readConfig (config);
|
|
}
|
|
|
|
KateViewConfig::KateViewConfig (KateView *view)
|
|
:
|
|
m_searchFlags (PowerModePlainText),
|
|
m_maxHistorySize (100),
|
|
m_dynWordWrapSet (false),
|
|
m_dynWordWrapIndicatorsSet (false),
|
|
m_dynWordWrapAlignIndentSet (false),
|
|
m_lineNumbersSet (false),
|
|
m_scrollBarMarksSet (false),
|
|
m_scrollBarMiniMapSet (false),
|
|
m_scrollBarMiniMapAllSet (false),
|
|
m_scrollBarMiniMapWidthSet (false),
|
|
m_showScrollbarsSet (false),
|
|
m_iconBarSet (false),
|
|
m_foldingBarSet (false),
|
|
m_lineModificationSet (false),
|
|
m_bookmarkSortSet (false),
|
|
m_autoCenterLinesSet (false),
|
|
m_searchFlagsSet (false),
|
|
m_defaultMarkTypeSet (false),
|
|
m_persistentSelectionSet (false),
|
|
m_viInputModeSet (false),
|
|
m_viInputModeStealKeysSet (false),
|
|
m_viRelativeLineNumbersSet (false),
|
|
m_viInputModeEmulateCommandBarSet(false),
|
|
m_automaticCompletionInvocationSet (false),
|
|
m_wordCompletionSet (false),
|
|
m_keywordCompletionSet (false),
|
|
m_wordCompletionMinimalWordLengthSet (false),
|
|
m_smartCopyCutSet (false),
|
|
m_scrollPastEndSet (false),
|
|
m_allowMarkMenu (true),
|
|
m_wordCompletionRemoveTailSet (false),
|
|
m_foldFirstLineSet (false),
|
|
m_view (view)
|
|
{
|
|
}
|
|
|
|
KateViewConfig::~KateViewConfig ()
|
|
{
|
|
}
|
|
|
|
namespace
|
|
{
|
|
const char * const KEY_SEARCH_REPLACE_FLAGS = "Search/Replace Flags";
|
|
const char * const KEY_PATTERN_HISTORY = "Search Pattern History";
|
|
const char * const KEY_REPLACEMENT_HISTORY = "Replacement Text History";
|
|
const char * const KEY_DYN_WORD_WRAP = "Dynamic Word Wrap";
|
|
const char * const KEY_DYN_WORD_WRAP_INDICATORS = "Dynamic Word Wrap Indicators";
|
|
const char * const KEY_DYN_WORD_WRAP_ALIGN_INDENT = "Dynamic Word Wrap Align Indent";
|
|
const char * const KEY_LINE_NUMBERS = "Line Numbers";
|
|
const char * const KEY_SCROLL_BAR_MARKS = "Scroll Bar Marks";
|
|
const char * const KEY_SCROLL_BAR_MINI_MAP = "Scroll Bar Mini Map";
|
|
const char * const KEY_SCROLL_BAR_MINI_MAP_ALL = "Scroll Bar Mini Map All";
|
|
const char * const KEY_SCROLL_BAR_MINI_MAP_WIDTH = "Scroll Bar Mini Map Width";
|
|
const char * const KEY_SHOW_SCROLLBARS = "Show Scrollbars";
|
|
const char * const KEY_ICON_BAR = "Icon Bar";
|
|
const char * const KEY_FOLDING_BAR = "Folding Bar";
|
|
const char * const KEY_LINE_MODIFICATION = "Line Modification";
|
|
const char * const KEY_BOOKMARK_SORT = "Bookmark Menu Sorting";
|
|
const char * const KEY_AUTO_CENTER_LINES = "Auto Center Lines";
|
|
const char * const KEY_MAX_HISTORY_SIZE = "Maximum Search History Size";
|
|
const char * const KEY_DEFAULT_MARK_TYPE = "Default Mark Type";
|
|
const char * const KEY_ALLOW_MARK_MENU = "Allow Mark Menu";
|
|
const char * const KEY_PERSISTENT_SELECTION = "Persistent Selection";
|
|
const char * const KEY_VI_INPUT_MODE = "Vi Input Mode";
|
|
const char * const KEY_VI_INPUT_MODE_STEAL_KEYS = "Vi Input Mode Steal Keys";
|
|
const char * const KEY_VI_RELATIVE_LINE_NUMBERS = "Vi Relative Line Numbers";
|
|
const char * const KEY_VI_INPUT_MODE_EMULATE_COMMAND_BAR = "Vi Input Mode Emulate Command Bar";
|
|
const char * const KEY_AUTOMATIC_COMPLETION_INVOCATION = "Auto Completion";
|
|
const char * const KEY_WORD_COMPLETION = "Word Completion";
|
|
const char * const KEY_KEYWORD_COMPLETION = "Keyword Completion";
|
|
const char * const KEY_WORD_COMPLETION_MINIMAL_WORD_LENGTH = "Word Completion Minimal Word Length";
|
|
const char * const KEY_WORD_COMPLETION_REMOVE_TAIL = "Word Completion Remove Tail";
|
|
const char * const KEY_SMART_COPY_CUT = "Smart Copy Cut";
|
|
const char * const KEY_SCROLL_PAST_END = "Scroll Past End";
|
|
const char * const KEY_FOLD_FIRST_LINE = "Fold First Line";
|
|
}
|
|
|
|
void KateViewConfig::readConfig ( const KConfigGroup &config)
|
|
{
|
|
configStart ();
|
|
|
|
// default off again, until this is usable for large size documents
|
|
setDynWordWrap (config.readEntry( KEY_DYN_WORD_WRAP, false ));
|
|
setDynWordWrapIndicators (config.readEntry( KEY_DYN_WORD_WRAP_INDICATORS, 1 ));
|
|
setDynWordWrapAlignIndent (config.readEntry( KEY_DYN_WORD_WRAP_ALIGN_INDENT, 80 ));
|
|
|
|
setLineNumbers (config.readEntry( KEY_LINE_NUMBERS, false));
|
|
|
|
setScrollBarMarks (config.readEntry( KEY_SCROLL_BAR_MARKS, false));
|
|
|
|
setScrollBarMiniMap (config.readEntry( KEY_SCROLL_BAR_MINI_MAP, false));
|
|
|
|
setScrollBarMiniMapAll (config.readEntry( KEY_SCROLL_BAR_MINI_MAP_ALL, false));
|
|
|
|
setScrollBarMiniMapWidth (config.readEntry( KEY_SCROLL_BAR_MINI_MAP_WIDTH, 60));
|
|
|
|
setShowScrollbars (config.readEntry( KEY_SHOW_SCROLLBARS, static_cast<int>(AlwaysOn)));
|
|
|
|
setIconBar (config.readEntry( KEY_ICON_BAR, false ));
|
|
|
|
setFoldingBar (config.readEntry( KEY_FOLDING_BAR, true));
|
|
|
|
setLineModification (config.readEntry( KEY_LINE_MODIFICATION, false));
|
|
|
|
setBookmarkSort (config.readEntry( KEY_BOOKMARK_SORT, 0 ));
|
|
|
|
setAutoCenterLines (config.readEntry( KEY_AUTO_CENTER_LINES, 0 ));
|
|
|
|
setSearchFlags(config.readEntry(KEY_SEARCH_REPLACE_FLAGS,
|
|
IncFromCursor|PowerMatchCase|PowerModePlainText));
|
|
|
|
m_maxHistorySize = config.readEntry(KEY_MAX_HISTORY_SIZE, 100);
|
|
|
|
setDefaultMarkType (config.readEntry( KEY_DEFAULT_MARK_TYPE, int(KTextEditor::MarkInterface::markType01) ));
|
|
setAllowMarkMenu (config.readEntry( KEY_ALLOW_MARK_MENU, true ));
|
|
|
|
setPersistentSelection (config.readEntry( KEY_PERSISTENT_SELECTION, false ));
|
|
|
|
setViInputMode (config.readEntry( KEY_VI_INPUT_MODE, false));
|
|
setViInputModeStealKeys (config.readEntry( KEY_VI_INPUT_MODE_STEAL_KEYS, false));
|
|
setViRelativeLineNumbers(config.readEntry( KEY_VI_RELATIVE_LINE_NUMBERS, false));
|
|
setViInputModeEmulateCommandBar (config.readEntry( KEY_VI_INPUT_MODE_EMULATE_COMMAND_BAR, false));
|
|
|
|
setAutomaticCompletionInvocation (config.readEntry( KEY_AUTOMATIC_COMPLETION_INVOCATION, true ));
|
|
setWordCompletion (config.readEntry( KEY_WORD_COMPLETION, true ));
|
|
setKeywordCompletion (config.readEntry( KEY_KEYWORD_COMPLETION, true ));
|
|
setWordCompletionMinimalWordLength (config.readEntry( KEY_WORD_COMPLETION_MINIMAL_WORD_LENGTH, 3 ));
|
|
setWordCompletionRemoveTail (config.readEntry( KEY_WORD_COMPLETION_REMOVE_TAIL, true ));
|
|
setSmartCopyCut (config.readEntry( KEY_SMART_COPY_CUT, false ));
|
|
setScrollPastEnd (config.readEntry( KEY_SCROLL_PAST_END, false ));
|
|
setFoldFirstLine (config.readEntry( KEY_FOLD_FIRST_LINE, false ));
|
|
|
|
if (isGlobal()) {
|
|
// Read search pattern history
|
|
QStringList patternHistory = config.readEntry(KEY_PATTERN_HISTORY, QStringList());
|
|
m_patternHistoryModel.setStringList(patternHistory);
|
|
|
|
// Read replacement text history
|
|
QStringList replacementHistory = config.readEntry(KEY_REPLACEMENT_HISTORY, QStringList());
|
|
m_replacementHistoryModel.setStringList(replacementHistory);
|
|
}
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateViewConfig::writeConfig (KConfigGroup &config)
|
|
{
|
|
config.writeEntry( KEY_DYN_WORD_WRAP, dynWordWrap() );
|
|
config.writeEntry( KEY_DYN_WORD_WRAP_INDICATORS, dynWordWrapIndicators() );
|
|
config.writeEntry( KEY_DYN_WORD_WRAP_ALIGN_INDENT, dynWordWrapAlignIndent() );
|
|
|
|
config.writeEntry( KEY_LINE_NUMBERS, lineNumbers() );
|
|
|
|
config.writeEntry( KEY_SCROLL_BAR_MARKS, scrollBarMarks() );
|
|
|
|
config.writeEntry( KEY_SCROLL_BAR_MINI_MAP, scrollBarMiniMap() );
|
|
|
|
config.writeEntry( KEY_SCROLL_BAR_MINI_MAP_ALL, scrollBarMiniMapAll() );
|
|
|
|
config.writeEntry( KEY_SCROLL_BAR_MINI_MAP_WIDTH, scrollBarMiniMapWidth() );
|
|
|
|
config.writeEntry( KEY_SHOW_SCROLLBARS, showScrollbars() );
|
|
|
|
config.writeEntry( KEY_ICON_BAR, iconBar() );
|
|
|
|
config.writeEntry( KEY_FOLDING_BAR, foldingBar() );
|
|
|
|
config.writeEntry( KEY_LINE_MODIFICATION, lineModification() );
|
|
|
|
config.writeEntry( KEY_BOOKMARK_SORT, bookmarkSort() );
|
|
|
|
config.writeEntry( KEY_AUTO_CENTER_LINES, autoCenterLines() );
|
|
|
|
config.writeEntry(KEY_SEARCH_REPLACE_FLAGS, int(searchFlags()));
|
|
|
|
config.writeEntry(KEY_MAX_HISTORY_SIZE, m_maxHistorySize);
|
|
|
|
config.writeEntry(KEY_DEFAULT_MARK_TYPE, defaultMarkType());
|
|
|
|
config.writeEntry(KEY_ALLOW_MARK_MENU, allowMarkMenu());
|
|
|
|
config.writeEntry(KEY_PERSISTENT_SELECTION, persistentSelection());
|
|
|
|
config.writeEntry( KEY_AUTOMATIC_COMPLETION_INVOCATION, automaticCompletionInvocation());
|
|
config.writeEntry( KEY_WORD_COMPLETION, wordCompletion());
|
|
config.writeEntry( KEY_KEYWORD_COMPLETION, keywordCompletion());
|
|
config.writeEntry( KEY_WORD_COMPLETION_MINIMAL_WORD_LENGTH, wordCompletionMinimalWordLength());
|
|
config.writeEntry( KEY_WORD_COMPLETION_REMOVE_TAIL, wordCompletionRemoveTail());
|
|
|
|
config.writeEntry( KEY_SMART_COPY_CUT, smartCopyCut() );
|
|
config.writeEntry( KEY_SCROLL_PAST_END , scrollPastEnd() );
|
|
config.writeEntry( KEY_FOLD_FIRST_LINE, foldFirstLine() );
|
|
|
|
config.writeEntry( KEY_VI_INPUT_MODE, viInputMode());
|
|
config.writeEntry( KEY_VI_INPUT_MODE_STEAL_KEYS, viInputModeStealKeys());
|
|
config.writeEntry( KEY_VI_RELATIVE_LINE_NUMBERS, viRelativeLineNumbers());
|
|
config.writeEntry( KEY_VI_INPUT_MODE_EMULATE_COMMAND_BAR, viInputModeEmulateCommandBar());
|
|
|
|
|
|
if (isGlobal()) {
|
|
// Write search pattern history
|
|
config.writeEntry(KEY_PATTERN_HISTORY, m_patternHistoryModel.stringList());
|
|
|
|
// Write replacement text history
|
|
config.writeEntry(KEY_REPLACEMENT_HISTORY, m_replacementHistoryModel.stringList());
|
|
}
|
|
}
|
|
|
|
void KateViewConfig::updateConfig ()
|
|
{
|
|
if (m_view)
|
|
{
|
|
m_view->updateConfig ();
|
|
return;
|
|
}
|
|
|
|
if (isGlobal())
|
|
{
|
|
for (int z=0; z < KateGlobal::self()->views().size(); ++z)
|
|
(KateGlobal::self()->views())[z]->updateConfig ();
|
|
}
|
|
}
|
|
|
|
bool KateViewConfig::dynWordWrap () const
|
|
{
|
|
if (m_dynWordWrapSet || isGlobal())
|
|
return m_dynWordWrap;
|
|
|
|
return s_global->dynWordWrap();
|
|
}
|
|
|
|
void KateViewConfig::setDynWordWrap (bool wrap)
|
|
{
|
|
if (m_dynWordWrapSet && m_dynWordWrap == wrap)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_dynWordWrapIndicatorsSet && m_dynWordWrapIndicators == mode)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_dynWordWrapIndicatorsSet = true;
|
|
m_dynWordWrapIndicators = qBound(0, mode, 80);
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateViewConfig::dynWordWrapAlignIndent () const
|
|
{
|
|
if (m_dynWordWrapAlignIndentSet || isGlobal())
|
|
return m_dynWordWrapAlignIndent;
|
|
|
|
return s_global->dynWordWrapAlignIndent();
|
|
}
|
|
|
|
void KateViewConfig::setDynWordWrapAlignIndent (int indent)
|
|
{
|
|
if (m_dynWordWrapAlignIndentSet && m_dynWordWrapAlignIndent == indent)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_lineNumbersSet && m_lineNumbers == on)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_scrollBarMarksSet && m_scrollBarMarks == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_scrollBarMarksSet = true;
|
|
m_scrollBarMarks = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::scrollBarMiniMap () const
|
|
{
|
|
if (m_scrollBarMiniMapSet || isGlobal())
|
|
return m_scrollBarMiniMap;
|
|
|
|
return s_global->scrollBarMiniMap();
|
|
}
|
|
|
|
void KateViewConfig::setScrollBarMiniMap (bool on)
|
|
{
|
|
if (m_scrollBarMiniMapSet && m_scrollBarMiniMap == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_scrollBarMiniMapSet = true;
|
|
m_scrollBarMiniMap = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::scrollBarMiniMapAll () const
|
|
{
|
|
if (m_scrollBarMiniMapAllSet || isGlobal())
|
|
return m_scrollBarMiniMapAll;
|
|
|
|
return s_global->scrollBarMiniMapAll();
|
|
}
|
|
|
|
void KateViewConfig::setScrollBarMiniMapAll (bool on)
|
|
{
|
|
if (m_scrollBarMiniMapAllSet && m_scrollBarMiniMapAll == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_scrollBarMiniMapAllSet = true;
|
|
m_scrollBarMiniMapAll = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateViewConfig::scrollBarMiniMapWidth () const
|
|
{
|
|
if (m_scrollBarMiniMapWidthSet || isGlobal())
|
|
return m_scrollBarMiniMapWidth;
|
|
|
|
return s_global->scrollBarMiniMapWidth();
|
|
}
|
|
|
|
void KateViewConfig::setScrollBarMiniMapWidth (int width)
|
|
{
|
|
if (m_scrollBarMiniMapWidthSet && m_scrollBarMiniMapWidth == width)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_scrollBarMiniMapWidthSet = true;
|
|
m_scrollBarMiniMapWidth = width;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateViewConfig::showScrollbars() const
|
|
{
|
|
if (m_showScrollbarsSet || isGlobal())
|
|
return m_showScrollbars;
|
|
|
|
return s_global->showScrollbars();
|
|
}
|
|
|
|
void KateViewConfig::setShowScrollbars(int mode)
|
|
{
|
|
if (m_showScrollbarsSet && m_showScrollbars == mode)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_showScrollbarsSet = true;
|
|
m_showScrollbars = qBound(0, mode, 80);
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::iconBar () const
|
|
{
|
|
if (m_iconBarSet || isGlobal())
|
|
return m_iconBar;
|
|
|
|
return s_global->iconBar();
|
|
}
|
|
|
|
void KateViewConfig::setIconBar (bool on)
|
|
{
|
|
if (m_iconBarSet && m_iconBar == on)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_foldingBarSet && m_foldingBar == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_foldingBarSet = true;
|
|
m_foldingBar = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::lineModification () const
|
|
{
|
|
if (m_lineModificationSet || isGlobal())
|
|
return m_lineModification;
|
|
|
|
return s_global->lineModification();
|
|
}
|
|
|
|
void KateViewConfig::setLineModification (bool on)
|
|
{
|
|
if (m_lineModificationSet && m_lineModification == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_lineModificationSet = true;
|
|
m_lineModification = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
int KateViewConfig::bookmarkSort () const
|
|
{
|
|
if (m_bookmarkSortSet || isGlobal())
|
|
return m_bookmarkSort;
|
|
|
|
return s_global->bookmarkSort();
|
|
}
|
|
|
|
void KateViewConfig::setBookmarkSort (int mode)
|
|
{
|
|
if (m_bookmarkSortSet && m_bookmarkSort == mode)
|
|
return;
|
|
|
|
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;
|
|
|
|
if (m_autoCenterLinesSet && m_autoCenterLines == lines)
|
|
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)
|
|
{
|
|
if (m_searchFlagsSet && m_searchFlags == flags)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_searchFlagsSet = true;
|
|
m_searchFlags = flags;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
QStringListModel *KateViewConfig::patternHistoryModel()
|
|
{
|
|
// always return global history
|
|
if (isGlobal())
|
|
return &m_patternHistoryModel;
|
|
|
|
return s_global->patternHistoryModel();
|
|
}
|
|
|
|
int KateViewConfig::maxHistorySize() const
|
|
{
|
|
return m_maxHistorySize;
|
|
}
|
|
|
|
QStringListModel *KateViewConfig::replacementHistoryModel()
|
|
{
|
|
// always return global history
|
|
if (isGlobal())
|
|
return &m_replacementHistoryModel;
|
|
|
|
return s_global->replacementHistoryModel();
|
|
}
|
|
|
|
uint KateViewConfig::defaultMarkType () const
|
|
{
|
|
if (m_defaultMarkTypeSet || isGlobal())
|
|
return m_defaultMarkType;
|
|
|
|
return s_global->defaultMarkType();
|
|
}
|
|
|
|
void KateViewConfig::setDefaultMarkType (uint type)
|
|
{
|
|
if (m_defaultMarkTypeSet && m_defaultMarkType == type)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_defaultMarkTypeSet = true;
|
|
m_defaultMarkType = type;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::allowMarkMenu() const
|
|
{
|
|
return m_allowMarkMenu;
|
|
}
|
|
|
|
void KateViewConfig::setAllowMarkMenu (bool allow)
|
|
{
|
|
m_allowMarkMenu = allow;
|
|
}
|
|
|
|
bool KateViewConfig::persistentSelection () const
|
|
{
|
|
if (m_persistentSelectionSet || isGlobal())
|
|
return m_persistentSelection;
|
|
|
|
return s_global->persistentSelection();
|
|
}
|
|
|
|
void KateViewConfig::setPersistentSelection (bool on)
|
|
{
|
|
if (m_persistentSelectionSet && m_persistentSelection == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_persistentSelectionSet = true;
|
|
m_persistentSelection = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::viInputMode () const
|
|
{
|
|
if (m_viInputModeSet || isGlobal())
|
|
return m_viInputMode;
|
|
|
|
return s_global->viInputMode();
|
|
}
|
|
|
|
void KateViewConfig::setViInputMode (bool on)
|
|
{
|
|
if (m_viInputModeSet && m_viInputMode == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_viInputModeSet = true;
|
|
m_viInputMode = on;
|
|
|
|
// make sure to turn off edits mergin when leaving vi input mode
|
|
if (!on && m_view) {
|
|
m_view->doc()->setUndoMergeAllEdits(false);
|
|
}
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::viInputModeStealKeys () const
|
|
{
|
|
if (m_viInputModeStealKeysSet || isGlobal())
|
|
return m_viInputModeStealKeys;
|
|
|
|
return s_global->viInputModeStealKeys();
|
|
}
|
|
|
|
void KateViewConfig::setViInputModeStealKeys (bool on)
|
|
{
|
|
if (m_viInputModeStealKeysSet && m_viInputModeStealKeys == on)
|
|
return;
|
|
|
|
configStart ();
|
|
m_viInputModeStealKeysSet = true;
|
|
m_viInputModeStealKeys = on;
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::viRelativeLineNumbers() const
|
|
{
|
|
if (m_viRelativeLineNumbersSet || isGlobal())
|
|
return m_viRelativeLineNumbers;
|
|
|
|
return s_global->viRelativeLineNumbers();
|
|
}
|
|
|
|
void KateViewConfig::setViRelativeLineNumbers(bool on)
|
|
{
|
|
if (m_viRelativeLineNumbersSet && m_viRelativeLineNumbers == on)
|
|
return;
|
|
|
|
configStart();
|
|
m_viRelativeLineNumbersSet = true;
|
|
m_viRelativeLineNumbers = on;
|
|
configEnd();
|
|
}
|
|
|
|
bool KateViewConfig::viInputModeEmulateCommandBar() const
|
|
{
|
|
if (m_viInputModeEmulateCommandBarSet || isGlobal())
|
|
return m_viInputModeEmulateCommandBar;
|
|
|
|
return s_global->viInputModeEmulateCommandBar();
|
|
}
|
|
|
|
void KateViewConfig::setViInputModeEmulateCommandBar(bool on)
|
|
{
|
|
if (m_viInputModeEmulateCommandBarSet && m_viInputModeEmulateCommandBar == on)
|
|
return;
|
|
|
|
configStart();
|
|
m_viInputModeEmulateCommandBarSet = true;
|
|
m_viInputModeEmulateCommandBar = on;
|
|
configEnd();
|
|
}
|
|
|
|
bool KateViewConfig::automaticCompletionInvocation () const
|
|
{
|
|
if (m_automaticCompletionInvocationSet || isGlobal())
|
|
return m_automaticCompletionInvocation;
|
|
|
|
return s_global->automaticCompletionInvocation();
|
|
}
|
|
|
|
void KateViewConfig::setAutomaticCompletionInvocation (bool on)
|
|
{
|
|
if (m_automaticCompletionInvocationSet && m_automaticCompletionInvocation == on)
|
|
return;
|
|
|
|
configStart ();
|
|
m_automaticCompletionInvocationSet = true;
|
|
m_automaticCompletionInvocation = on;
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::wordCompletion () const
|
|
{
|
|
if (m_wordCompletionSet || isGlobal())
|
|
return m_wordCompletion;
|
|
|
|
return s_global->wordCompletion();
|
|
}
|
|
|
|
void KateViewConfig::setWordCompletion (bool on)
|
|
{
|
|
if (m_wordCompletionSet && m_wordCompletion == on)
|
|
return;
|
|
|
|
configStart ();
|
|
m_wordCompletionSet = true;
|
|
m_wordCompletion = on;
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::keywordCompletion() const
|
|
{
|
|
if (m_keywordCompletionSet || isGlobal())
|
|
return m_keywordCompletion;
|
|
return s_global->keywordCompletion();
|
|
}
|
|
|
|
void KateViewConfig::setKeywordCompletion(bool on)
|
|
{
|
|
if (m_keywordCompletionSet && m_keywordCompletion == on)
|
|
return;
|
|
configStart();
|
|
m_keywordCompletionSet = true;
|
|
m_keywordCompletion = on;
|
|
configEnd();
|
|
}
|
|
|
|
int KateViewConfig::wordCompletionMinimalWordLength () const
|
|
{
|
|
if (m_wordCompletionMinimalWordLengthSet || isGlobal())
|
|
return m_wordCompletionMinimalWordLength;
|
|
|
|
return s_global->wordCompletionMinimalWordLength();
|
|
}
|
|
|
|
void KateViewConfig::setWordCompletionMinimalWordLength (int length)
|
|
{
|
|
if (m_wordCompletionMinimalWordLengthSet && m_wordCompletionMinimalWordLength == length)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_wordCompletionMinimalWordLengthSet = true;
|
|
m_wordCompletionMinimalWordLength = length;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::wordCompletionRemoveTail () const
|
|
{
|
|
if (m_wordCompletionRemoveTailSet || isGlobal())
|
|
return m_wordCompletionRemoveTail;
|
|
|
|
return s_global->wordCompletionRemoveTail();
|
|
}
|
|
|
|
void KateViewConfig::setWordCompletionRemoveTail (bool on)
|
|
{
|
|
if (m_wordCompletionRemoveTailSet && m_wordCompletionRemoveTail == on)
|
|
return;
|
|
|
|
configStart ();
|
|
m_wordCompletionRemoveTailSet = true;
|
|
m_wordCompletionRemoveTail = on;
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::smartCopyCut () const
|
|
{
|
|
if (m_smartCopyCutSet || isGlobal())
|
|
return m_smartCopyCut;
|
|
|
|
return s_global->smartCopyCut();
|
|
}
|
|
|
|
void KateViewConfig::setSmartCopyCut (bool on)
|
|
{
|
|
if (m_smartCopyCutSet && m_smartCopyCut == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_smartCopyCutSet = true;
|
|
m_smartCopyCut = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::scrollPastEnd () const
|
|
{
|
|
if (m_scrollPastEndSet || isGlobal())
|
|
return m_scrollPastEnd;
|
|
|
|
return s_global->scrollPastEnd();
|
|
}
|
|
|
|
void KateViewConfig::setScrollPastEnd (bool on)
|
|
{
|
|
if (m_scrollPastEndSet && m_scrollPastEnd == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_scrollPastEndSet = true;
|
|
m_scrollPastEnd = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateViewConfig::foldFirstLine() const
|
|
{
|
|
if (m_foldFirstLineSet || isGlobal())
|
|
return m_foldFirstLine;
|
|
|
|
return s_global->foldFirstLine();
|
|
}
|
|
|
|
void KateViewConfig::setFoldFirstLine(bool on)
|
|
{
|
|
if (m_foldFirstLineSet && m_foldFirstLine == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_foldFirstLineSet = true;
|
|
m_foldFirstLine = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
//END
|
|
|
|
//BEGIN KateRendererConfig
|
|
KateRendererConfig::KateRendererConfig ()
|
|
: m_fontMetrics(QFont()),
|
|
m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
|
|
m_wordWrapMarker (false),
|
|
m_showIndentationLines (false),
|
|
m_showWholeBracketExpression (false),
|
|
m_animateBracketMatching (false),
|
|
m_schemaSet (false),
|
|
m_fontSet (false),
|
|
m_wordWrapMarkerSet (false),
|
|
m_showIndentationLinesSet (false),
|
|
m_showWholeBracketExpressionSet (false),
|
|
m_backgroundColorSet (false),
|
|
m_selectionColorSet (false),
|
|
m_highlightedLineColorSet (false),
|
|
m_highlightedBracketColorSet (false),
|
|
m_wordWrapMarkerColorSet (false),
|
|
m_tabMarkerColorSet (false),
|
|
m_indentationLineColorSet (false),
|
|
m_iconBarColorSet (false),
|
|
m_foldingColorSet (false),
|
|
m_lineNumberColorSet (false),
|
|
m_separatorColorSet (false),
|
|
m_spellingMistakeLineColorSet (false),
|
|
m_modifiedLineColorSet (false),
|
|
m_savedLineColorSet (false),
|
|
m_searchHighlightColorSet (false),
|
|
m_replaceHighlightColorSet (false),
|
|
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
|
|
KConfigGroup config(KGlobal::config(), "Kate Renderer Defaults");
|
|
readConfig (config);
|
|
}
|
|
|
|
KateRendererConfig::KateRendererConfig (KateRenderer *renderer)
|
|
: m_fontMetrics(QFont()),
|
|
m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
|
|
m_schemaSet (false),
|
|
m_fontSet (false),
|
|
m_wordWrapMarkerSet (false),
|
|
m_showIndentationLinesSet (false),
|
|
m_showWholeBracketExpressionSet (false),
|
|
m_backgroundColorSet (false),
|
|
m_selectionColorSet (false),
|
|
m_highlightedLineColorSet (false),
|
|
m_highlightedBracketColorSet (false),
|
|
m_wordWrapMarkerColorSet (false),
|
|
m_tabMarkerColorSet (false),
|
|
m_indentationLineColorSet (false),
|
|
m_iconBarColorSet (false),
|
|
m_foldingColorSet (false),
|
|
m_lineNumberColorSet (false),
|
|
m_separatorColorSet (false),
|
|
m_spellingMistakeLineColorSet (false),
|
|
m_modifiedLineColorSet(false),
|
|
m_savedLineColorSet(false),
|
|
m_searchHighlightColorSet(false),
|
|
m_replaceHighlightColorSet(false),
|
|
m_lineMarkerColorSet (m_lineMarkerColor.size()),
|
|
m_renderer (renderer)
|
|
{
|
|
// init bitarray
|
|
m_lineMarkerColorSet.fill (false);
|
|
}
|
|
|
|
KateRendererConfig::~KateRendererConfig ()
|
|
{
|
|
}
|
|
|
|
namespace
|
|
{
|
|
const char * const KEY_SCHEMA = "Schema";
|
|
const char * const KEY_WORD_WRAP_MARKER = "Word Wrap Marker";
|
|
const char * const KEY_SHOW_INDENTATION_LINES = "Show Indentation Lines";
|
|
const char * const KEY_SHOW_WHOLE_BRACKET_EXPRESSION = "Show Whole Bracket Expression";
|
|
const char * const KEY_ANIMATE_BRACKET_MATCHING = "Animate Bracket Matching";
|
|
}
|
|
|
|
void KateRendererConfig::readConfig (const KConfigGroup &config)
|
|
{
|
|
configStart ();
|
|
|
|
// "Normal" Schema MUST BE THERE, see global kateschemarc
|
|
setSchema (config.readEntry(KEY_SCHEMA, "Normal"));
|
|
|
|
setWordWrapMarker (config.readEntry(KEY_WORD_WRAP_MARKER, false ));
|
|
|
|
setShowIndentationLines (config.readEntry( KEY_SHOW_INDENTATION_LINES, false));
|
|
|
|
setShowWholeBracketExpression (config.readEntry( KEY_SHOW_WHOLE_BRACKET_EXPRESSION, false));
|
|
|
|
setAnimateBracketMatching(config.readEntry(KEY_ANIMATE_BRACKET_MATCHING, false));
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
void KateRendererConfig::writeConfig (KConfigGroup& config)
|
|
{
|
|
config.writeEntry (KEY_SCHEMA, schema());
|
|
|
|
config.writeEntry(KEY_WORD_WRAP_MARKER, wordWrapMarker() );
|
|
|
|
config.writeEntry(KEY_SHOW_INDENTATION_LINES, showIndentationLines());
|
|
|
|
config.writeEntry(KEY_SHOW_WHOLE_BRACKET_EXPRESSION, showWholeBracketExpression());
|
|
|
|
config.writeEntry(KEY_ANIMATE_BRACKET_MATCHING, animateBracketMatching());
|
|
}
|
|
|
|
void KateRendererConfig::updateConfig ()
|
|
{
|
|
if (m_renderer)
|
|
{
|
|
m_renderer->updateConfig ();
|
|
return;
|
|
}
|
|
|
|
if (isGlobal())
|
|
{
|
|
for (int z=0; z < KateGlobal::self()->views().size(); ++z)
|
|
(KateGlobal::self()->views())[z]->renderer()->updateConfig ();
|
|
}
|
|
}
|
|
|
|
const QString &KateRendererConfig::schema () const
|
|
{
|
|
if (m_schemaSet || isGlobal())
|
|
return m_schema;
|
|
|
|
return s_global->schema();
|
|
}
|
|
|
|
void KateRendererConfig::setSchema (const QString &schema)
|
|
{
|
|
if (m_schemaSet && m_schema == schema)
|
|
return;
|
|
|
|
configStart ();
|
|
m_schemaSet = true;
|
|
m_schema = schema;
|
|
setSchemaInternal( schema );
|
|
configEnd ();
|
|
}
|
|
|
|
void KateRendererConfig::reloadSchema()
|
|
{
|
|
if ( isGlobal() ) {
|
|
setSchemaInternal( m_schema );
|
|
foreach (KateView* view, KateGlobal::self()->views() )
|
|
view->renderer()->config()->reloadSchema();
|
|
}
|
|
|
|
else if ( m_renderer && m_schemaSet )
|
|
setSchemaInternal( m_schema );
|
|
}
|
|
|
|
void KateRendererConfig::setSchemaInternal( const QString &schema )
|
|
{
|
|
m_schemaSet = true;
|
|
m_schema = schema;
|
|
|
|
KConfigGroup config = KateGlobal::self()->schemaManager()->schema(schema);
|
|
|
|
KateDefaultColors colors;
|
|
|
|
m_backgroundColor = config.readEntry("Color Background", colors.color(Kate::Background));
|
|
m_backgroundColorSet = true;
|
|
m_selectionColor = config.readEntry("Color Selection", colors.color(Kate::SelectionBackground));
|
|
m_selectionColorSet = true;
|
|
m_highlightedLineColor = config.readEntry("Color Highlighted Line", colors.color(Kate::HighlightedLineBackground));
|
|
m_highlightedLineColorSet = true;
|
|
m_highlightedBracketColor = config.readEntry("Color Highlighted Bracket", colors.color(Kate::HighlightedBracket));
|
|
m_highlightedBracketColorSet = true;
|
|
m_wordWrapMarkerColor = config.readEntry("Color Word Wrap Marker", colors.color(Kate::WordWrapMarker));
|
|
m_wordWrapMarkerColorSet = true;
|
|
m_tabMarkerColor = config.readEntry("Color Tab Marker", colors.color(Kate::TabMarker));
|
|
m_tabMarkerColorSet = true;
|
|
m_indentationLineColor = config.readEntry("Color Indentation Line", colors.color(Kate::IndentationLine));
|
|
m_indentationLineColorSet = true;
|
|
m_iconBarColor = config.readEntry("Color Icon Bar", colors.color(Kate::IconBar));
|
|
m_iconBarColorSet = true;
|
|
m_foldingColor = config.readEntry("Color Code Folding", colors.color(Kate::CodeFolding));
|
|
m_foldingColorSet = true;
|
|
m_lineNumberColor = config.readEntry("Color Line Number", colors.color(Kate::LineNumber));
|
|
m_lineNumberColorSet = true;
|
|
m_separatorColor = config.readEntry("Color Separator", colors.color(Kate::Separator));
|
|
m_separatorColorSet = true;
|
|
m_spellingMistakeLineColor = config.readEntry("Color Spelling Mistake Line", colors.color(Kate::SpellingMistakeLine));
|
|
m_spellingMistakeLineColorSet = true;
|
|
|
|
m_modifiedLineColor = config.readEntry("Color Modified Lines", colors.color(Kate::ModifiedLine));
|
|
m_modifiedLineColorSet = true;
|
|
m_savedLineColor = config.readEntry("Color Saved Lines", colors.color(Kate::SavedLine));
|
|
m_savedLineColorSet = true;
|
|
m_searchHighlightColor = config.readEntry("Color Search Highlight", colors.color(Kate::SearchHighlight));
|
|
m_searchHighlightColorSet = true;
|
|
m_replaceHighlightColor = config.readEntry("Color Replace Highlight", colors.color(Kate::ReplaceHighlight));
|
|
m_replaceHighlightColorSet = true;
|
|
|
|
for (int i = Kate::FIRST_MARK; i <= Kate::LAST_MARK; i++) {
|
|
QColor col = config.readEntry(QString("Color MarkType %1").arg(i + 1), colors.mark(i));
|
|
m_lineMarkerColorSet[i] = true;
|
|
m_lineMarkerColor[i] = col;
|
|
}
|
|
|
|
QFont f (KGlobalSettings::fixedFont());
|
|
|
|
m_font = config.readEntry("Font", f);
|
|
m_fontMetrics = QFontMetricsF (m_font);
|
|
m_fontSet = true;
|
|
}
|
|
|
|
const QFont& KateRendererConfig::font() const
|
|
{
|
|
if (m_fontSet || isGlobal())
|
|
return m_font;
|
|
|
|
return s_global->font();
|
|
}
|
|
|
|
const QFontMetricsF& KateRendererConfig::fontMetrics() const
|
|
{
|
|
if (m_fontSet || isGlobal())
|
|
return m_fontMetrics;
|
|
|
|
return s_global->fontMetrics();
|
|
}
|
|
|
|
void KateRendererConfig::setFont(const QFont &font)
|
|
{
|
|
if (m_fontSet && m_font == font)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_fontSet = true;
|
|
m_font = font;
|
|
m_fontMetrics = QFontMetricsF (m_font);
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateRendererConfig::wordWrapMarker () const
|
|
{
|
|
if (m_wordWrapMarkerSet || isGlobal())
|
|
return m_wordWrapMarker;
|
|
|
|
return s_global->wordWrapMarker();
|
|
}
|
|
|
|
void KateRendererConfig::setWordWrapMarker (bool on)
|
|
{
|
|
if (m_wordWrapMarkerSet && m_wordWrapMarker == on)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_backgroundColorSet && m_backgroundColor == col)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_selectionColorSet && m_selectionColor == col)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_highlightedLineColorSet && m_highlightedLineColor == col)
|
|
return;
|
|
|
|
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() );
|
|
|
|
if (m_lineMarkerColorSet[index] && m_lineMarkerColor[index] == col)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_highlightedBracketColorSet && m_highlightedBracketColor == col)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_wordWrapMarkerColorSet && m_wordWrapMarkerColor == col)
|
|
return;
|
|
|
|
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)
|
|
{
|
|
if (m_tabMarkerColorSet && m_tabMarkerColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_tabMarkerColorSet = true;
|
|
m_tabMarkerColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::indentationLineColor() const
|
|
{
|
|
if (m_indentationLineColorSet || isGlobal())
|
|
return m_indentationLineColor;
|
|
|
|
return s_global->indentationLineColor();
|
|
}
|
|
|
|
void KateRendererConfig::setIndentationLineColor (const QColor &col)
|
|
{
|
|
if (m_indentationLineColorSet && m_indentationLineColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_indentationLineColorSet = true;
|
|
m_indentationLineColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::iconBarColor() const
|
|
{
|
|
if (m_iconBarColorSet || isGlobal())
|
|
return m_iconBarColor;
|
|
|
|
return s_global->iconBarColor();
|
|
}
|
|
|
|
void KateRendererConfig::setIconBarColor (const QColor &col)
|
|
{
|
|
if (m_iconBarColorSet && m_iconBarColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_iconBarColorSet = true;
|
|
m_iconBarColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::foldingColor() const
|
|
{
|
|
if (m_foldingColorSet || isGlobal())
|
|
return m_foldingColor;
|
|
|
|
return s_global->foldingColor();
|
|
}
|
|
|
|
void KateRendererConfig::setFoldingColor (const QColor &col)
|
|
{
|
|
if (m_foldingColorSet && m_foldingColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_foldingColorSet = true;
|
|
m_foldingColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::lineNumberColor() const
|
|
{
|
|
if (m_lineNumberColorSet || isGlobal())
|
|
return m_lineNumberColor;
|
|
|
|
return s_global->lineNumberColor();
|
|
}
|
|
|
|
void KateRendererConfig::setLineNumberColor (const QColor &col)
|
|
{
|
|
if (m_lineNumberColorSet && m_lineNumberColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_lineNumberColorSet = true;
|
|
m_lineNumberColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::separatorColor() const
|
|
{
|
|
if (m_separatorColorSet || isGlobal())
|
|
return m_separatorColor;
|
|
|
|
return s_global->separatorColor();
|
|
}
|
|
|
|
void KateRendererConfig::setSeparatorColor(const QColor& col)
|
|
{
|
|
if (m_separatorColorSet && m_separatorColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_separatorColorSet = true;
|
|
m_separatorColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::spellingMistakeLineColor() const
|
|
{
|
|
if (m_spellingMistakeLineColorSet || isGlobal())
|
|
return m_spellingMistakeLineColor;
|
|
|
|
return s_global->spellingMistakeLineColor();
|
|
}
|
|
|
|
void KateRendererConfig::setSpellingMistakeLineColor (const QColor &col)
|
|
{
|
|
if (m_spellingMistakeLineColorSet && m_spellingMistakeLineColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_spellingMistakeLineColorSet = true;
|
|
m_spellingMistakeLineColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::modifiedLineColor() const
|
|
{
|
|
if (m_modifiedLineColorSet || isGlobal())
|
|
return m_modifiedLineColor;
|
|
|
|
return s_global->modifiedLineColor();
|
|
}
|
|
|
|
void KateRendererConfig::setModifiedLineColor(const QColor &col)
|
|
{
|
|
if (m_modifiedLineColorSet && m_modifiedLineColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_modifiedLineColorSet = true;
|
|
m_modifiedLineColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::savedLineColor() const
|
|
{
|
|
if (m_savedLineColorSet || isGlobal())
|
|
return m_savedLineColor;
|
|
|
|
return s_global->savedLineColor();
|
|
}
|
|
|
|
void KateRendererConfig::setSavedLineColor(const QColor &col)
|
|
{
|
|
if (m_savedLineColorSet && m_savedLineColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_savedLineColorSet = true;
|
|
m_savedLineColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::searchHighlightColor() const
|
|
{
|
|
if (m_searchHighlightColorSet || isGlobal())
|
|
return m_searchHighlightColor;
|
|
|
|
return s_global->searchHighlightColor();
|
|
}
|
|
|
|
void KateRendererConfig::setSearchHighlightColor(const QColor &col)
|
|
{
|
|
if (m_searchHighlightColorSet && m_searchHighlightColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_searchHighlightColorSet = true;
|
|
m_searchHighlightColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
const QColor& KateRendererConfig::replaceHighlightColor() const
|
|
{
|
|
if (m_replaceHighlightColorSet || isGlobal())
|
|
return m_replaceHighlightColor;
|
|
|
|
return s_global->replaceHighlightColor();
|
|
}
|
|
|
|
void KateRendererConfig::setReplaceHighlightColor(const QColor &col)
|
|
{
|
|
if (m_replaceHighlightColorSet && m_replaceHighlightColor == col)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_replaceHighlightColorSet = true;
|
|
m_replaceHighlightColor = col;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
|
|
bool KateRendererConfig::showIndentationLines () const
|
|
{
|
|
if (m_showIndentationLinesSet || isGlobal())
|
|
return m_showIndentationLines;
|
|
|
|
return s_global->showIndentationLines();
|
|
}
|
|
|
|
void KateRendererConfig::setShowIndentationLines (bool on)
|
|
{
|
|
if (m_showIndentationLinesSet && m_showIndentationLines == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_showIndentationLinesSet = true;
|
|
m_showIndentationLines = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateRendererConfig::showWholeBracketExpression () const
|
|
{
|
|
if (m_showWholeBracketExpressionSet || isGlobal())
|
|
return m_showWholeBracketExpression;
|
|
|
|
return s_global->showWholeBracketExpression();
|
|
}
|
|
|
|
void KateRendererConfig::setShowWholeBracketExpression (bool on)
|
|
{
|
|
if (m_showWholeBracketExpressionSet && m_showWholeBracketExpression == on)
|
|
return;
|
|
|
|
configStart ();
|
|
|
|
m_showWholeBracketExpressionSet = true;
|
|
m_showWholeBracketExpression = on;
|
|
|
|
configEnd ();
|
|
}
|
|
|
|
bool KateRendererConfig::animateBracketMatching () const
|
|
{
|
|
return s_global->m_animateBracketMatching;
|
|
}
|
|
|
|
void KateRendererConfig::setAnimateBracketMatching (bool on)
|
|
{
|
|
if (!isGlobal()) {
|
|
s_global->setAnimateBracketMatching (on);
|
|
} else if (on != m_animateBracketMatching) {
|
|
configStart ();
|
|
m_animateBracketMatching = on;
|
|
configEnd ();
|
|
}
|
|
}
|
|
|
|
//END
|
|
|
|
// kate: space-indent on; indent-width 2; replace-tabs on;
|