00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "kateconfig.h"
00020
00021 #include "katefactory.h"
00022 #include "katerenderer.h"
00023 #include "kateview.h"
00024 #include "katedocument.h"
00025 #include "katefont.h"
00026 #include "kateschema.h"
00027
00028 #include <math.h>
00029
00030 #include <kapplication.h>
00031 #include <kconfig.h>
00032 #include <kglobalsettings.h>
00033 #include <kcharsets.h>
00034 #include <klocale.h>
00035 #include <kfinddialog.h>
00036 #include <kreplacedialog.h>
00037 #include <kinstance.h>
00038 #include <kstaticdeleter.h>
00039
00040 #include <qpopupmenu.h>
00041 #include <qtextcodec.h>
00042
00043 #include <kdebug.h>
00044
00045
00046 KateConfig::KateConfig ()
00047 : configSessionNumber (0), configIsRunning (false)
00048 {
00049 }
00050
00051 KateConfig::~KateConfig ()
00052 {
00053 }
00054
00055 void KateConfig::configStart ()
00056 {
00057 configSessionNumber++;
00058
00059 if (configSessionNumber > 1)
00060 return;
00061
00062 configIsRunning = true;
00063 }
00064
00065 void KateConfig::configEnd ()
00066 {
00067 if (configSessionNumber == 0)
00068 return;
00069
00070 configSessionNumber--;
00071
00072 if (configSessionNumber > 0)
00073 return;
00074
00075 configIsRunning = false;
00076
00077 updateConfig ();
00078 }
00079
00080
00081
00082 KateDocumentConfig *KateDocumentConfig::s_global = 0;
00083 KateViewConfig *KateViewConfig::s_global = 0;
00084 KateRendererConfig *KateRendererConfig::s_global = 0;
00085
00086 KateDocumentConfig::KateDocumentConfig ()
00087 : m_tabWidth (8),
00088 m_indentationWidth (2),
00089 m_wordWrapAt (80),
00090 m_configFlags (0),
00091 m_plugins (KateFactory::self()->plugins().count()),
00092 m_tabWidthSet (true),
00093 m_indentationWidthSet (true),
00094 m_indentationModeSet (true),
00095 m_wordWrapSet (true),
00096 m_wordWrapAtSet (true),
00097 m_pageUpDownMovesCursorSet (true),
00098 m_undoStepsSet (true),
00099 m_configFlagsSet (0xFFFF),
00100 m_encodingSet (true),
00101 m_eolSet (true),
00102 m_backupFlagsSet (true),
00103 m_searchDirConfigDepthSet (true),
00104 m_backupPrefixSet (true),
00105 m_backupSuffixSet (true),
00106 m_pluginsSet (m_plugins.size()),
00107 m_doc (0)
00108 {
00109 s_global = this;
00110
00111
00112 m_plugins.fill (false);
00113 m_pluginsSet.fill (true);
00114
00115
00116 KConfig *config = kapp->config();
00117 config->setGroup("Kate Document Defaults");
00118 readConfig (config);
00119 }
00120
00121 KateDocumentConfig::KateDocumentConfig (KateDocument *doc)
00122 : m_configFlags (0),
00123 m_plugins (KateFactory::self()->plugins().count()),
00124 m_tabWidthSet (false),
00125 m_indentationWidthSet (false),
00126 m_indentationModeSet (false),
00127 m_wordWrapSet (false),
00128 m_wordWrapAtSet (false),
00129 m_pageUpDownMovesCursorSet (false),
00130 m_undoStepsSet (false),
00131 m_configFlagsSet (0),
00132 m_encodingSet (false),
00133 m_eolSet (false),
00134 m_backupFlagsSet (false),
00135 m_searchDirConfigDepthSet (false),
00136 m_backupPrefixSet (false),
00137 m_backupSuffixSet (false),
00138 m_pluginsSet (m_plugins.size()),
00139 m_doc (doc)
00140 {
00141
00142 m_plugins.fill (false);
00143 m_pluginsSet.fill (false);
00144 }
00145
00146 KateDocumentConfig::~KateDocumentConfig ()
00147 {
00148 }
00149
00150 void KateDocumentConfig::readConfig (KConfig *config)
00151 {
00152 configStart ();
00153
00154 setTabWidth (config->readNumEntry("Tab Width", 8));
00155
00156 setIndentationWidth (config->readNumEntry("Indentation Width", 2));
00157
00158 setIndentationMode (config->readNumEntry("Indentation Mode", KateDocumentConfig::imNone));
00159
00160 setWordWrap (config->readBoolEntry("Word Wrap", false));
00161 setWordWrapAt (config->readNumEntry("Word Wrap Column", 80));
00162 setPageUpDownMovesCursor (config->readNumEntry("PageUp/PageDown Moves Cursor", false));
00163 setUndoSteps(config->readNumEntry("Undo Steps", 0));
00164
00165 setConfigFlags (config->readNumEntry("Basic Config Flags", KateDocumentConfig::cfTabIndents
00166 | KateDocumentConfig::cfKeepIndentProfile
00167 | KateDocumentConfig::cfWrapCursor
00168 | KateDocumentConfig::cfShowTabs
00169 | KateDocumentConfig::cfSmartHome));
00170
00171 setEncoding (config->readEntry("Encoding", ""));
00172
00173 setEol (config->readNumEntry("End of Line", 0));
00174
00175 setBackupFlags (config->readNumEntry("Backup Config Flags", 1));
00176
00177 setSearchDirConfigDepth (config->readNumEntry("Search Dir Config Depth", -1));
00178
00179 setBackupPrefix (config->readEntry("Backup Prefix", QString ("")));
00180
00181 setBackupSuffix (config->readEntry("Backup Suffix", QString ("~")));
00182
00183
00184 for (uint i=0; i<KateFactory::self()->plugins().count(); i++)
00185 setPlugin (i, config->readBoolEntry("KTextEditor Plugin " + (KateFactory::self()->plugins())[i]->library(), false));
00186
00187 configEnd ();
00188 }
00189
00190 void KateDocumentConfig::writeConfig (KConfig *config)
00191 {
00192 config->writeEntry("Tab Width", tabWidth());
00193
00194 config->writeEntry("Indentation Width", indentationWidth());
00195 config->writeEntry("Indentation Mode", indentationMode());
00196
00197 config->writeEntry("Word Wrap", wordWrap());
00198 config->writeEntry("Word Wrap Column", wordWrapAt());
00199
00200 config->writeEntry("PageUp/PageDown Moves Cursor", pageUpDownMovesCursor());
00201
00202 config->writeEntry("Undo Steps", undoSteps());
00203
00204 config->writeEntry("Basic Config Flags", configFlags());
00205
00206 config->writeEntry("Encoding", encoding());
00207
00208 config->writeEntry("End of Line", eol());
00209
00210 config->writeEntry("Backup Config Flags", backupFlags());
00211
00212 config->writeEntry("Search Dir Config Depth", searchDirConfigDepth());
00213
00214 config->writeEntry("Backup Prefix", backupPrefix());
00215
00216 config->writeEntry("Backup Suffix", backupSuffix());
00217
00218
00219 for (uint i=0; i<KateFactory::self()->plugins().count(); i++)
00220 config->writeEntry("KTextEditor Plugin " + (KateFactory::self()->plugins())[i]->library(), plugin(i));
00221 }
00222
00223 void KateDocumentConfig::updateConfig ()
00224 {
00225 if (m_doc)
00226 {
00227 m_doc->updateConfig ();
00228 return;
00229 }
00230
00231 if (isGlobal())
00232 {
00233 for (uint z=0; z < KateFactory::self()->documents()->count(); z++)
00234 {
00235 KateFactory::self()->documents()->at(z)->updateConfig ();
00236 }
00237 }
00238 }
00239
00240 int KateDocumentConfig::tabWidth () const
00241 {
00242 if (m_tabWidthSet || isGlobal())
00243 return m_tabWidth;
00244
00245 return s_global->tabWidth();
00246 }
00247
00248 void KateDocumentConfig::setTabWidth (int tabWidth)
00249 {
00250 if (tabWidth < 1)
00251 return;
00252
00253 configStart ();
00254
00255 m_tabWidthSet = true;
00256 m_tabWidth = tabWidth;
00257
00258 configEnd ();
00259 }
00260
00261 int KateDocumentConfig::indentationWidth () const
00262 {
00263 if (m_indentationWidthSet || isGlobal())
00264 return m_indentationWidth;
00265
00266 return s_global->indentationWidth();
00267 }
00268
00269 void KateDocumentConfig::setIndentationWidth (int indentationWidth)
00270 {
00271 if (indentationWidth < 1)
00272 return;
00273
00274 configStart ();
00275
00276 m_indentationWidthSet = true;
00277 m_indentationWidth = indentationWidth;
00278
00279 configEnd ();
00280 }
00281
00282 uint KateDocumentConfig::indentationMode () const
00283 {
00284 if (m_indentationModeSet || isGlobal())
00285 return m_indentationMode;
00286
00287 return s_global->indentationMode();
00288 }
00289
00290 void KateDocumentConfig::setIndentationMode (uint indentationMode)
00291 {
00292 configStart ();
00293
00294 m_indentationModeSet = true;
00295 m_indentationMode = indentationMode;
00296
00297 configEnd ();
00298 }
00299
00300 bool KateDocumentConfig::wordWrap () const
00301 {
00302 if (m_wordWrapSet || isGlobal())
00303 return m_wordWrap;
00304
00305 return s_global->wordWrap();
00306 }
00307
00308 void KateDocumentConfig::setWordWrap (bool on)
00309 {
00310 configStart ();
00311
00312 m_wordWrapSet = true;
00313 m_wordWrap = on;
00314
00315 configEnd ();
00316 }
00317
00318 unsigned int KateDocumentConfig::wordWrapAt () const
00319 {
00320 if (m_wordWrapAtSet || isGlobal())
00321 return m_wordWrapAt;
00322
00323 return s_global->wordWrapAt();
00324 }
00325
00326 void KateDocumentConfig::setWordWrapAt (unsigned int col)
00327 {
00328 if (col < 1)
00329 return;
00330
00331 configStart ();
00332
00333 m_wordWrapAtSet = true;
00334 m_wordWrapAt = col;
00335
00336 configEnd ();
00337 }
00338
00339 uint KateDocumentConfig::undoSteps () const
00340 {
00341 if (m_undoStepsSet || isGlobal())
00342 return m_undoSteps;
00343
00344 return s_global->undoSteps();
00345 }
00346
00347 void KateDocumentConfig::setUndoSteps (uint undoSteps)
00348 {
00349 configStart ();
00350
00351 m_undoStepsSet = true;
00352 m_undoSteps = undoSteps;
00353
00354 configEnd ();
00355 }
00356
00357 bool KateDocumentConfig::pageUpDownMovesCursor () const
00358 {
00359 if (m_pageUpDownMovesCursorSet || isGlobal())
00360 return m_pageUpDownMovesCursor;
00361
00362 return s_global->pageUpDownMovesCursor();
00363 }
00364
00365 void KateDocumentConfig::setPageUpDownMovesCursor (bool on)
00366 {
00367 configStart ();
00368
00369 m_pageUpDownMovesCursorSet = true;
00370 m_pageUpDownMovesCursor = on;
00371
00372 configEnd ();
00373 }
00374
00375 uint KateDocumentConfig::configFlags () const
00376 {
00377 if (isGlobal())
00378 return m_configFlags;
00379
00380 return ((s_global->configFlags() & ~ m_configFlagsSet) | m_configFlags);
00381 }
00382
00383 void KateDocumentConfig::setConfigFlags (KateDocumentConfig::ConfigFlags flag, bool enable)
00384 {
00385 configStart ();
00386
00387 m_configFlagsSet |= flag;
00388
00389 if (enable)
00390 m_configFlags = m_configFlags | flag;
00391 else
00392 m_configFlags = m_configFlags & ~ flag;
00393
00394 configEnd ();
00395 }
00396
00397 void KateDocumentConfig::setConfigFlags (uint fullFlags)
00398 {
00399 configStart ();
00400
00401 m_configFlagsSet = 0xFFFF;
00402 m_configFlags = fullFlags;
00403
00404 configEnd ();
00405 }
00406
00407 const QString &KateDocumentConfig::encoding () const
00408 {
00409 if (m_encodingSet || isGlobal())
00410 return m_encoding;
00411
00412 return s_global->encoding();
00413 }
00414
00415 QTextCodec *KateDocumentConfig::codec ()
00416 {
00417 if (m_encodingSet || isGlobal())
00418 {
00419 if (m_encoding.isEmpty() && isGlobal())
00420 return KGlobal::charsets()->codecForName (QString::fromLatin1(KGlobal::locale()->encoding()));
00421 else if (m_encoding.isEmpty())
00422 return s_global->codec ();
00423 else
00424 return KGlobal::charsets()->codecForName (m_encoding);
00425 }
00426
00427 return s_global->codec ();
00428 }
00429
00430 void KateDocumentConfig::setEncoding (const QString &encoding)
00431 {
00432 QString enc = encoding;
00433
00434 if (!enc.isEmpty())
00435 {
00436 bool found = false;
00437 QTextCodec *codec = KGlobal::charsets()->codecForName (encoding, found);
00438
00439 if (!found || !codec)
00440 return;
00441
00442 enc = codec->name();
00443 }
00444
00445 configStart ();
00446
00447 if (isGlobal())
00448 KateDocument::setDefaultEncoding (enc);
00449
00450 m_encodingSet = true;
00451 m_encoding = enc;
00452
00453 configEnd ();
00454 }
00455
00456 bool KateDocumentConfig::isSetEncoding () const
00457 {
00458 return m_encodingSet;
00459 }
00460
00461 int KateDocumentConfig::eol () const
00462 {
00463 if (m_eolSet || isGlobal())
00464 return m_eol;
00465
00466 return s_global->eol();
00467 }
00468
00469 QString KateDocumentConfig::eolString ()
00470 {
00471 if (eol() == KateDocumentConfig::eolUnix)
00472 return QString ("\n");
00473 else if (eol() == KateDocumentConfig::eolDos)
00474 return QString ("\r\n");
00475 else if (eol() == KateDocumentConfig::eolMac)
00476 return QString ("\r");
00477
00478 return QString ("\n");
00479 }
00480
00481 void KateDocumentConfig::setEol (int mode)
00482 {
00483 configStart ();
00484
00485 m_eolSet = true;
00486 m_eol = mode;
00487
00488 configEnd ();
00489 }
00490
00491 uint KateDocumentConfig::backupFlags () const
00492 {
00493 if (m_backupFlagsSet || isGlobal())
00494 return m_backupFlags;
00495
00496 return s_global->backupFlags();
00497 }
00498
00499 void KateDocumentConfig::setBackupFlags (uint flags)
00500 {
00501 configStart ();
00502
00503 m_backupFlagsSet = true;
00504 m_backupFlags = flags;
00505
00506 configEnd ();
00507 }
00508
00509 const QString &KateDocumentConfig::backupPrefix () const
00510 {
00511 if (m_backupPrefixSet || isGlobal())
00512 return m_backupPrefix;
00513
00514 return s_global->backupPrefix();
00515 }
00516
00517 const QString &KateDocumentConfig::backupSuffix () const
00518 {
00519 if (m_backupSuffixSet || isGlobal())
00520 return m_backupSuffix;
00521
00522 return s_global->backupSuffix();
00523 }
00524
00525 void KateDocumentConfig::setBackupPrefix (const QString &prefix)
00526 {
00527 configStart ();
00528
00529 m_backupPrefixSet = true;
00530 m_backupPrefix = prefix;
00531
00532 configEnd ();
00533 }
00534
00535 void KateDocumentConfig::setBackupSuffix (const QString &suffix)
00536 {
00537 configStart ();
00538
00539 m_backupSuffixSet = true;
00540 m_backupSuffix = suffix;
00541
00542 configEnd ();
00543 }
00544
00545 bool KateDocumentConfig::plugin (uint index) const
00546 {
00547 if (index >= m_plugins.size())
00548 return false;
00549
00550 if (m_pluginsSet.at(index) || isGlobal())
00551 return m_plugins.at(index);
00552
00553 return s_global->plugin (index);
00554 }
00555
00556 void KateDocumentConfig::setPlugin (uint index, bool load)
00557 {
00558 if (index >= m_plugins.size())
00559 return;
00560
00561 configStart ();
00562
00563 m_pluginsSet.setBit(index);
00564 m_plugins.setBit(index, load);
00565
00566 configEnd ();
00567 }
00568
00569 int KateDocumentConfig::searchDirConfigDepth () const
00570 {
00571 if (m_searchDirConfigDepthSet || isGlobal())
00572 return m_searchDirConfigDepth;
00573
00574 return s_global->searchDirConfigDepth ();
00575 }
00576
00577 void KateDocumentConfig::setSearchDirConfigDepth (int depth)
00578 {
00579 configStart ();
00580
00581 m_searchDirConfigDepthSet = true;
00582 m_searchDirConfigDepth = depth;
00583
00584 configEnd ();
00585 }
00586
00587
00588
00589
00590 KateViewConfig::KateViewConfig ()
00591 :
00592 m_dynWordWrapSet (true),
00593 m_dynWordWrapIndicatorsSet (true),
00594 m_dynWordWrapAlignIndentSet (true),
00595 m_lineNumbersSet (true),
00596 m_scrollBarMarksSet (true),
00597 m_iconBarSet (true),
00598 m_foldingBarSet (true),
00599 m_bookmarkSortSet (true),
00600 m_autoCenterLinesSet (true),
00601 m_searchFlagsSet (true),
00602 m_cmdLineSet (true),
00603 m_defaultMarkTypeSet (true),
00604 m_textToSearchModeSet (true),
00605 m_view (0)
00606 {
00607 s_global = this;
00608
00609
00610 KConfig *config = kapp->config();
00611 config->setGroup("Kate View Defaults");
00612 readConfig (config);
00613 }
00614
00615 KateViewConfig::KateViewConfig (KateView *view)
00616 :
00617 m_dynWordWrapSet (false),
00618 m_dynWordWrapIndicatorsSet (false),
00619 m_dynWordWrapAlignIndentSet (false),
00620 m_lineNumbersSet (false),
00621 m_scrollBarMarksSet (false),
00622 m_iconBarSet (false),
00623 m_foldingBarSet (false),
00624 m_bookmarkSortSet (false),
00625 m_autoCenterLinesSet (false),
00626 m_searchFlagsSet (false),
00627 m_cmdLineSet (false),
00628 m_defaultMarkTypeSet (false),
00629 m_textToSearchModeSet (false),
00630 m_view (view)
00631 {
00632 }
00633
00634 KateViewConfig::~KateViewConfig ()
00635 {
00636 }
00637
00638 void KateViewConfig::readConfig (KConfig *config)
00639 {
00640 configStart ();
00641
00642 setDynWordWrap (config->readBoolEntry( "Dynamic Word Wrap", true ));
00643 setDynWordWrapIndicators (config->readNumEntry( "Dynamic Word Wrap Indicators", 1 ));
00644 setDynWordWrapAlignIndent (config->readNumEntry( "Dynamic Word Wrap Align Indent", 80 ));
00645
00646 setLineNumbers (config->readBoolEntry( "Line Numbers", false));
00647
00648 setScrollBarMarks (config->readBoolEntry( "Scroll Bar Marks", false));
00649
00650 setIconBar (config->readBoolEntry( "Icon Bar", false ));
00651
00652 setFoldingBar (config->readBoolEntry( "Folding Bar", true));
00653
00654 setBookmarkSort (config->readNumEntry( "Bookmark Menu Sorting", 0 ));
00655
00656 setAutoCenterLines (config->readNumEntry( "Auto Center Lines", 0 ));
00657
00658 setSearchFlags (config->readNumEntry("Search Config Flags", KFindDialog::FromCursor | KFindDialog::CaseSensitive | KReplaceDialog::PromptOnReplace));
00659
00660 setCmdLine (config->readBoolEntry( "Command Line", false));
00661
00662 setDefaultMarkType (config->readNumEntry( "Default Mark Type", KTextEditor::MarkInterface::markType01 ));
00663
00664 setTextToSearchMode (config->readNumEntry( "Text To Search Mode", KateViewConfig::SelectionWord));
00665
00666 configEnd ();
00667 }
00668
00669 void KateViewConfig::writeConfig (KConfig *config)
00670 {
00671 config->writeEntry( "Dynamic Word Wrap", dynWordWrap() );
00672 config->writeEntry( "Dynamic Word Wrap Indicators", dynWordWrapIndicators() );
00673 config->writeEntry( "Dynamic Word Wrap Align Indent", dynWordWrapAlignIndent() );
00674
00675 config->writeEntry( "Line Numbers", lineNumbers() );
00676
00677 config->writeEntry( "Scroll Bar Marks", scrollBarMarks() );
00678
00679 config->writeEntry( "Icon Bar", iconBar() );
00680
00681 config->writeEntry( "Folding Bar", foldingBar() );
00682
00683 config->writeEntry( "Bookmark Menu Sorting", bookmarkSort() );
00684
00685 config->writeEntry( "Auto Center Lines", autoCenterLines() );
00686
00687 config->writeEntry("Search Config Flags", searchFlags());
00688
00689 config->writeEntry("Command Line", cmdLine());
00690
00691 config->writeEntry("Default Mark Type", defaultMarkType());
00692
00693 config->writeEntry("Text To Search Mode", textToSearchMode());
00694 }
00695
00696 void KateViewConfig::updateConfig ()
00697 {
00698 if (m_view)
00699 {
00700 m_view->updateConfig ();
00701 return;
00702 }
00703
00704 if (isGlobal())
00705 {
00706 for (uint z=0; z < KateFactory::self()->views()->count(); z++)
00707 {
00708 KateFactory::self()->views()->at(z)->updateConfig ();
00709 }
00710 }
00711 }
00712
00713 bool KateViewConfig::dynWordWrap () const
00714 {
00715 if (m_dynWordWrapSet || isGlobal())
00716 return m_dynWordWrap;
00717
00718 return s_global->dynWordWrap();
00719 }
00720
00721 void KateViewConfig::setDynWordWrap (bool wrap)
00722 {
00723 configStart ();
00724
00725 m_dynWordWrapSet = true;
00726 m_dynWordWrap = wrap;
00727
00728 configEnd ();
00729 }
00730
00731 int KateViewConfig::dynWordWrapIndicators () const
00732 {
00733 if (m_dynWordWrapIndicatorsSet || isGlobal())
00734 return m_dynWordWrapIndicators;
00735
00736 return s_global->dynWordWrapIndicators();
00737 }
00738
00739 void KateViewConfig::setDynWordWrapIndicators (int mode)
00740 {
00741 configStart ();
00742
00743 m_dynWordWrapIndicatorsSet = true;
00744 m_dynWordWrapIndicators = QMIN(80, QMAX(0, mode));
00745
00746 configEnd ();
00747 }
00748
00749 int KateViewConfig::dynWordWrapAlignIndent () const
00750 {
00751 if (m_dynWordWrapAlignIndentSet || isGlobal())
00752 return m_dynWordWrapAlignIndent;
00753
00754 return s_global->dynWordWrapAlignIndent();
00755 }
00756
00757 void KateViewConfig::setDynWordWrapAlignIndent (int indent)
00758 {
00759 configStart ();
00760
00761 m_dynWordWrapAlignIndentSet = true;
00762 m_dynWordWrapAlignIndent = indent;
00763
00764 configEnd ();
00765 }
00766
00767 bool KateViewConfig::lineNumbers () const
00768 {
00769 if (m_lineNumbersSet || isGlobal())
00770 return m_lineNumbers;
00771
00772 return s_global->lineNumbers();
00773 }
00774
00775 void KateViewConfig::setLineNumbers (bool on)
00776 {
00777 configStart ();
00778
00779 m_lineNumbersSet = true;
00780 m_lineNumbers = on;
00781
00782 configEnd ();
00783 }
00784
00785 bool KateViewConfig::scrollBarMarks () const
00786 {
00787 if (m_scrollBarMarksSet || isGlobal())
00788 return m_scrollBarMarks;
00789
00790 return s_global->scrollBarMarks();
00791 }
00792
00793 void KateViewConfig::setScrollBarMarks (bool on)
00794 {
00795 configStart ();
00796
00797 m_scrollBarMarksSet = true;
00798 m_scrollBarMarks = on;
00799
00800 configEnd ();
00801 }
00802
00803 bool KateViewConfig::iconBar () const
00804 {
00805 if (m_iconBarSet || isGlobal())
00806 return m_iconBar;
00807
00808 return s_global->iconBar();
00809 }
00810
00811 void KateViewConfig::setIconBar (bool on)
00812 {
00813 configStart ();
00814
00815 m_iconBarSet = true;
00816 m_iconBar = on;
00817
00818 configEnd ();
00819 }
00820
00821 bool KateViewConfig::foldingBar () const
00822 {
00823 if (m_foldingBarSet || isGlobal())
00824 return m_foldingBar;
00825
00826 return s_global->foldingBar();
00827 }
00828
00829 void KateViewConfig::setFoldingBar (bool on)
00830 {
00831 configStart ();
00832
00833 m_foldingBarSet = true;
00834 m_foldingBar = on;
00835
00836 configEnd ();
00837 }
00838
00839 int KateViewConfig::bookmarkSort () const
00840 {
00841 if (m_bookmarkSortSet || isGlobal())
00842 return m_bookmarkSort;
00843
00844 return s_global->bookmarkSort();
00845 }
00846
00847 void KateViewConfig::setBookmarkSort (int mode)
00848 {
00849 configStart ();
00850
00851 m_bookmarkSortSet = true;
00852 m_bookmarkSort = mode;
00853
00854 configEnd ();
00855 }
00856
00857 int KateViewConfig::autoCenterLines () const
00858 {
00859 if (m_autoCenterLinesSet || isGlobal())
00860 return m_autoCenterLines;
00861
00862 return s_global->autoCenterLines();
00863 }
00864
00865 void KateViewConfig::setAutoCenterLines (int lines)
00866 {
00867 if (lines < 0)
00868 return;
00869
00870 configStart ();
00871
00872 m_autoCenterLinesSet = true;
00873 m_autoCenterLines = lines;
00874
00875 configEnd ();
00876 }
00877
00878 long KateViewConfig::searchFlags () const
00879 {
00880 if (m_searchFlagsSet || isGlobal())
00881 return m_searchFlags;
00882
00883 return s_global->searchFlags();
00884 }
00885
00886 void KateViewConfig::setSearchFlags (long flags)
00887 {
00888 configStart ();
00889
00890 m_searchFlagsSet = true;
00891 m_searchFlags = flags;
00892
00893 configEnd ();
00894 }
00895
00896 bool KateViewConfig::cmdLine () const
00897 {
00898 if (m_cmdLineSet || isGlobal())
00899 return m_cmdLine;
00900
00901 return s_global->cmdLine();
00902 }
00903
00904 void KateViewConfig::setCmdLine (bool on)
00905 {
00906 configStart ();
00907
00908 m_cmdLineSet = true;
00909 m_cmdLine = on;
00910
00911 configEnd ();
00912 }
00913
00914 uint KateViewConfig::defaultMarkType () const
00915 {
00916 if (m_defaultMarkTypeSet || isGlobal())
00917 return m_defaultMarkType;
00918
00919 return s_global->defaultMarkType();
00920 }
00921
00922 void KateViewConfig::setDefaultMarkType (uint type)
00923 {
00924 configStart ();
00925
00926 m_defaultMarkTypeSet = true;
00927 m_defaultMarkType = type;
00928
00929 configEnd ();
00930 }
00931
00932 int KateViewConfig::textToSearchMode () const
00933 {
00934 if (m_textToSearchModeSet || isGlobal())
00935 return m_textToSearchMode;
00936
00937 return s_global->textToSearchMode();
00938 }
00939
00940 void KateViewConfig::setTextToSearchMode (int mode)
00941 {
00942 configStart ();
00943
00944 m_textToSearchModeSet = true;
00945 m_textToSearchMode = mode;
00946
00947 configEnd ();
00948 }
00949
00950
00951
00952 KateRendererConfig::KateRendererConfig ()
00953 :
00954 m_font (new KateFontStruct ()),
00955 m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
00956 m_schemaSet (true),
00957 m_fontSet (true),
00958 m_wordWrapMarkerSet (true),
00959 m_backgroundColorSet (true),
00960 m_selectionColorSet (true),
00961 m_highlightedLineColorSet (true),
00962 m_highlightedBracketColorSet (true),
00963 m_wordWrapMarkerColorSet (true),
00964 m_tabMarkerColorSet(true),
00965 m_iconBarColorSet (true),
00966 m_lineNumberColorSet (true),
00967 m_lineMarkerColorSet (m_lineMarkerColor.size()),
00968 m_renderer (0)
00969 {
00970
00971 m_lineMarkerColorSet.fill (true);
00972
00973 s_global = this;
00974
00975
00976 KConfig *config = kapp->config();
00977 config->setGroup("Kate Renderer Defaults");
00978 readConfig (config);
00979 }
00980
00981 KateRendererConfig::KateRendererConfig (KateRenderer *renderer)
00982 : m_font (0),
00983 m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
00984 m_schemaSet (false),
00985 m_fontSet (false),
00986 m_wordWrapMarkerSet (false),
00987 m_backgroundColorSet (false),
00988 m_selectionColorSet (false),
00989 m_highlightedLineColorSet (false),
00990 m_highlightedBracketColorSet (false),
00991 m_wordWrapMarkerColorSet (false),
00992 m_tabMarkerColorSet(false),
00993 m_iconBarColorSet (false),
00994 m_lineNumberColorSet (false),
00995 m_lineMarkerColorSet (m_lineMarkerColor.size()),
00996 m_renderer (renderer)
00997 {
00998
00999 m_lineMarkerColorSet.fill (false);
01000 }
01001
01002 KateRendererConfig::~KateRendererConfig ()
01003 {
01004 delete m_font;
01005 }
01006
01007 void KateRendererConfig::readConfig (KConfig *config)
01008 {
01009 configStart ();
01010
01011 setSchema (KateFactory::self()->schemaManager()->number (config->readEntry("Schema", KateSchemaManager::normalSchema())));
01012
01013 setWordWrapMarker (config->readBoolEntry("Word Wrap Marker", false ));
01014
01015 configEnd ();
01016 }
01017
01018 void KateRendererConfig::writeConfig (KConfig *config)
01019 {
01020 config->writeEntry ("Schema", KateFactory::self()->schemaManager()->name(schema()));
01021
01022 config->writeEntry( "Word Wrap Marker", wordWrapMarker() );
01023 }
01024
01025 void KateRendererConfig::updateConfig ()
01026 {
01027 if (m_renderer)
01028 {
01029 m_renderer->updateConfig ();
01030 return;
01031 }
01032
01033 if (isGlobal())
01034 {
01035 for (uint z=0; z < KateFactory::self()->renderers()->count(); z++)
01036 {
01037 KateFactory::self()->renderers()->at(z)->updateConfig ();
01038 }
01039 }
01040 }
01041
01042 uint KateRendererConfig::schema () const
01043 {
01044 if (m_schemaSet || isGlobal())
01045 return m_schema;
01046
01047 return s_global->schema();
01048 }
01049
01050 void KateRendererConfig::setSchema (uint schema)
01051 {
01052 configStart ();
01053 m_schemaSet = true;
01054 m_schema = schema;
01055 setSchemaInternal( schema );
01056 configEnd ();
01057 }
01058
01059 void KateRendererConfig::reloadSchema()
01060 {
01061 if ( isGlobal() )
01062 for ( uint z=0; z < KateFactory::self()->renderers()->count(); z++ )
01063 KateFactory::self()->renderers()->at(z)->config()->reloadSchema();
01064
01065 else if ( m_renderer && m_schemaSet )
01066 setSchemaInternal( m_schema );
01067 }
01068
01069 void KateRendererConfig::setSchemaInternal( int schema )
01070 {
01071 m_schemaSet = true;
01072 m_schema = schema;
01073
01074 KConfig *config (KateFactory::self()->schemaManager()->schema(schema));
01075
01076 QColor tmp0 (KGlobalSettings::baseColor());
01077 QColor tmp1 (KGlobalSettings::highlightColor());
01078 QColor tmp2 (KGlobalSettings::alternateBackgroundColor());
01079 QColor tmp3 ( "#FFFF99" );
01080 QColor tmp4 (tmp2.dark());
01081 QColor tmp5 ( KGlobalSettings::textColor() );
01082 QColor tmp6 ( "#EAE9E8" );
01083 QColor tmp7 ( "#000000" );
01084
01085 m_backgroundColor = config->readColorEntry("Color Background", &tmp0);
01086 m_backgroundColorSet = true;
01087 m_selectionColor = config->readColorEntry("Color Selection", &tmp1);
01088 m_selectionColorSet = true;
01089 m_highlightedLineColor = config->readColorEntry("Color Highlighted Line", &tmp2);
01090 m_highlightedLineColorSet = true;
01091 m_highlightedBracketColor = config->readColorEntry("Color Highlighted Bracket", &tmp3);
01092 m_highlightedBracketColorSet = true;
01093 m_wordWrapMarkerColor = config->readColorEntry("Color Word Wrap Marker", &tmp4);
01094 m_wordWrapMarkerColorSet = true;
01095 m_tabMarkerColor = config->readColorEntry("Color Tab Marker", &tmp5);
01096 m_tabMarkerColorSet = true;
01097 m_iconBarColor = config->readColorEntry("Color Icon Bar", &tmp6);
01098 m_iconBarColorSet = true;
01099 m_lineNumberColor = config->readColorEntry("Color Line Number", &tmp7);
01100 m_lineNumberColorSet = true;
01101
01102
01103 QColor mark[7];
01104 mark[0] = Qt::blue;
01105 mark[1] = Qt::red;
01106 mark[2] = Qt::yellow;
01107 mark[3] = Qt::magenta;
01108 mark[4] = Qt::gray;
01109 mark[5] = Qt::green;
01110 mark[6] = Qt::red;
01111
01112 for (int i = 1; i <= KTextEditor::MarkInterface::reservedMarkersCount(); i++) {
01113 QColor col = config->readColorEntry(QString("Color MarkType%1").arg(i), &mark[i - 1]);
01114 int index = i-1;
01115 m_lineMarkerColorSet[index] = true;
01116 m_lineMarkerColor[index] = col;
01117 }
01118
01119 QFont f (KGlobalSettings::fixedFont());
01120
01121 if (!m_fontSet)
01122 {
01123 m_fontSet = true;
01124 m_font = new KateFontStruct ();
01125 }
01126
01127 m_font->setFont(config->readFontEntry("Font", &f));
01128 }
01129
01130 KateFontStruct *KateRendererConfig::fontStruct ()
01131 {
01132 if (m_fontSet || isGlobal())
01133 return m_font;
01134
01135 return s_global->fontStruct ();
01136 }
01137
01138 QFont *KateRendererConfig::font()
01139 {
01140 return &(fontStruct ()->myFont);
01141 }
01142
01143 KateFontMetrics *KateRendererConfig::fontMetrics()
01144 {
01145 return &(fontStruct ()->myFontMetrics);
01146 }
01147
01148 void KateRendererConfig::setFont(const QFont &font)
01149 {
01150 configStart ();
01151
01152 if (!m_fontSet)
01153 {
01154 m_fontSet = true;
01155 m_font = new KateFontStruct ();
01156 }
01157
01158 m_font->setFont(font);
01159
01160 configEnd ();
01161 }
01162
01163 bool KateRendererConfig::wordWrapMarker () const
01164 {
01165 if (m_wordWrapMarkerSet || isGlobal())
01166 return m_wordWrapMarker;
01167
01168 return s_global->wordWrapMarker();
01169 }
01170
01171 void KateRendererConfig::setWordWrapMarker (bool on)
01172 {
01173 configStart ();
01174
01175 m_wordWrapMarkerSet = true;
01176 m_wordWrapMarker = on;
01177
01178 configEnd ();
01179 }
01180
01181 const QColor& KateRendererConfig::backgroundColor() const
01182 {
01183 if (m_backgroundColorSet || isGlobal())
01184 return m_backgroundColor;
01185
01186 return s_global->backgroundColor();
01187 }
01188
01189 void KateRendererConfig::setBackgroundColor (const QColor &col)
01190 {
01191 configStart ();
01192
01193 m_backgroundColorSet = true;
01194 m_backgroundColor = col;
01195
01196 configEnd ();
01197 }
01198
01199 const QColor& KateRendererConfig::selectionColor() const
01200 {
01201 if (m_selectionColorSet || isGlobal())
01202 return m_selectionColor;
01203
01204 return s_global->selectionColor();
01205 }
01206
01207 void KateRendererConfig::setSelectionColor (const QColor &col)
01208 {
01209 configStart ();
01210
01211 m_selectionColorSet = true;
01212 m_selectionColor = col;
01213
01214 configEnd ();
01215 }
01216
01217 const QColor& KateRendererConfig::highlightedLineColor() const
01218 {
01219 if (m_highlightedLineColorSet || isGlobal())
01220 return m_highlightedLineColor;
01221
01222 return s_global->highlightedLineColor();
01223 }
01224
01225 void KateRendererConfig::setHighlightedLineColor (const QColor &col)
01226 {
01227 configStart ();
01228
01229 m_highlightedLineColorSet = true;
01230 m_highlightedLineColor = col;
01231
01232 configEnd ();
01233 }
01234
01235 const QColor& KateRendererConfig::lineMarkerColor(KTextEditor::MarkInterface::MarkTypes type) const
01236 {
01237 int index = 0;
01238 if (type > 0) { while((type >> index++) ^ 1) {} }
01239 index -= 1;
01240
01241 if ( index < 0 || index >= KTextEditor::MarkInterface::reservedMarkersCount() )
01242 return QColor();
01243
01244 if (m_lineMarkerColorSet[index] || isGlobal())
01245 return m_lineMarkerColor[index];
01246
01247 return s_global->lineMarkerColor( type );
01248 }
01249
01250 void KateRendererConfig::setLineMarkerColor (const QColor &col, KTextEditor::MarkInterface::MarkTypes type)
01251 {
01252 int index = static_cast<int>( log(static_cast<double>(type)) / log(2.0) );
01253 Q_ASSERT( index >= 0 && index < KTextEditor::MarkInterface::reservedMarkersCount() );
01254 configStart ();
01255
01256 m_lineMarkerColorSet[index] = true;
01257 m_lineMarkerColor[index] = col;
01258
01259 configEnd ();
01260 }
01261
01262 const QColor& KateRendererConfig::highlightedBracketColor() const
01263 {
01264 if (m_highlightedBracketColorSet || isGlobal())
01265 return m_highlightedBracketColor;
01266
01267 return s_global->highlightedBracketColor();
01268 }
01269
01270 void KateRendererConfig::setHighlightedBracketColor (const QColor &col)
01271 {
01272 configStart ();
01273
01274 m_highlightedBracketColorSet = true;
01275 m_highlightedBracketColor = col;
01276
01277 configEnd ();
01278 }
01279
01280 const QColor& KateRendererConfig::wordWrapMarkerColor() const
01281 {
01282 if (m_wordWrapMarkerColorSet || isGlobal())
01283 return m_wordWrapMarkerColor;
01284
01285 return s_global->wordWrapMarkerColor();
01286 }
01287
01288 void KateRendererConfig::setWordWrapMarkerColor (const QColor &col)
01289 {
01290 configStart ();
01291
01292 m_wordWrapMarkerColorSet = true;
01293 m_wordWrapMarkerColor = col;
01294
01295 configEnd ();
01296 }
01297
01298 const QColor& KateRendererConfig::tabMarkerColor() const
01299 {
01300 if (m_tabMarkerColorSet || isGlobal())
01301 return m_tabMarkerColor;
01302
01303 return s_global->tabMarkerColor();
01304 }
01305
01306 void KateRendererConfig::setTabMarkerColor (const QColor &col)
01307 {
01308 configStart ();
01309
01310 m_tabMarkerColorSet = true;
01311 m_tabMarkerColor = col;
01312
01313 configEnd ();
01314 }
01315
01316 const QColor& KateRendererConfig::iconBarColor() const
01317 {
01318 if (m_iconBarColorSet || isGlobal())
01319 return m_iconBarColor;
01320
01321 return s_global->iconBarColor();
01322 }
01323
01324 void KateRendererConfig::setIconBarColor (const QColor &col)
01325 {
01326 configStart ();
01327
01328 m_iconBarColorSet = true;
01329 m_iconBarColor = col;
01330
01331 configEnd ();
01332 }
01333
01334 const QColor& KateRendererConfig::lineNumberColor() const
01335 {
01336 if (m_lineNumberColorSet || isGlobal())
01337 return m_lineNumberColor;
01338
01339 return s_global->lineNumberColor();
01340 }
01341
01342 void KateRendererConfig::setLineNumberColor (const QColor &col)
01343 {
01344 configStart ();
01345
01346 m_lineNumberColorSet = true;
01347 m_lineNumberColor = col;
01348
01349 configEnd ();
01350 }
01351
01352
01353