kate Library: kateconfig.cpp Source File (kate Library)

| # kate Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kateconfig.cpp

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2003 Christoph Cullmann <cullmann@kde.org>
    00003
    00004    This library is free software; you can redistribute it and/or
    00005    modify it under the terms of the GNU Library General Public
    00006    License version 2 as published by the Free Software Foundation.
    00007
    00008    This library is distributed in the hope that it will be useful,
    00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00011    Library General Public License for more details.
    00012
    00013    You should have received a copy of the GNU Library General Public License
    00014    along with this library; see the file COPYING.LIB.  If not, write to
    00015    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00016    Boston, MA 02111-1307, USA.
    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 //BEGIN KateConfig
    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 //END
    00080
    00081 //BEGIN KateDocumentConfig
    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   // init plugin array
    00112   m_plugins.fill (false);
    00113   m_pluginsSet.fill (true);
    00114
    00115   // init with defaults from config or really hardcoded ones
    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   // init plugin array
    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   // plugins
    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   // plugins
    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 //END
    00588
    00589 //BEGIN KateViewConfig
    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   // init with defaults from config or really hardcoded ones
    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 //END
    00950
    00951 //BEGIN KateRendererConfig
    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   // init bitarray
    00971   m_lineMarkerColorSet.fill (true);
    00972
    00973   s_global = this;
    00974
    00975   // init with defaults from config or really hardcoded ones
    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   // init bitarray
    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     // same std colors like in KateDocument::markColor
    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 //END
    01352
    01353 // kate: space-indent on; indent-width 2; replace-tabs on;

This file is part of the documentation for kate Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:36:30 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003