SVN commit 1146719 by beschow:
[kate:kate1.git] / part / utils / kateconfig.cpp
1 /* This file is part of the KDE libraries
2    Copyright (C) 2007, 2008 Matthew Woehlke <mw_triad@users.sourceforge.net>
3    Copyright (C) 2003 Christoph Cullmann <cullmann@kde.org>
4
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public
7    License version 2 as published by the Free Software Foundation.
8
9    This library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public License
15    along with this library; see the file COPYING.LIB.  If not, write to
16    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17    Boston, MA 02110-1301, USA.
18 */
19
20 #include "kateconfig.h"
21
22 #include "kateglobal.h"
23 #include "katerenderer.h"
24 #include "kateview.h"
25 #include "katedocument.h"
26 #include "kateschema.h"
27
28 #include <math.h>
29
30 #include <kconfig.h>
31 #include <kglobalsettings.h>
32 #include <kcolorscheme.h>
33 #include <kcolorutils.h>
34 #include <kcharsets.h>
35 #include <klocale.h>
36 #include <kcomponentdata.h>
37 #include <kdebug.h>
38
39 #include <QtCore/QTextCodec>
40 #include <QStringListModel>
41
42 //BEGIN KateConfig
43 KateConfig::KateConfig ()
44  : configSessionNumber (0), configIsRunning (false)
45 {
46 }
47
48 KateConfig::~KateConfig ()
49 {
50 }
51
52 void KateConfig::configStart ()
53 {
54   configSessionNumber++;
55
56   if (configSessionNumber > 1)
57     return;
58
59   configIsRunning = true;
60 }
61
62 void KateConfig::configEnd ()
63 {
64   if (configSessionNumber == 0)
65     return;
66
67   configSessionNumber--;
68
69   if (configSessionNumber > 0)
70     return;
71
72   configIsRunning = false;
73
74   updateConfig ();
75 }
76 //END
77
78 //BEGIN KateDocumentConfig
79 KateGlobalConfig *KateGlobalConfig::s_global = 0;
80 KateDocumentConfig *KateDocumentConfig::s_global = 0;
81 KateViewConfig *KateViewConfig::s_global = 0;
82 KateRendererConfig *KateRendererConfig::s_global = 0;
83
84 KateGlobalConfig::KateGlobalConfig ()
85 {
86   s_global = this;
87
88   // init with defaults from config or really hardcoded ones
89   KConfigGroup cg( KGlobal::config(), "Kate Part Defaults");
90   readConfig (cg);
91 }
92
93 KateGlobalConfig::~KateGlobalConfig ()
94 {
95 }
96
97 void KateGlobalConfig::readConfig (const KConfigGroup &config)
98 {
99   configStart ();
100
101   setProberType ((KEncodingProber::ProberType)config.readEntry("Encoding Prober Type", (int)KEncodingProber::Universal));
102   setFallbackEncoding (config.readEntry("Fallback Encoding", ""));
103
104   configEnd ();
105 }
106
107 void KateGlobalConfig::writeConfig (KConfigGroup &config)
108 {
109   config.writeEntry("Encoding Prober Type", (int)proberType());
110   config.writeEntry("Fallback Encoding", fallbackEncoding());
111 }
112
113 void KateGlobalConfig::updateConfig ()
114 {
115 }
116
117 void KateGlobalConfig::setProberType (KEncodingProber::ProberType proberType)
118 {
119   configStart ();
120   m_proberType = proberType;
121   configEnd ();
122 }
123
124 const QString &KateGlobalConfig::fallbackEncoding () const
125 {
126   return m_fallbackEncoding;
127 }
128
129 QTextCodec *KateGlobalConfig::fallbackCodec () const
130 {
131   if (m_fallbackEncoding.isEmpty())
132       return QTextCodec::codecForName("ISO 8859-15");
133
134   return KGlobal::charsets()->codecForName (m_fallbackEncoding);
135 }
136
137 bool KateGlobalConfig::setFallbackEncoding (const QString &encoding)
138 {
139   QTextCodec *codec;
140   bool found = false;
141   if (encoding.isEmpty())
142   {
143     codec = s_global->fallbackCodec();
144     found = true;
145   }
146   else
147     codec = KGlobal::charsets()->codecForName (encoding, found);
148
149   if (!found || !codec)
150     return false;
151
152   configStart ();
153   m_fallbackEncoding = codec->name();
154   configEnd ();
155   return true;
156 }
157
158 KateDocumentConfig::KateDocumentConfig ()
159  : m_indentationWidth (2),
160    m_tabWidth (8),
161    m_tabHandling (tabSmart),
162    m_configFlags (0),
163    m_wordWrapAt (80),
164    m_tabWidthSet (true),
165    m_indentationWidthSet (true),
166    m_indentationModeSet (true),
167    m_wordWrapSet (true),
168    m_wordWrapAtSet (true),
169    m_pageUpDownMovesCursorSet (true),
170    m_keepExtraSpacesSet (false),
171    m_indentPastedTextSet (false),
172    m_backspaceIndentsSet (false),
173    m_smartHomeSet (false),
174    m_wrapCursorSet (false),
175    m_autoBracketsSet (false),
176    m_showTabsSet (false),
177    m_showSpacesSet (false),
178    m_replaceTabsDynSet (false),
179    m_removeTrailingDynSet (false),
180    m_removeSpacesSet (false),
181    m_overwiteModeSet (false),
182    m_tabIndentsSet (false),
183    m_encodingSet (true),
184    m_eolSet (true),
185    m_bomSet (true),
186    m_allowEolDetectionSet (false),
187    m_allowSimpleModeSet (false),
188    m_backupFlagsSet (true),
189    m_searchDirConfigDepthSet (true),
190    m_backupPrefixSet (true),
191    m_backupSuffixSet (true),
192    m_onTheFlySpellCheckSet (true),
193    m_doc (0)
194 {
195   s_global = this;
196
197   // init with defaults from config or really hardcoded ones
198   KConfigGroup cg( KGlobal::config(), "Kate Document Defaults");
199   readConfig (cg);
200 }
201
202 KateDocumentConfig::KateDocumentConfig (const KConfigGroup &cg)
203  : m_indentationWidth (2),
204    m_tabWidth (8),
205    m_tabHandling (tabSmart),
206    m_configFlags (0),
207    m_wordWrapAt (80),
208    m_tabWidthSet (true),
209    m_indentationWidthSet (true),
210    m_indentationModeSet (true),
211    m_wordWrapSet (true),
212    m_wordWrapAtSet (true),
213    m_pageUpDownMovesCursorSet (true),
214    m_keepExtraSpacesSet (false),
215    m_indentPastedTextSet (false),
216    m_backspaceIndentsSet (false),
217    m_smartHomeSet (false),
218    m_wrapCursorSet (false),
219    m_autoBracketsSet (false),
220    m_showTabsSet (false),
221    m_showSpacesSet (false),
222    m_replaceTabsDynSet (false),
223    m_removeTrailingDynSet (false),
224    m_removeSpacesSet (false),
225    m_overwiteModeSet (false),
226    m_tabIndentsSet (false),
227    m_encodingSet (true),
228    m_eolSet (true),
229    m_bomSet (true),
230    m_allowEolDetectionSet (false),
231    m_allowSimpleModeSet (false),
232    m_backupFlagsSet (true),
233    m_searchDirConfigDepthSet (true),
234    m_backupPrefixSet (true),
235    m_backupSuffixSet (true),
236    m_onTheFlySpellCheckSet (true),
237    m_doc (0)
238 {
239   // init with defaults from config or really hardcoded ones
240   readConfig (cg);
241 }
242
243 KateDocumentConfig::KateDocumentConfig (KateDocument *doc)
244  : m_tabHandling (tabSmart),
245    m_configFlags (0),
246    m_tabWidthSet (false),
247    m_indentationWidthSet (false),
248    m_indentationModeSet (false),
249    m_wordWrapSet (false),
250    m_wordWrapAtSet (false),
251    m_pageUpDownMovesCursorSet (false),
252    m_keepExtraSpacesSet (false),
253    m_indentPastedTextSet (false),
254    m_backspaceIndentsSet (false),
255    m_smartHomeSet (false),
256    m_wrapCursorSet (false),
257    m_autoBracketsSet (false),
258    m_showTabsSet (false),
259    m_showSpacesSet (false),
260    m_replaceTabsDynSet (false),
261    m_removeTrailingDynSet (false),
262    m_removeSpacesSet (false),
263    m_overwiteModeSet (false),
264    m_tabIndentsSet (false),
265    m_encodingSet (false),
266    m_eolSet (false),
267    m_bomSet (false),
268    m_allowEolDetectionSet (false),
269    m_allowSimpleModeSet (false),
270    m_backupFlagsSet (false),
271    m_searchDirConfigDepthSet (false),
272    m_backupPrefixSet (false),
273    m_backupSuffixSet (false),
274    m_onTheFlySpellCheckSet (false),
275    m_doc (doc)
276 {
277 }
278
279 KateDocumentConfig::~KateDocumentConfig ()
280 {
281 }
282
283 void KateDocumentConfig::readConfig (const KConfigGroup &config)
284 {
285   configStart ();
286
287   setTabWidth (config.readEntry("Tab Width", 8));
288
289   setIndentationWidth (config.readEntry("Indentation Width", 2));
290
291   setIndentationMode (config.readEntry("Indentation Mode", ""));
292
293   setTabHandling (config.readEntry("Tab Handling", int(KateDocumentConfig::tabSmart)));
294
295   setWordWrap (config.readEntry("Word Wrap", false));
296   setWordWrapAt (config.readEntry("Word Wrap Column", 80));
297   setPageUpDownMovesCursor (config.readEntry("PageUp/PageDown Moves Cursor", false));
298
299   setSmartHome (config.readEntry("Smart Home", true));
300   setWrapCursor (config.readEntry("Wrap Cursor", true));
301   setShowTabs (config.readEntry("Show Tabs", true));
302   setTabIndents (config.readEntry("Indent On Tab", true));
303   setKeepExtraSpaces (config.readEntry("Keep Extra Spaces", false));
304   setIndentPastedText (config.readEntry("Indent On Text Paste", false));
305   setBackspaceIndents (config.readEntry("Indent On Backspace", false));
306   setAutoBrackets (config.readEntry("Automatically Insert Closing Brackets", false));
307   setShowSpaces (config.readEntry("Show Spaces", false));
308   setReplaceTabsDyn (config.readEntry("ReplaceTabsDyn", false));
309   setRemoveTrailingDyn (config.readEntry("RemoveTrailingDyn", false));
310   setRemoveSpaces (config.readEntry("Remove Spaces", false));
311   setOvr (config.readEntry("Overwrite Mode", false));
312
313   setEncoding (config.readEntry("Encoding", ""));
314
315   setEol (config.readEntry("End of Line", 0));
316   setAllowEolDetection (config.readEntry("Allow End of Line Detection", true));
317
318   setBom (config.readEntry("BOM",false));
319
320   setAllowSimpleMode (config.readEntry("Allow Simple Mode", true));
321
322   setBackupFlags (config.readEntry("Backup Config Flags", 1));
323
324   setSearchDirConfigDepth (config.readEntry("Search Dir Config Depth", 3));
325
326   setBackupPrefix (config.readEntry("Backup Prefix", QString ("")));
327
328   setBackupSuffix (config.readEntry("Backup Suffix", QString ("~")));
329
330   setOnTheFlySpellCheck(config.readEntry("On-The-Fly Spellcheck", false));
331
332   configEnd ();
333 }
334
335 void KateDocumentConfig::writeConfig (KConfigGroup &config)
336 {
337   config.writeEntry("Tab Width", tabWidth());
338
339   config.writeEntry("Indentation Width", indentationWidth());
340   config.writeEntry("Indentation Mode", indentationMode());
341
342   config.writeEntry("Tab Handling", tabHandling());
343
344   config.writeEntry("Word Wrap", wordWrap());
345   config.writeEntry("Word Wrap Column", wordWrapAt());
346
347   config.writeEntry("PageUp/PageDown Moves Cursor", pageUpDownMovesCursor());
348
349   config.writeEntry("Smart Home", smartHome());
350   config.writeEntry("Wrap Cursor", wrapCursor());
351   config.writeEntry("Show Tabs", showTabs());
352   config.writeEntry("Indent On Tab", tabIndentsEnabled());
353   config.writeEntry("Keep Extra Spaces", keepExtraSpaces());
354   config.writeEntry("Indent On Text Paste", indentPastedText());
355   config.writeEntry("Indent On Backspace", backspaceIndents());
356   config.writeEntry("Automatically Insert Closing Brackets", autoBrackets());
357   config.writeEntry("Show Spaces", showSpaces());
358   config.writeEntry("ReplaceTabsDyn", replaceTabsDyn());
359   config.writeEntry("RemoveTrailingDyn", removeTrailingDyn());
360   config.writeEntry("Remove Spaces", removeSpaces());
361   config.writeEntry("Overwrite Mode", ovr());
362
363   config.writeEntry("Encoding", encoding());
364
365   config.writeEntry("End of Line", eol());
366   config.writeEntry("Allow End of Line Detection", allowEolDetection());
367
368   config.writeEntry("BOM",bom());
369
370   config.writeEntry("Allow Simple Mode", allowSimpleMode());
371
372   config.writeEntry("Backup Config Flags", backupFlags());
373
374   config.writeEntry("Search Dir Config Depth", searchDirConfigDepth());
375
376   config.writeEntry("Backup Prefix", backupPrefix());
377
378   config.writeEntry("Backup Suffix", backupSuffix());
379
380   config.writeEntry("On-The-Fly Spellcheck", onTheFlySpellCheck());
381 }
382
383 void KateDocumentConfig::updateConfig ()
384 {
385   if (m_doc)
386   {
387     m_doc->updateConfig ();
388     return;
389   }
390
391   if (isGlobal())
392   {
393     for (int z=0; z < KateGlobal::self()->kateDocuments().size(); ++z)
394       (KateGlobal::self()->kateDocuments())[z]->updateConfig ();
395   }
396 }
397
398 int KateDocumentConfig::tabWidth () const
399 {
400   if (m_tabWidthSet || isGlobal())
401     return m_tabWidth;
402
403   return s_global->tabWidth();
404 }
405
406 void KateDocumentConfig::setTabWidth (int tabWidth)
407 {
408   if (tabWidth < 1)
409     return;
410
411   configStart ();
412
413   m_tabWidthSet = true;
414   m_tabWidth = tabWidth;
415
416   configEnd ();
417 }
418
419 int KateDocumentConfig::indentationWidth () const
420 {
421   if (m_indentationWidthSet || isGlobal())
422     return m_indentationWidth;
423
424   return s_global->indentationWidth();
425 }
426
427 void KateDocumentConfig::setIndentationWidth (int indentationWidth)
428 {
429   if (indentationWidth < 1)
430     return;
431
432   configStart ();
433
434   m_indentationWidthSet = true;
435   m_indentationWidth = indentationWidth;
436
437   configEnd ();
438 }
439
440 const QString &KateDocumentConfig::indentationMode () const
441 {
442   if (m_indentationModeSet || isGlobal())
443     return m_indentationMode;
444
445   return s_global->indentationMode();
446 }
447
448 void KateDocumentConfig::setIndentationMode (const QString &indentationMode)
449 {
450   configStart ();
451
452   m_indentationModeSet = true;
453   m_indentationMode = indentationMode;
454
455   configEnd ();
456 }
457
458 uint KateDocumentConfig::tabHandling () const
459 {
460   // This setting is purly a user preference,
461   // hence, there exists only the global setting.
462   if (isGlobal())
463     return m_tabHandling;
464
465   return s_global->tabHandling();
466 }
467
468 void KateDocumentConfig::setTabHandling (uint tabHandling)
469 {
470   configStart ();
471
472   m_tabHandling = tabHandling;
473
474   configEnd ();
475 }
476
477 bool KateDocumentConfig::wordWrap () const
478 {
479   if (m_wordWrapSet || isGlobal())
480     return m_wordWrap;
481
482   return s_global->wordWrap();
483 }
484
485 void KateDocumentConfig::setWordWrap (bool on)
486 {
487   configStart ();
488
489   m_wordWrapSet = true;
490   m_wordWrap = on;
491
492   configEnd ();
493 }
494
495 unsigned int KateDocumentConfig::wordWrapAt () const
496 {
497   if (m_wordWrapAtSet || isGlobal())
498     return m_wordWrapAt;
499
500   return s_global->wordWrapAt();
501 }
502
503 void KateDocumentConfig::setWordWrapAt (unsigned int col)
504 {
505   if (col < 1)
506     return;
507
508   configStart ();
509
510   m_wordWrapAtSet = true;
511   m_wordWrapAt = col;
512
513   configEnd ();
514 }
515
516 bool KateDocumentConfig::pageUpDownMovesCursor () const
517 {
518   if (m_pageUpDownMovesCursorSet || isGlobal())
519     return m_pageUpDownMovesCursor;
520
521   return s_global->pageUpDownMovesCursor();
522 }
523
524 void KateDocumentConfig::setPageUpDownMovesCursor (bool on)
525 {
526   configStart ();
527
528   m_pageUpDownMovesCursorSet = true;
529   m_pageUpDownMovesCursor = on;
530
531   configEnd ();
532 }
533
534 void KateDocumentConfig::setKeepExtraSpaces(bool on)
535 {
536   configStart ();
537
538   m_keepExtraSpacesSet = true;
539   m_keepExtraSpaces = on;
540
541   configEnd ();
542 }
543
544 bool KateDocumentConfig::keepExtraSpaces() const
545 {
546   if (m_keepExtraSpacesSet || isGlobal())
547     return m_keepExtraSpaces;
548
549   return s_global->keepExtraSpaces();
550 }
551
552 void KateDocumentConfig::setIndentPastedText(bool on)
553 {
554   configStart ();
555
556   m_indentPastedTextSet = true;
557   m_indentPastedText = on;
558
559   configEnd ();
560 }
561
562 bool KateDocumentConfig::indentPastedText() const
563 {
564   if (m_indentPastedTextSet || isGlobal())
565     return m_indentPastedText;
566
567   return s_global->indentPastedText();
568 }
569
570 void KateDocumentConfig::setBackspaceIndents(bool on)
571 {
572   configStart ();
573
574   m_backspaceIndentsSet = true;
575   m_backspaceIndents = on;
576
577   configEnd ();
578 }
579
580 bool KateDocumentConfig::backspaceIndents() const
581 {
582   if (m_backspaceIndentsSet || isGlobal())
583     return m_backspaceIndents;
584
585   return s_global->backspaceIndents();
586 }
587
588 void KateDocumentConfig::setSmartHome(bool on)
589 {
590   configStart ();
591
592   m_smartHomeSet = true;
593   m_smartHome = on;
594
595   configEnd ();
596 }
597
598 bool KateDocumentConfig::smartHome() const
599 {
600   if (m_smartHomeSet || isGlobal())
601     return m_smartHome;
602
603   return s_global->smartHome();
604 }
605
606 void KateDocumentConfig::setWrapCursor(bool on)
607 {
608   configStart ();
609
610   m_wrapCursorSet = true;
611   m_wrapCursor = on;
612
613   configEnd ();
614 }
615
616 bool KateDocumentConfig::wrapCursor() const
617 {
618   if (m_wrapCursorSet || isGlobal())
619     return m_wrapCursor;
620
621   return s_global->wrapCursor();
622 }
623
624 void KateDocumentConfig::setAutoBrackets(bool on)
625 {
626   configStart ();
627
628   m_autoBracketsSet = true;
629   m_autoBrackets = on;
630
631   configEnd ();
632 }
633
634 bool KateDocumentConfig::autoBrackets() const
635 {
636   if (m_autoBracketsSet || isGlobal())
637     return m_autoBrackets;
638
639   return s_global->autoBrackets();
640 }
641
642 void KateDocumentConfig::setShowTabs(bool on)
643 {
644   configStart ();
645
646   m_showTabsSet = true;
647   m_showTabs = on;
648
649   configEnd ();
650 }
651
652 bool KateDocumentConfig::showTabs() const
653 {
654   if (m_showTabsSet || isGlobal())
655     return m_showTabs;
656
657   return s_global->showTabs();
658 }
659
660 void KateDocumentConfig::setShowSpaces(bool on)
661 {
662   configStart ();
663
664   m_showSpacesSet = true;
665   m_showSpaces = on;
666
667   configEnd ();
668 }
669
670 bool KateDocumentConfig::showSpaces() const
671 {
672   if (m_showSpacesSet || isGlobal())
673     return m_showSpaces;
674
675   return s_global->showSpaces();
676 }
677
678 void KateDocumentConfig::setReplaceTabsDyn(bool on)
679 {
680   configStart ();
681
682   m_replaceTabsDynSet = true;
683   m_replaceTabsDyn = on;
684
685   configEnd ();
686 }
687
688 bool KateDocumentConfig::replaceTabsDyn() const
689 {
690   if (m_replaceTabsDynSet || isGlobal())
691     return m_replaceTabsDyn;
692
693   return s_global->replaceTabsDyn();
694 }
695
696 void KateDocumentConfig::setRemoveTrailingDyn(bool on)
697 {
698   configStart ();
699
700   m_removeTrailingDynSet = true;
701   m_removeTrailingDyn = on;
702
703   configEnd ();
704 }
705
706 bool KateDocumentConfig::removeTrailingDyn() const
707 {
708   if (m_removeTrailingDynSet || isGlobal())
709     return m_removeTrailingDyn;
710
711   return s_global->removeTrailingDyn();
712 }
713
714 void KateDocumentConfig::setRemoveSpaces(bool on)
715 {
716   configStart ();
717
718   m_removeSpacesSet = true;
719   m_removeSpaces = on;
720
721   configEnd ();
722 }
723
724 bool KateDocumentConfig::removeSpaces() const
725 {
726   if (m_removeSpacesSet || isGlobal())
727     return m_removeSpaces;
728
729   return s_global->removeSpaces();
730 }
731
732 void KateDocumentConfig::setOvr(bool on)
733 {
734   configStart ();
735
736   m_overwiteModeSet = true;
737   m_overwiteMode = on;
738
739   configEnd ();
740 }
741
742 bool KateDocumentConfig::ovr() const
743 {
744   if (m_overwiteModeSet || isGlobal())
745     return m_overwiteMode;
746
747   return s_global->ovr();
748 }
749
750 void KateDocumentConfig::setTabIndents(bool on)
751 {
752   configStart ();
753
754   m_tabIndentsSet = true;
755   m_tabIndents = on;
756
757   configEnd ();
758 }
759
760 bool KateDocumentConfig::tabIndentsEnabled() const
761 {
762   if (m_tabIndentsSet || isGlobal())
763     return m_tabIndents;
764
765   return s_global->tabIndentsEnabled();
766 }
767
768 const QString &KateDocumentConfig::encoding () const
769 {
770   if (m_encodingSet || isGlobal())
771     return m_encoding;
772
773   return s_global->encoding();
774 }
775
776 QTextCodec *KateDocumentConfig::codec () const
777 {
778   if (m_encodingSet || isGlobal())
779   {
780     if (m_encoding.isEmpty() && isGlobal())
781       return KGlobal::locale()->codecForEncoding();
782     else if (m_encoding.isEmpty())
783       return s_global->codec ();
784     else
785       return KGlobal::charsets()->codecForName (m_encoding);
786   }
787
788   return s_global->codec ();
789 }
790
791 bool KateDocumentConfig::setEncoding (const QString &encoding)
792 {
793   QTextCodec *codec;
794   bool found = false;
795   if (encoding.isEmpty())
796   {
797     codec = s_global->codec();
798     found=true;
799   }
800   else
801     codec = KGlobal::charsets()->codecForName (encoding, found);
802
803   if (!found || !codec)
804     return false;
805
806   configStart ();
807   m_encodingSet = true;
808   m_encoding = codec->name();
809
810   if (isGlobal())
811     KateGlobal::self()->setDefaultEncoding (m_encoding);
812
813   configEnd ();
814   return true;
815 }
816
817 bool KateDocumentConfig::isSetEncoding () const
818 {
819   return m_encodingSet;
820 }
821
822 int KateDocumentConfig::eol () const
823 {
824   if (m_eolSet || isGlobal())
825     return m_eol;
826
827   return s_global->eol();
828 }
829
830 QString KateDocumentConfig::eolString ()
831 {
832   if (eol() == KateDocumentConfig::eolUnix)
833     return QString ("\n");
834   else if (eol() == KateDocumentConfig::eolDos)
835     return QString ("\r\n");
836   else if (eol() == KateDocumentConfig::eolMac)
837     return QString ("\r");
838
839   return QString ("\n");
840 }
841
842 void KateDocumentConfig::setEol (int mode)
843 {
844   configStart ();
845
846   m_eolSet = true;
847   m_eol = mode;
848
849   configEnd ();
850 }
851
852 void KateDocumentConfig::setBom (bool bom)
853 {
854   configStart ();
855
856   m_bomSet = true;
857   m_bom = bom;
858
859   configEnd ();
860 }
861
862 bool KateDocumentConfig::bom() const
863 {
864     if (m_bomSet || isGlobal())
865       return m_bom;
866     return s_global->bom();
867 }
868
869
870 bool KateDocumentConfig::allowEolDetection () const
871 {
872   if (m_allowEolDetectionSet || isGlobal())
873     return m_allowEolDetection;
874
875   return s_global->allowEolDetection();
876 }
877
878 void KateDocumentConfig::setAllowEolDetection (bool on)
879 {
880   configStart ();
881
882   m_allowEolDetectionSet = true;
883   m_allowEolDetection = on;
884
885   configEnd ();
886 }
887
888
889 bool KateDocumentConfig::allowSimpleMode () const
890 {
891   if (m_allowSimpleModeSet || isGlobal())
892     return m_allowSimpleMode;
893
894   return s_global->allowSimpleMode();
895 }
896
897 void KateDocumentConfig::setAllowSimpleMode (bool on)
898 {
899   configStart ();
900
901   m_allowSimpleModeSet = true;
902   m_allowSimpleMode = on;
903
904   configEnd ();
905 }
906
907 uint KateDocumentConfig::backupFlags () const
908 {
909   if (m_backupFlagsSet || isGlobal())
910     return m_backupFlags;
911
912   return s_global->backupFlags();
913 }
914
915 void KateDocumentConfig::setBackupFlags (uint flags)
916  {
917   configStart ();
918
919   m_backupFlagsSet = true;
920   m_backupFlags = flags;
921
922   configEnd ();
923 }
924
925 const QString &KateDocumentConfig::backupPrefix () const
926 {
927   if (m_backupPrefixSet || isGlobal())
928     return m_backupPrefix;
929
930   return s_global->backupPrefix();
931 }
932
933 const QString &KateDocumentConfig::backupSuffix () const
934 {
935   if (m_backupSuffixSet || isGlobal())
936     return m_backupSuffix;
937
938   return s_global->backupSuffix();
939 }
940
941 void KateDocumentConfig::setBackupPrefix (const QString &prefix)
942 {
943   configStart ();
944
945   m_backupPrefixSet = true;
946   m_backupPrefix = prefix;
947
948   configEnd ();
949 }
950
951 void KateDocumentConfig::setBackupSuffix (const QString &suffix)
952 {
953   configStart ();
954
955   m_backupSuffixSet = true;
956   m_backupSuffix = suffix;
957
958   configEnd ();
959 }
960
961 int KateDocumentConfig::searchDirConfigDepth () const
962 {
963   if (m_searchDirConfigDepthSet || isGlobal())
964     return m_searchDirConfigDepth;
965
966   return s_global->searchDirConfigDepth ();
967 }
968
969 void KateDocumentConfig::setSearchDirConfigDepth (int depth)
970 {
971   configStart ();
972
973   m_searchDirConfigDepthSet = true;
974   m_searchDirConfigDepth = depth;
975
976   configEnd ();
977 }
978
979 bool KateDocumentConfig::onTheFlySpellCheck() const
980 {
981   if(isGlobal()) {
982     // WARNING: this is slightly hackish, but it's currently the only way to
983     //          do it, see also the KTextEdit class
984     KConfigGroup configGroup(KGlobal::config(), "Spelling");
985     return configGroup.readEntry("checkerEnabledByDefault", false);
986   }
987   if (m_onTheFlySpellCheckSet) {
988     return m_onTheFlySpellCheck;
989   }
990
991   return s_global->onTheFlySpellCheck();
992 }
993
994 void KateDocumentConfig::setOnTheFlySpellCheck(bool on)
995 {
996   configStart ();
997
998   m_onTheFlySpellCheckSet = true;
999   m_onTheFlySpellCheck = on;
1000
1001   configEnd ();
1002 }
1003
1004
1005
1006
1007 //END
1008
1009 //BEGIN KateViewConfig
1010 KateViewConfig::KateViewConfig ()
1011  :
1012    m_dynWordWrapSet (true),
1013    m_dynWordWrapIndicatorsSet (true),
1014    m_dynWordWrapAlignIndentSet (true),
1015    m_lineNumbersSet (true),
1016    m_scrollBarMarksSet (true),
1017    m_iconBarSet (true),
1018    m_foldingBarSet (true),
1019    m_bookmarkSortSet (true),
1020    m_autoCenterLinesSet (true),
1021    m_searchFlagsSet (true),
1022    m_defaultMarkTypeSet (true),
1023    m_persistentSelectionSet (true),
1024    m_viInputModeSet (true),
1025    m_viInputModeStealKeysSet (true),
1026    m_automaticCompletionInvocationSet (true),
1027    m_wordCompletionSet (true),
1028    m_wordCompletionMinimalWordLengthSet (true),
1029    m_smartCopyCutSet (true),
1030    m_scrollPastEndSet (true),
1031    m_view (0)
1032 {
1033   s_global = this;
1034
1035   // init with defaults from config or really hardcoded ones
1036   KConfigGroup config( KGlobal::config(), "Kate View Defaults");
1037   readConfig (config);
1038 }
1039
1040 KateViewConfig::KateViewConfig (KateView *view)
1041  :
1042    m_searchFlags (PowerModePlainText),
1043    m_dynWordWrapSet (false),
1044    m_dynWordWrapIndicatorsSet (false),
1045    m_dynWordWrapAlignIndentSet (false),
1046    m_lineNumbersSet (false),
1047    m_scrollBarMarksSet (false),
1048    m_iconBarSet (false),
1049    m_foldingBarSet (false),
1050    m_bookmarkSortSet (false),
1051    m_autoCenterLinesSet (false),
1052    m_searchFlagsSet (false),
1053    m_defaultMarkTypeSet (false),
1054    m_persistentSelectionSet (false),
1055    m_viInputModeSet (false),
1056    m_viInputModeStealKeysSet (false),
1057    m_automaticCompletionInvocationSet (false),
1058    m_wordCompletionSet (false),
1059    m_wordCompletionMinimalWordLengthSet (false),
1060    m_smartCopyCutSet (false),
1061    m_scrollPastEndSet (false),
1062    m_view (view)
1063 {
1064 }
1065
1066 KateViewConfig::~KateViewConfig ()
1067 {
1068 }
1069
1070
1071 // TODO Extract more keys to constants for maintainability
1072 static const char * const KEY_SEARCH_REPLACE_FLAGS = "Search/Replace Flags";
1073 static const char * const KEY_PATTERN_HISTORY = "Search Pattern History";
1074 static const char * const KEY_REPLACEMENT_HISTORY = "Replacement Text History";
1075
1076
1077 void KateViewConfig::readConfig ( const KConfigGroup &config)
1078 {
1079   configStart ();
1080
1081   // default off again, until this is usable for large size documents
1082   setDynWordWrap (config.readEntry( "Dynamic Word Wrap", false ));
1083   setDynWordWrapIndicators (config.readEntry( "Dynamic Word Wrap Indicators", 1 ));
1084   setDynWordWrapAlignIndent (config.readEntry( "Dynamic Word Wrap Align Indent", 80 ));
1085
1086   setLineNumbers (config.readEntry( "Line Numbers",  false));
1087
1088   setScrollBarMarks (config.readEntry( "Scroll Bar Marks",  false));
1089
1090   setIconBar (config.readEntry( "Icon Bar", false ));
1091
1092   setFoldingBar (config.readEntry( "Folding Bar", true));
1093
1094   setBookmarkSort (config.readEntry( "Bookmark Menu Sorting", 0 ));
1095
1096   setAutoCenterLines (config.readEntry( "Auto Center Lines", 0 ));
1097
1098   setSearchFlags(config.readEntry(KEY_SEARCH_REPLACE_FLAGS,
1099       IncFromCursor|PowerMatchCase|PowerModePlainText));
1100
1101   m_maxHistorySize = config.readEntry("Maximum Search History Size", 100);
1102
1103   setDefaultMarkType (config.readEntry( "Default Mark Type", int(KTextEditor::MarkInterface::markType01) ));
1104
1105   setPersistentSelection (config.readEntry( "Persistent Selection", false ));
1106
1107   setViInputMode (config.readEntry( "Vi Input Mode", false));
1108   setViInputModeStealKeys (config.readEntry( "Vi Input Mode Steal Keys", false));
1109   setViInputModeHideStatusBar (config.readEntry( "Vi Input Mode Hide Status Bar", false));
1110
1111   setAutomaticCompletionInvocation (config.readEntry( "Auto Completion", true ));
1112   setWordCompletion (config.readEntry( "Word Completion", true ));
1113   setWordCompletionMinimalWordLength (config.readEntry( "Word Completion Minimal Word Length", 3 ));
1114   setSmartCopyCut (config.readEntry( "Smart Copy Cut", false ));
1115   setScrollPastEnd (config.readEntry( "Scroll Past End", false ));
1116
1117   if (isGlobal()) {
1118     // Read search pattern history
1119     QStringList patternHistory = config.readEntry(KEY_PATTERN_HISTORY, QStringList());
1120     m_patternHistoryModel.setStringList(patternHistory);
1121
1122     // Read replacement text history
1123     QStringList replacementHistory = config.readEntry(KEY_REPLACEMENT_HISTORY, QStringList());
1124     m_replacementHistoryModel.setStringList(replacementHistory);
1125   }
1126
1127   configEnd ();
1128 }
1129
1130 void KateViewConfig::writeConfig (KConfigGroup &config)
1131 {
1132   config.writeEntry( "Dynamic Word Wrap", dynWordWrap() );
1133   config.writeEntry( "Dynamic Word Wrap Indicators", dynWordWrapIndicators() );
1134   config.writeEntry( "Dynamic Word Wrap Align Indent", dynWordWrapAlignIndent() );
1135
1136   config.writeEntry( "Line Numbers", lineNumbers() );
1137
1138   config.writeEntry( "Scroll Bar Marks", scrollBarMarks() );
1139
1140   config.writeEntry( "Icon Bar", iconBar() );
1141
1142   config.writeEntry( "Folding Bar", foldingBar() );
1143
1144   config.writeEntry( "Bookmark Menu Sorting", bookmarkSort() );
1145
1146   config.writeEntry( "Auto Center Lines", autoCenterLines() );
1147
1148   config.writeEntry(KEY_SEARCH_REPLACE_FLAGS, int(searchFlags()));
1149
1150   config.writeEntry("Maximum Search History Size", m_maxHistorySize);
1151
1152   config.writeEntry("Default Mark Type", defaultMarkType());
1153
1154   config.writeEntry("Persistent Selection", persistentSelection());
1155
1156   config.writeEntry( "Auto Completion", automaticCompletionInvocation());
1157   config.writeEntry( "Word Completion", wordCompletion());
1158   config.writeEntry( "Word Completion Minimal Word Length", wordCompletionMinimalWordLength());
1159
1160   config.writeEntry( "Smart Copy Cut", smartCopyCut() );
1161   config.writeEntry( "Scroll Past End" , scrollPastEnd() );
1162
1163   config.writeEntry( "Vi Input Mode", viInputMode());
1164
1165   config.writeEntry( "Vi Input Mode Steal Keys", viInputModeStealKeys());
1166
1167   config.writeEntry( "Vi Input Mode Hide Status Bar", viInputModeHideStatusBar());
1168
1169
1170   if (isGlobal()) {
1171     // Write search pattern history
1172     config.writeEntry(KEY_PATTERN_HISTORY, m_patternHistoryModel.stringList());
1173
1174     // Write replacement text history
1175     config.writeEntry(KEY_REPLACEMENT_HISTORY, m_replacementHistoryModel.stringList());
1176   }
1177 }
1178
1179 void KateViewConfig::updateConfig ()
1180 {
1181   if (m_view)
1182   {
1183     m_view->updateConfig ();
1184     return;
1185   }
1186
1187   if (isGlobal())
1188   {
1189     for (int z=0; z < KateGlobal::self()->views().size(); ++z)
1190       (KateGlobal::self()->views())[z]->updateConfig ();
1191   }
1192 }
1193
1194 bool KateViewConfig::dynWordWrap () const
1195 {
1196   if (m_dynWordWrapSet || isGlobal())
1197     return m_dynWordWrap;
1198
1199   return s_global->dynWordWrap();
1200 }
1201
1202 void KateViewConfig::setDynWordWrap (bool wrap)
1203 {
1204   configStart ();
1205
1206   m_dynWordWrapSet = true;
1207   m_dynWordWrap = wrap;
1208
1209   configEnd ();
1210 }
1211
1212 int KateViewConfig::dynWordWrapIndicators () const
1213 {
1214   if (m_dynWordWrapIndicatorsSet || isGlobal())
1215     return m_dynWordWrapIndicators;
1216
1217   return s_global->dynWordWrapIndicators();
1218 }
1219
1220 void KateViewConfig::setDynWordWrapIndicators (int mode)
1221 {
1222   configStart ();
1223
1224   m_dynWordWrapIndicatorsSet = true;
1225   m_dynWordWrapIndicators = qBound(0, mode, 80);
1226
1227   configEnd ();
1228 }
1229
1230 int KateViewConfig::dynWordWrapAlignIndent () const
1231 {
1232   if (m_dynWordWrapAlignIndentSet || isGlobal())
1233     return m_dynWordWrapAlignIndent;
1234
1235   return s_global->dynWordWrapAlignIndent();
1236 }
1237
1238 void KateViewConfig::setDynWordWrapAlignIndent (int indent)
1239 {
1240   configStart ();
1241
1242   m_dynWordWrapAlignIndentSet = true;
1243   m_dynWordWrapAlignIndent = indent;
1244
1245   configEnd ();
1246 }
1247
1248 bool KateViewConfig::lineNumbers () const
1249 {
1250   if (m_lineNumbersSet || isGlobal())
1251     return m_lineNumbers;
1252
1253   return s_global->lineNumbers();
1254 }
1255
1256 void KateViewConfig::setLineNumbers (bool on)
1257 {
1258   configStart ();
1259
1260   m_lineNumbersSet = true;
1261   m_lineNumbers = on;
1262
1263   configEnd ();
1264 }
1265
1266 bool KateViewConfig::scrollBarMarks () const
1267 {
1268   if (m_scrollBarMarksSet || isGlobal())
1269     return m_scrollBarMarks;
1270
1271   return s_global->scrollBarMarks();
1272 }
1273
1274 void KateViewConfig::setScrollBarMarks (bool on)
1275 {
1276   configStart ();
1277
1278   m_scrollBarMarksSet = true;
1279   m_scrollBarMarks = on;
1280
1281   configEnd ();
1282 }
1283
1284 bool KateViewConfig::iconBar () const
1285 {
1286   if (m_iconBarSet || isGlobal())
1287     return m_iconBar;
1288
1289   return s_global->iconBar();
1290 }
1291
1292 void KateViewConfig::setIconBar (bool on)
1293 {
1294   configStart ();
1295
1296   m_iconBarSet = true;
1297   m_iconBar = on;
1298
1299   configEnd ();
1300 }
1301
1302 bool KateViewConfig::foldingBar () const
1303 {
1304   if (m_foldingBarSet || isGlobal())
1305     return m_foldingBar;
1306
1307   return s_global->foldingBar();
1308 }
1309
1310 void KateViewConfig::setFoldingBar (bool on)
1311 {
1312   configStart ();
1313
1314   m_foldingBarSet = true;
1315   m_foldingBar = on;
1316
1317   configEnd ();
1318 }
1319
1320 int KateViewConfig::bookmarkSort () const
1321 {
1322   if (m_bookmarkSortSet || isGlobal())
1323     return m_bookmarkSort;
1324
1325   return s_global->bookmarkSort();
1326 }
1327
1328 void KateViewConfig::setBookmarkSort (int mode)
1329 {
1330   configStart ();
1331
1332   m_bookmarkSortSet = true;
1333   m_bookmarkSort = mode;
1334
1335   configEnd ();
1336 }
1337
1338 int KateViewConfig::autoCenterLines () const
1339 {
1340   if (m_autoCenterLinesSet || isGlobal())
1341     return m_autoCenterLines;
1342
1343   return s_global->autoCenterLines();
1344 }
1345
1346 void KateViewConfig::setAutoCenterLines (int lines)
1347 {
1348   if (lines < 0)
1349     return;
1350
1351   configStart ();
1352
1353   m_autoCenterLinesSet = true;
1354   m_autoCenterLines = lines;
1355
1356   configEnd ();
1357 }
1358
1359 long KateViewConfig::searchFlags () const
1360 {
1361   if (m_searchFlagsSet || isGlobal())
1362     return m_searchFlags;
1363
1364   return s_global->searchFlags();
1365 }
1366
1367 void KateViewConfig::setSearchFlags (long flags)
1368  {
1369   configStart ();
1370
1371   m_searchFlagsSet = true;
1372   m_searchFlags = flags;
1373
1374   configEnd ();
1375 }
1376
1377 QStringListModel *KateViewConfig::patternHistoryModel()
1378 {
1379   return &m_patternHistoryModel;
1380 }
1381
1382 int KateViewConfig::maxHistorySize() const
1383 {
1384   return m_maxHistorySize;
1385 }
1386
1387 QStringListModel *KateViewConfig::replacementHistoryModel()
1388 {
1389   return &m_replacementHistoryModel;
1390 }
1391
1392 uint KateViewConfig::defaultMarkType () const
1393 {
1394   if (m_defaultMarkTypeSet || isGlobal())
1395     return m_defaultMarkType;
1396
1397   return s_global->defaultMarkType();
1398 }
1399
1400 void KateViewConfig::setDefaultMarkType (uint type)
1401 {
1402   configStart ();
1403
1404   m_defaultMarkTypeSet = true;
1405   m_defaultMarkType = type;
1406
1407   configEnd ();
1408 }
1409
1410 bool KateViewConfig::persistentSelection () const
1411 {
1412   if (m_persistentSelectionSet || isGlobal())
1413     return m_persistentSelection;
1414
1415   return s_global->persistentSelection();
1416 }
1417
1418 void KateViewConfig::setPersistentSelection (bool on)
1419 {
1420   configStart ();
1421
1422   m_persistentSelectionSet = true;
1423   m_persistentSelection = on;
1424
1425   configEnd ();
1426 }
1427
1428 bool KateViewConfig::viInputMode () const
1429 {
1430   if (m_viInputModeSet || isGlobal())
1431     return m_viInputMode;
1432
1433   return s_global->viInputMode();
1434 }
1435
1436 void KateViewConfig::setViInputMode (bool on)
1437 {
1438   configStart ();
1439
1440   m_viInputModeSet = true;
1441   m_viInputMode = on;
1442
1443   // update all views and show/hide the status bar
1444   foreach (KateView* view, KateGlobal::self()->views() ) {
1445     if (on && !m_viInputModeHideStatusBar) {
1446       view->showViModeBar();
1447     } else {
1448       view->hideViModeBar();
1449     }
1450   }
1451
1452   // make sure to turn off edits mergin when leaving vi input mode
1453   if (!on && m_view) {
1454     m_view->doc()->setUndoMergeAllEdits(false);
1455   }
1456
1457   configEnd ();
1458 }
1459
1460 bool KateViewConfig::viInputModeStealKeys () const
1461 {
1462   if (m_viInputModeStealKeysSet || isGlobal())
1463     return m_viInputModeStealKeys;
1464
1465   return s_global->viInputModeStealKeys();
1466 }
1467
1468 void KateViewConfig::setViInputModeStealKeys (bool on)
1469 {
1470   configStart ();
1471
1472   m_viInputModeStealKeysSet = true;
1473   m_viInputModeStealKeys = on;
1474
1475   configEnd ();
1476 }
1477
1478 bool KateViewConfig::viInputModeHideStatusBar () const
1479 {
1480   if (m_viInputModeHideStatusBarSet || isGlobal())
1481     return m_viInputModeHideStatusBar;
1482
1483   return s_global->viInputModeHideStatusBar();
1484 }
1485
1486 void KateViewConfig::setViInputModeHideStatusBar (bool on)
1487 {
1488   configStart ();
1489
1490   m_viInputModeHideStatusBarSet = true;
1491   m_viInputModeHideStatusBar = on;
1492
1493   // update all views and show/hide the status bar
1494   foreach (KateView* view, KateGlobal::self()->views() ) {
1495     if (on && m_viInputMode) {
1496       view->hideViModeBar();
1497     } else if (viInputMode()) {
1498       view->showViModeBar();
1499     }
1500   }
1501
1502   configEnd ();
1503 }
1504
1505
1506 bool KateViewConfig::automaticCompletionInvocation () const
1507 {
1508   if (m_automaticCompletionInvocationSet || isGlobal())
1509     return m_automaticCompletionInvocation;
1510
1511   return s_global->automaticCompletionInvocation();
1512 }
1513
1514 void KateViewConfig::setAutomaticCompletionInvocation (bool on)
1515 {
1516   configStart ();
1517
1518   m_automaticCompletionInvocationSet = true;
1519   m_automaticCompletionInvocation = on;
1520
1521   configEnd ();
1522 }
1523
1524 bool KateViewConfig::wordCompletion () const
1525 {
1526   if (m_wordCompletionSet || isGlobal())
1527     return m_wordCompletion;
1528
1529   return s_global->wordCompletion();
1530 }
1531
1532 void KateViewConfig::setWordCompletion (bool on)
1533 {
1534   configStart ();
1535
1536   m_wordCompletionSet = true;
1537   m_wordCompletion = on;
1538
1539   configEnd ();
1540 }
1541
1542 int KateViewConfig::wordCompletionMinimalWordLength () const
1543 {
1544   if (m_wordCompletionMinimalWordLengthSet || isGlobal())
1545     return m_wordCompletionMinimalWordLength;
1546
1547   return s_global->wordCompletionMinimalWordLength();
1548 }
1549
1550 void KateViewConfig::setWordCompletionMinimalWordLength (int length)
1551 {
1552   configStart ();
1553
1554   m_wordCompletionMinimalWordLengthSet = true;
1555   m_wordCompletionMinimalWordLength = length;
1556
1557   configEnd ();
1558 }
1559
1560 bool KateViewConfig::smartCopyCut () const
1561 {
1562   if (m_smartCopyCutSet || isGlobal())
1563      return m_smartCopyCut;
1564
1565   return s_global->smartCopyCut();
1566 }
1567
1568 void KateViewConfig::setSmartCopyCut (bool on)
1569 {
1570   configStart ();
1571
1572   m_smartCopyCutSet = true;
1573   m_smartCopyCut = on;
1574
1575   configEnd ();
1576 }
1577
1578 bool KateViewConfig::scrollPastEnd () const
1579 {
1580   if (m_scrollPastEndSet || isGlobal())
1581     return m_scrollPastEnd;
1582
1583   return s_global->scrollPastEnd();
1584 }
1585
1586 void KateViewConfig::setScrollPastEnd (bool on)
1587 {
1588   configStart ();
1589
1590   m_scrollPastEndSet = true;
1591   m_scrollPastEnd = on;
1592
1593   configEnd ();
1594 }
1595
1596 //END
1597
1598 //BEGIN KateRendererConfig
1599 KateRendererConfig::KateRendererConfig ()
1600  : m_fontMetrics(QFont()),
1601    m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
1602    m_schemaSet (true),
1603    m_fontSet (true),
1604    m_wordWrapMarkerSet (true),
1605    m_showIndentationLinesSet (true),
1606    m_showWholeBracketExpressionSet (true),
1607    m_backgroundColorSet (true),
1608    m_selectionColorSet (true),
1609    m_highlightedLineColorSet (true),
1610    m_highlightedBracketColorSet (true),
1611    m_wordWrapMarkerColorSet (true),
1612    m_tabMarkerColorSet(true),
1613    m_iconBarColorSet (true),
1614    m_lineNumberColorSet (true),
1615    m_spellingMistakeLineColorSet (true),
1616    m_templateColorsSet(true),
1617    m_lineMarkerColorSet (m_lineMarkerColor.size()),
1618    m_renderer (0)
1619 {
1620   // init bitarray
1621   m_lineMarkerColorSet.fill (true);
1622
1623   s_global = this;
1624
1625   // init with defaults from config or really hardcoded ones
1626   KConfigGroup config(KGlobal::config(), "Kate Renderer Defaults");
1627   readConfig (config);
1628 }
1629
1630 KateRendererConfig::KateRendererConfig (KateRenderer *renderer)
1631  : m_fontMetrics(QFont()),
1632    m_lineMarkerColor (KTextEditor::MarkInterface::reservedMarkersCount()),
1633    m_schemaSet (false),
1634    m_fontSet (false),
1635    m_wordWrapMarkerSet (false),
1636    m_showIndentationLinesSet (false),
1637    m_showWholeBracketExpressionSet (false),
1638    m_backgroundColorSet (false),
1639    m_selectionColorSet (false),
1640    m_highlightedLineColorSet (false),
1641    m_highlightedBracketColorSet (false),
1642    m_wordWrapMarkerColorSet (false),
1643    m_tabMarkerColorSet(false),
1644    m_iconBarColorSet (false),
1645    m_lineNumberColorSet (false),
1646    m_spellingMistakeLineColorSet (false),
1647    m_templateColorsSet(false),
1648    m_lineMarkerColorSet (m_lineMarkerColor.size()),
1649    m_renderer (renderer)
1650 {
1651   // init bitarray
1652   m_lineMarkerColorSet.fill (false);
1653 }
1654
1655 KateRendererConfig::~KateRendererConfig ()
1656 {
1657 }
1658
1659 void KateRendererConfig::readConfig (const KConfigGroup &config)
1660 {
1661   configStart ();
1662
1663   setSchema (config.readEntry("Schema", KateSchemaManager::normalSchema()));
1664
1665   setWordWrapMarker (config.readEntry("Word Wrap Marker", false ));
1666
1667   setShowIndentationLines (config.readEntry( "Show Indentation Lines", false));
1668
1669   setShowWholeBracketExpression (config.readEntry( "Show Whole Bracket Expression", false));
1670
1671   configEnd ();
1672 }
1673
1674 void KateRendererConfig::writeConfig (KConfigGroup& config)
1675 {
1676   config.writeEntry ("Schema", schema());
1677
1678   config.writeEntry("Word Wrap Marker", wordWrapMarker() );
1679
1680   config.writeEntry("Show Indentation Lines", showIndentationLines());
1681
1682   config.writeEntry("Show Whole Bracket Expression", showWholeBracketExpression());
1683 }
1684
1685 void KateRendererConfig::updateConfig ()
1686 {
1687   if (m_renderer)
1688   {
1689     m_renderer->updateConfig ();
1690     return;
1691   }
1692
1693   if (isGlobal())
1694   {
1695     for (int z=0; z < KateGlobal::self()->views().size(); ++z)
1696       (KateGlobal::self()->views())[z]->renderer()->updateConfig ();
1697   }
1698 }
1699
1700 const QString &KateRendererConfig::schema () const
1701 {
1702   if (m_schemaSet || isGlobal())
1703     return m_schema;
1704
1705   return s_global->schema();
1706 }
1707
1708 void KateRendererConfig::setSchema (const QString &schema)
1709 {
1710   configStart ();
1711   m_schemaSet = true;
1712   m_schema = schema;
1713   setSchemaInternal( schema );
1714   configEnd ();
1715 }
1716
1717 void KateRendererConfig::reloadSchema()
1718 {
1719   if ( isGlobal() )
1720     foreach (KateView* view, KateGlobal::self()->views() )
1721       view->renderer()->config()->reloadSchema();
1722
1723   else if ( m_renderer && m_schemaSet )
1724     setSchemaInternal( m_schema );
1725 }
1726
1727 void KateRendererConfig::setSchemaInternal( const QString &schema )
1728 {
1729   m_schemaSet = true;
1730   m_schema = schema;
1731
1732   KConfigGroup config = KateGlobal::self()->schemaManager()->schema(KateGlobal::self()->schemaManager()->number(schema));
1733
1734   // NOTE keep in sync with KateSchemaConfigColorTab::schemaChanged
1735   KColorScheme schemeView(QPalette::Active, KColorScheme::View);
1736   KColorScheme schemeWindow(QPalette::Active, KColorScheme::Window);
1737   KColorScheme schemeSelection(QPalette::Active, KColorScheme::Selection);
1738   KColorScheme schemeTooltip(QPalette::Active, KColorScheme::Tooltip);
1739   QColor tmp0( schemeView.background().color() );
1740   QColor tmp1( schemeSelection.background().color() );
1741   QColor tmp2( schemeView.background(KColorScheme::AlternateBackground).color() );
1742   // using KColorUtils::shade wasn't working really well
1743   qreal bgLuma = KColorUtils::luma( tmp0 );
1744   QColor tmp3( KColorUtils::tint(tmp0, schemeView.decoration(KColorScheme::HoverColor).color()) );
1745   QColor tmp4( KColorUtils::shade( tmp0, bgLuma > 0.3 ? -0.15 : 0.03 ) );
1746   QColor tmp5( KColorUtils::shade( tmp0, bgLuma > 0.7 ? -0.35 : 0.3 ) );
1747   QColor tmp6( schemeWindow.background().color() );
1748   QColor tmp7( schemeWindow.foreground().color() );
1749   QColor tmp8( schemeView.foreground(KColorScheme::NegativeText).color() );
1750
1751   m_backgroundColor = config.readEntry("Color Background", tmp0);
1752   m_backgroundColorSet = true;
1753   m_selectionColor = config.readEntry("Color Selection", tmp1);
1754   m_selectionColorSet = true;
1755   m_highlightedLineColor  = config.readEntry("Color Highlighted Line", tmp2);
1756   m_highlightedLineColorSet = true;
1757   m_highlightedBracketColor = config.readEntry("Color Highlighted Bracket", tmp3);
1758   m_highlightedBracketColorSet = true;
1759   m_wordWrapMarkerColor = config.readEntry("Color Word Wrap Marker", tmp4);
1760   m_wordWrapMarkerColorSet = true;
1761   m_tabMarkerColor = config.readEntry("Color Tab Marker", tmp5);
1762   m_tabMarkerColorSet = true;
1763   m_iconBarColor  = config.readEntry("Color Icon Bar", tmp6);
1764   m_iconBarColorSet = true;
1765   m_lineNumberColor = config.readEntry("Color Line Number", tmp7);
1766   m_lineNumberColorSet = true;
1767   m_spellingMistakeLineColor = config.readEntry("Color Spelling Mistake Line", tmp8);
1768   m_spellingMistakeLineColorSet = true;
1769
1770     // same std colors like in KateDocument::markColor
1771   QColor mark[7];
1772   mark[0] = Qt::blue;
1773   mark[1] = Qt::red;
1774   mark[2] = Qt::yellow;
1775   mark[3] = Qt::magenta;
1776   mark[4] = Qt::gray;
1777   mark[5] = Qt::green;
1778   mark[6] = Qt::red;
1779
1780   for (int i = 1; i <= KTextEditor::MarkInterface::reservedMarkersCount(); i++) {
1781     QColor col = config.readEntry(QString("Color MarkType%1").arg(i), mark[i - 1]);
1782     int index = i-1;
1783     m_lineMarkerColorSet[index] = true;
1784     m_lineMarkerColor[index] = col;
1785   }
1786
1787   QFont f (KGlobalSettings::fixedFont());
1788
1789   m_font = config.readEntry("Font", f);
1790   m_fontMetrics = QFontMetrics(m_font);
1791   m_fontSet = true;
1792
1793   m_templateBackgroundColor=config.readEntry(QString("Color Template Background"),
1794                                              schemeTooltip.background(KColorScheme::NormalBackground).color());
1795
1796   m_templateEditablePlaceholderColor = config.readEntry(QString("Color Template Editable Placeholder"),
1797                                                         schemeTooltip.background(KColorScheme::NeutralBackground).color());
1798
1799   m_templateFocusedEditablePlaceholderColor=config.readEntry(QString("Color Template Focused Editable Placeholder"),
1800                                                              schemeTooltip.background(KColorScheme::PositiveBackground).color());
1801
1802   m_templateNotEditablePlaceholderColor=config.readEntry(QString("Color Template Not Editable Placeholder"),
1803                                                          schemeTooltip.background(KColorScheme::NegativeBackground).color());
1804
1805   m_templateColorsSet=true;
1806 }
1807
1808 const QFont& KateRendererConfig::font() const
1809 {
1810   if (m_fontSet || isGlobal())
1811     return m_font;
1812
1813   return s_global->font();
1814 }
1815
1816 const QFontMetrics& KateRendererConfig::fontMetrics() const
1817 {
1818   if (m_fontSet || isGlobal())
1819     return m_fontMetrics;
1820
1821   return s_global->fontMetrics();
1822 }
1823
1824 void KateRendererConfig::setFont(const QFont &font)
1825 {
1826   configStart ();
1827
1828   m_fontSet = true;
1829   m_font = font;
1830   m_fontMetrics = QFontMetrics(m_font);
1831
1832   configEnd ();
1833 }
1834
1835 bool KateRendererConfig::wordWrapMarker () const
1836 {
1837   if (m_wordWrapMarkerSet || isGlobal())
1838     return m_wordWrapMarker;
1839
1840   return s_global->wordWrapMarker();
1841 }
1842
1843 void KateRendererConfig::setWordWrapMarker (bool on)
1844 {
1845   configStart ();
1846
1847   m_wordWrapMarkerSet = true;
1848   m_wordWrapMarker = on;
1849
1850   configEnd ();
1851 }
1852
1853 const QColor& KateRendererConfig::backgroundColor() const
1854 {
1855   if (m_backgroundColorSet || isGlobal())
1856     return m_backgroundColor;
1857
1858   return s_global->backgroundColor();
1859 }
1860
1861 void KateRendererConfig::setBackgroundColor (const QColor &col)
1862 {
1863   configStart ();
1864
1865   m_backgroundColorSet = true;
1866   m_backgroundColor = col;
1867
1868   configEnd ();
1869 }
1870
1871 const QColor& KateRendererConfig::selectionColor() const
1872 {
1873   if (m_selectionColorSet || isGlobal())
1874     return m_selectionColor;
1875
1876   return s_global->selectionColor();
1877 }
1878
1879 void KateRendererConfig::setSelectionColor (const QColor &col)
1880 {
1881   configStart ();
1882
1883   m_selectionColorSet = true;
1884   m_selectionColor = col;
1885
1886   configEnd ();
1887 }
1888
1889 const QColor& KateRendererConfig::highlightedLineColor() const
1890 {
1891   if (m_highlightedLineColorSet || isGlobal())
1892     return m_highlightedLineColor;
1893
1894   return s_global->highlightedLineColor();
1895 }
1896
1897 void KateRendererConfig::setHighlightedLineColor (const QColor &col)
1898 {
1899   configStart ();
1900
1901   m_highlightedLineColorSet = true;
1902   m_highlightedLineColor = col;
1903
1904   configEnd ();
1905 }
1906
1907 const QColor& KateRendererConfig::lineMarkerColor(KTextEditor::MarkInterface::MarkTypes type) const
1908 {
1909   int index = 0;
1910   if (type > 0) { while((type >> index++) ^ 1) {} }
1911   index -= 1;
1912
1913   if ( index < 0 || index >= KTextEditor::MarkInterface::reservedMarkersCount() )
1914   {
1915     static QColor dummy;
1916     return dummy;
1917   }
1918
1919   if (m_lineMarkerColorSet[index] || isGlobal())
1920     return m_lineMarkerColor[index];
1921
1922   return s_global->lineMarkerColor( type );
1923 }
1924
1925 void KateRendererConfig::setLineMarkerColor (const QColor &col, KTextEditor::MarkInterface::MarkTypes type)
1926 {
1927   int index = static_cast<int>( log(static_cast<double>(type)) / log(2.0) );
1928   Q_ASSERT( index >= 0 && index < KTextEditor::MarkInterface::reservedMarkersCount() );
1929   configStart ();
1930
1931   m_lineMarkerColorSet[index] = true;
1932   m_lineMarkerColor[index] = col;
1933
1934   configEnd ();
1935 }
1936
1937 const QColor& KateRendererConfig::highlightedBracketColor() const
1938 {
1939   if (m_highlightedBracketColorSet || isGlobal())
1940     return m_highlightedBracketColor;
1941
1942   return s_global->highlightedBracketColor();
1943 }
1944
1945 void KateRendererConfig::setHighlightedBracketColor (const QColor &col)
1946 {
1947   configStart ();
1948
1949   m_highlightedBracketColorSet = true;
1950   m_highlightedBracketColor = col;
1951
1952   configEnd ();
1953 }
1954
1955 const QColor& KateRendererConfig::wordWrapMarkerColor() const
1956 {
1957   if (m_wordWrapMarkerColorSet || isGlobal())
1958     return m_wordWrapMarkerColor;
1959
1960   return s_global->wordWrapMarkerColor();
1961 }
1962
1963 void KateRendererConfig::setWordWrapMarkerColor (const QColor &col)
1964 {
1965   configStart ();
1966
1967   m_wordWrapMarkerColorSet = true;
1968   m_wordWrapMarkerColor = col;
1969
1970   configEnd ();
1971 }
1972
1973 const QColor& KateRendererConfig::tabMarkerColor() const
1974 {
1975   if (m_tabMarkerColorSet || isGlobal())
1976     return m_tabMarkerColor;
1977
1978   return s_global->tabMarkerColor();
1979 }
1980
1981 void KateRendererConfig::setTabMarkerColor (const QColor &col)
1982 {
1983   configStart ();
1984
1985   m_tabMarkerColorSet = true;
1986   m_tabMarkerColor = col;
1987
1988   configEnd ();
1989 }
1990
1991 const QColor& KateRendererConfig::iconBarColor() const
1992 {
1993   if (m_iconBarColorSet || isGlobal())
1994     return m_iconBarColor;
1995
1996   return s_global->iconBarColor();
1997 }
1998
1999 void KateRendererConfig::setIconBarColor (const QColor &col)
2000 {
2001   configStart ();
2002
2003   m_iconBarColorSet = true;
2004   m_iconBarColor = col;
2005
2006   configEnd ();
2007 }
2008
2009
2010 const QColor &KateRendererConfig::templateBackgroundColor() const {
2011   if (m_templateColorsSet || isGlobal())
2012     return m_templateBackgroundColor;
2013
2014   return s_global->templateBackgroundColor();
2015 }
2016 const QColor &KateRendererConfig::templateEditablePlaceholderColor() const {
2017   if (m_templateColorsSet || isGlobal())
2018     return m_templateEditablePlaceholderColor;
2019
2020   return s_global->templateEditablePlaceholderColor();
2021 }
2022 const QColor &KateRendererConfig::templateFocusedEditablePlaceholderColor() const {
2023   if (m_templateColorsSet || isGlobal())
2024     return m_templateFocusedEditablePlaceholderColor;
2025
2026   return s_global->templateFocusedEditablePlaceholderColor();
2027 }
2028 const QColor &KateRendererConfig::templateNotEditablePlaceholderColor() const {
2029   if (m_templateColorsSet || isGlobal())
2030     return m_templateNotEditablePlaceholderColor;
2031
2032   return s_global->templateNotEditablePlaceholderColor();
2033 }
2034
2035
2036 const QColor& KateRendererConfig::lineNumberColor() const
2037 {
2038   if (m_lineNumberColorSet || isGlobal())
2039     return m_lineNumberColor;
2040
2041   return s_global->lineNumberColor();
2042 }
2043
2044 void KateRendererConfig::setLineNumberColor (const QColor &col)
2045 {
2046   configStart ();
2047
2048   m_lineNumberColorSet = true;
2049   m_lineNumberColor = col;
2050
2051   configEnd ();
2052 }
2053
2054 const QColor& KateRendererConfig::spellingMistakeLineColor() const
2055 {
2056   if (m_spellingMistakeLineColorSet || isGlobal())
2057     return m_spellingMistakeLineColor;
2058
2059   return s_global->spellingMistakeLineColor();
2060 }
2061
2062 void KateRendererConfig::setSpellingMistakeKineColor (const QColor &col)
2063 {
2064   configStart ();
2065
2066   m_spellingMistakeLineColorSet = true;
2067   m_spellingMistakeLineColor = col;
2068
2069   configEnd ();
2070 }
2071
2072 bool KateRendererConfig::showIndentationLines () const
2073 {
2074   if (m_showIndentationLinesSet || isGlobal())
2075     return m_showIndentationLines;
2076
2077   return s_global->showIndentationLines();
2078 }
2079
2080 void KateRendererConfig::setShowIndentationLines (bool on)
2081 {
2082   configStart ();
2083
2084   m_showIndentationLinesSet = true;
2085   m_showIndentationLines = on;
2086
2087   configEnd ();
2088 }
2089
2090 bool KateRendererConfig::showWholeBracketExpression () const
2091 {
2092   if (m_showWholeBracketExpressionSet || isGlobal())
2093     return m_showWholeBracketExpression;
2094
2095   return s_global->showWholeBracketExpression();
2096 }
2097
2098 void KateRendererConfig::setShowWholeBracketExpression (bool on)
2099 {
2100   configStart ();
2101
2102   m_showWholeBracketExpressionSet = true;
2103   m_showWholeBracketExpression = on;
2104
2105   configEnd ();
2106 }
2107
2108 //END
2109
2110 // kate: space-indent on; indent-width 2; replace-tabs on;