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