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