Few modifs for Xpad->SciNotes
[scilab.git] / scilab / modules / scinotes / src / java / org / scilab / modules / scinotes / utils / ConfigSciNotesManager.java
1 /*
2  * Scilab (http://www.scilab.org/) - This file is part of Scilab
3  * Copyright (C) 2009 - INRIA - Allan SIMON
4  * Copyright (C) 2010 - Calixte DENIZET
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 package org.scilab.modules.scinotes.utils;
15
16 import java.awt.Color;
17 import java.awt.Font;
18 import java.awt.Toolkit;
19
20 import java.io.File;
21 import java.io.FileInputStream;
22 import java.io.FileNotFoundException;
23 import java.io.FileOutputStream;
24 import java.io.IOException;
25 import java.nio.charset.Charset;
26 import java.util.ArrayList;
27 import java.util.List;
28 import java.util.Hashtable;
29 import java.util.Properties;
30 import java.util.Enumeration;
31 import java.util.Map;
32
33 import javax.xml.parsers.DocumentBuilder;
34 import javax.xml.parsers.DocumentBuilderFactory;
35 import javax.xml.parsers.ParserConfigurationException;
36 import javax.xml.transform.OutputKeys;
37 import javax.xml.transform.Transformer;
38 import javax.xml.transform.TransformerConfigurationException;
39 import javax.xml.transform.TransformerException;
40 import javax.xml.transform.TransformerFactory;
41 import javax.xml.transform.TransformerFactoryConfigurationError;
42 import javax.xml.transform.dom.DOMSource;
43 import javax.xml.transform.stream.StreamResult;
44
45 import javax.swing.KeyStroke;
46
47 import org.scilab.modules.console.GuiManagement;
48 import org.scilab.modules.gui.utils.Position;
49 import org.scilab.modules.gui.utils.Size;
50
51 import org.scilab.modules.scinotes.ScilabView;
52 import org.scilab.modules.scinotes.TabManager;
53 import org.scilab.modules.scinotes.MatchingBlockManager;
54
55 import org.w3c.dom.Document;
56 import org.w3c.dom.Element;
57 import org.w3c.dom.Node;
58 import org.w3c.dom.NodeList;
59 import org.xml.sax.SAXException;
60
61 /**
62  * Configuration class which interacts with the file etc/scinotesConfiguration.xml
63  */
64 public final class ConfigSciNotesManager {
65     private static final int BUFSIZE = 1024;
66
67     private static final int MARGIN = 20;
68
69     private static final String ERROR_READ = "Could not load file: ";
70     private static final String ERROR_WRITE = "Could not save file: ";
71     private static final String VALUE = "value";
72     private static final String STYLE = "style";
73     private static final String UNDERLINE = "underline";
74     private static final String DEFAULTUNDERLINE = "defaultUnderline";
75     private static final String STROKE = "stroke";
76     private static final String DEFAULTSTROKE = "defaultStroke";
77     private static final String FONT_SIZE = "FontSize";
78     private static final String FONT_STYLE = "FontStyle";
79     private static final String FONT_NAME = "FontName";
80     private static final String DEFAULT = "default";
81     private static final String WIDTH = "width";
82     private static final String HEIGHT = "height";
83     private static final String XCOORD = "x";
84     private static final String YCOORD = "y";
85     private static final String MAINWINPOSITION = "MainWindowPosition";
86     private static final String MAINWINSIZE = "MainWindowSize";
87     private static final String AUTOINDENT = "AutoIndent";
88     private static final String AUTOCOLORIZE = "AutoColorize";
89     private static final String DEFAULTENCONDING = "DefaultEncoding";
90     private static final String LINEHIGHLIGHTER = "LineHighlighter";
91     private static final String HELPONTYPING = "HelpOnTyping";
92     private static final String LINENUMBERING = "LineNumbering";
93     private static final String EDITOR = "SciNotes";
94
95     private static final String FOREGROUNDCOLOR = "ForegroundColor";
96     private static final String BACKGROUNDCOLOR = "BackgroundColor";
97     private static final String LINECOLOR = "linecolor";
98     private static final String CONTOURCOLOR = "contourcolor";
99     private static final String COLORPREFIX = "#";
100
101     private static final String NAME = "name";
102     private static final String NULL = "null";
103
104     private static final String PROFILE = "Profile";
105
106     private static String RECENT_SEARCH = "recentSearch";
107     private static String SEARCH = "search";
108     private static String RECENT_REPLACE = "recentReplace";
109     private static String REPLACE = "replace";
110     private static String EXPRESSION = "exp";
111     private static String REGULAR_EXPRESION = "regularExp";
112     private static String WORD_WARP = "wordWarp";
113     private static String WHOLE_WORD = "wholeWord";
114     private static String CASE_SENSITIVE = "caseSensitive";
115     private static String STATE_FLAG = "state";
116
117     private static String SETTING = "Setting";
118     private static String SCINOTES = "scinotes";
119     private static String TRUE = "true";
120     private static String FALSE = "false";
121     private static String DOCUMENT = "document";
122     private static String PATH = "path";
123     private static String RECENT_FILES = "recentFiles";
124
125     private static final String SCINOTES_CONFIG_FILE = System.getenv("SCI") + "/modules/scinotes/etc/scinotesConfiguration.xml";
126     private static final String SCINOTES_CONFIG_KEYS_FILE = System.getenv("SCI") + "/modules/scinotes/etc/keysConfiguration.xml";
127
128     private static final String USER_SCINOTES_CONFIG_FILE = GuiManagement.getSCIHOME() + "/scinotesConfiguration.xml";
129     private static final String USER_SCINOTES_CONFIG_KEYS_FILE = GuiManagement.getSCIHOME() + "/keysConfiguration.xml";
130
131     private static final int PLAIN = 0;
132     private static final int BOLD =  1;
133     private static final int ITALIC = 2;
134     private static final int BOLDITALIC = 3;
135
136     private static final int DEFAULT_WIDTH = 650;
137     private static final int DEFAULT_HEIGHT = 550;
138
139     private static final int MAX_RECENT_FILES = 10;
140     private static final int MAX_RECENT_SEARCH = 20;
141     private static final int MAX_RECENT_REPLACE = 20;
142
143     private static final String packActionName = "org.scilab.modules.scinotes.actions";
144
145     private static Document document;
146     private static Properties keysMap;
147
148     /**
149      * Constructor
150      */
151     private ConfigSciNotesManager() {
152         throw new UnsupportedOperationException();
153     }
154
155     /**
156      * Create a copy of Scilab configuration file in the user directory
157      */
158     public static void createUserCopy() {
159         File fileConfig = new File(USER_SCINOTES_CONFIG_FILE);
160         if (!fileConfig.exists() || (fileConfig.length() == 0)) {
161             /* Create a local copy of the configuration file */
162             copyFile(new File(SCINOTES_CONFIG_FILE), new File(USER_SCINOTES_CONFIG_FILE));
163         }
164         fileConfig = new File(USER_SCINOTES_CONFIG_KEYS_FILE);
165         if (!fileConfig.exists() || (fileConfig.length() == 0)) {
166             /* Create a local copy of the configuration file */
167             copyFile(new File(SCINOTES_CONFIG_KEYS_FILE), new File(USER_SCINOTES_CONFIG_KEYS_FILE));
168         }
169     }
170     /**
171      * Get the name of the user configuration file
172      * @return the name of the configuration file
173      */
174     public static String getUserConfigFile() {
175         return USER_SCINOTES_CONFIG_FILE;
176     }
177
178     /**
179      * Get all Style name
180      * @return a array list of all style name
181      */
182
183     public static List<String> getAllStyleName() {
184         List<String> stylesName = new ArrayList<String>();
185
186         readDocument();
187
188         Element root = document.getDocumentElement();
189         NodeList styles = root.getElementsByTagName(STYLE);
190
191         for (int i = 0; i < styles.getLength(); ++i) {
192             Element style = (Element) styles.item(i);
193
194             stylesName.add(style.getAttribute(NAME));
195
196
197         }
198         return stylesName;
199     }
200
201     /**
202      * Get the font name
203      * @return the name of the font
204      */
205     public static String getFontName() {
206
207         /*load file*/
208         readDocument();
209
210         Element root = document.getDocumentElement();
211
212         NodeList profiles = root.getElementsByTagName(PROFILE);
213         Element scinotesProfile = (Element) profiles.item(0);
214
215         NodeList fontNameElement = scinotesProfile.getElementsByTagName(FONT_NAME);
216         Element fontName = (Element) fontNameElement.item(0);
217         return fontName.getAttribute(VALUE);
218
219     }
220
221     /**
222      * Get the font size
223      * @return the font size
224      */
225     public static int getFontSize() {
226         /*load file*/
227         readDocument();
228
229         Element root = document.getDocumentElement();
230
231         NodeList profiles = root.getElementsByTagName(PROFILE);
232         Element scinotesProfile = (Element) profiles.item(0);
233
234         NodeList fontSizeElement = scinotesProfile.getElementsByTagName(FONT_SIZE);
235         Element fontSize = (Element) fontSizeElement.item(0);
236         return Integer.parseInt(fontSize.getAttribute(VALUE));
237     }
238
239     /**
240      * @return true if help on typing is active
241      */
242     public static boolean getHelpOnTypingState() {
243         readDocument();
244
245         Element root = document.getDocumentElement();
246
247         NodeList profiles = root.getElementsByTagName(PROFILE);
248         Element scinotesProfile = (Element) profiles.item(0);
249
250         NodeList allSizeElements = scinotesProfile.getElementsByTagName(HELPONTYPING);
251         Element helpontyping = (Element) allSizeElements.item(0);
252
253         return TRUE.equals(helpontyping.getAttribute(VALUE));
254     }
255
256     /**
257      * Save help on typing
258      * @param activated active or not
259      */
260     public static void saveHelpOnTypingState(boolean activated) {
261         readDocument();
262
263         Element root = document.getDocumentElement();
264
265         NodeList profiles = root.getElementsByTagName(PROFILE);
266         Element scinotesProfile = (Element) profiles.item(0);
267
268         NodeList allSizeElements = scinotesProfile.getElementsByTagName(HELPONTYPING);
269         Element helpOnTyping = (Element) allSizeElements.item(0);
270         if (helpOnTyping == null) {
271             Element help = document.createElement(HELPONTYPING);
272             helpOnTyping.setAttribute(VALUE, new Boolean(activated).toString());
273             helpOnTyping.appendChild((Node) help);
274         } else {
275             helpOnTyping.setAttribute(VALUE, new Boolean(activated).toString());
276         }
277         writeDocument();
278     }
279
280     /**
281      * @return the default state
282      */
283     public static int getLineNumberingState() {
284         readDocument();
285
286         Element root = document.getDocumentElement();
287
288         NodeList profiles = root.getElementsByTagName(PROFILE);
289         Element scinotesProfile = (Element) profiles.item(0);
290
291         NodeList allSizeElements = scinotesProfile.getElementsByTagName(LINENUMBERING);
292         Element lineNumbering = (Element) allSizeElements.item(0);
293
294         return Integer.parseInt(lineNumbering.getAttribute(VALUE));
295     }
296
297     /**
298      * Save line numbering state
299      * @param state the state
300      */
301     public static void saveLineNumberingState(int state) {
302         readDocument();
303
304         Element root = document.getDocumentElement();
305
306         NodeList profiles = root.getElementsByTagName(PROFILE);
307         Element scinotesProfile = (Element) profiles.item(0);
308
309         NodeList allSizeElements = scinotesProfile.getElementsByTagName(LINENUMBERING);
310         Element lineNumbering = (Element) allSizeElements.item(0);
311         if (lineNumbering == null) {
312             Element line = document.createElement(LINENUMBERING);
313             lineNumbering.setAttribute(VALUE, Integer.toString(state));
314             lineNumbering.appendChild((Node) line);
315         } else {
316             lineNumbering.setAttribute(VALUE, Integer.toString(state));
317         }
318         writeDocument();
319     }
320
321     /**
322      * @return true if highlighted line is active
323      */
324     public static boolean getHighlightState() {
325         readDocument();
326
327         Element root = document.getDocumentElement();
328
329         NodeList profiles = root.getElementsByTagName(PROFILE);
330         Element scinotesProfile = (Element) profiles.item(0);
331
332         NodeList allSizeElements = scinotesProfile.getElementsByTagName(LINEHIGHLIGHTER);
333         Element lineHighlight = (Element) allSizeElements.item(0);
334
335         return TRUE.equals(lineHighlight.getAttribute(VALUE));
336     }
337
338     /**
339      * Save highlight state
340      * @param state the state
341      */
342     public static void saveHighlightState(boolean state) {
343         readDocument();
344
345         Element root = document.getDocumentElement();
346
347         NodeList profiles = root.getElementsByTagName(PROFILE);
348         Element scinotesProfile = (Element) profiles.item(0);
349
350         NodeList allSizeElements = scinotesProfile.getElementsByTagName(LINEHIGHLIGHTER);
351         Element lineHighlighter = (Element) allSizeElements.item(0);
352         if (lineHighlighter == null) {
353             Element line = document.createElement(LINEHIGHLIGHTER);
354             lineHighlighter.setAttribute(VALUE, Boolean.toString(state));
355             lineHighlighter.appendChild((Node) line);
356         } else {
357             lineHighlighter.setAttribute(VALUE, Boolean.toString(state));
358         }
359         writeDocument();
360     }
361
362     /**
363      * @return the color for the highlight and for the contour of the highlight
364      */
365     public static Color[] getHighlightColors() {
366         readDocument();
367
368         Element root = document.getDocumentElement();
369
370         NodeList profiles = root.getElementsByTagName(PROFILE);
371         Element scinotesProfile = (Element) profiles.item(0);
372
373         NodeList allSizeElements = scinotesProfile.getElementsByTagName(LINEHIGHLIGHTER);
374         Element lineHighlight = (Element) allSizeElements.item(0);
375         Color[] arr = new Color[2];
376
377         Color c;
378         if (NULL.equals(lineHighlight.getAttribute(LINECOLOR))) {
379             c = null;
380         } else {
381             c = Color.decode(lineHighlight.getAttribute(LINECOLOR));
382         }
383
384         arr[0] = c;
385
386         if (NULL.equals(lineHighlight.getAttribute(CONTOURCOLOR))) {
387             c = null;
388         } else {
389             c = Color.decode(lineHighlight.getAttribute(CONTOURCOLOR));
390         }
391
392         arr[1] = c;
393         return arr;
394     }
395
396     /**
397      * Get all font style
398      * @return true if the font style is bold , false otherwise
399      */
400     public static Map<String, Boolean> getAllisBold() {
401         /*load file*/
402         readDocument();
403         Map<String, Boolean > stylesIsBoldTable = new Hashtable<String, Boolean>();
404
405         Element root = document.getDocumentElement();
406         NodeList styles = root.getElementsByTagName(STYLE);
407
408         for (int i = 0; i < styles.getLength(); ++i) {
409             Element style = (Element) styles.item(i);
410
411
412             NodeList fontStyleElement = style.getElementsByTagName(FONT_STYLE);
413             Element fontStyle = (Element) fontStyleElement.item(0);
414             int value = Integer.parseInt(fontStyle.getAttribute(VALUE));
415
416             if (value  == BOLD || value == BOLDITALIC) {
417                 stylesIsBoldTable.put(style.getAttribute(NAME), true);
418             } else {
419                 stylesIsBoldTable.put(style.getAttribute(NAME), false);
420             }
421         }
422         return stylesIsBoldTable;
423     }
424
425     /**
426      * Get all default font style
427      * @return true if the font style is bold , false otherwise
428      */
429     public static Map<String, Boolean> getDefaultAllisBold() {
430         /*load file*/
431         readDocument();
432         Map<String, Boolean > stylesIsBoldTable = new Hashtable<String, Boolean>();
433
434         Element root = document.getDocumentElement();
435         NodeList styles = root.getElementsByTagName(STYLE);
436
437         for (int i = 0; i < styles.getLength(); ++i) {
438             Element style = (Element) styles.item(i);
439
440
441             NodeList fontStyleElement = style.getElementsByTagName(FONT_STYLE);
442             Element fontStyle = (Element) fontStyleElement.item(0);
443             int value = Integer.parseInt(fontStyle.getAttribute(DEFAULT));
444
445             if (value  == BOLD || value == BOLDITALIC) {
446                 stylesIsBoldTable.put(style.getAttribute(NAME), true);
447             } else {
448                 stylesIsBoldTable.put(style.getAttribute(NAME), false);
449             }
450         }
451         return stylesIsBoldTable;
452     }
453
454     /**
455      * Get all font style
456      * @return true if the font style is bold , false otherwise
457      */
458     public static Map<String, Boolean> getAllisItalic() {
459         /*load file*/
460         readDocument();
461         Map<String, Boolean> stylesIsItalicTable = new Hashtable<String, Boolean>();
462
463         Element root = document.getDocumentElement();
464         NodeList styles = root.getElementsByTagName(STYLE);
465
466         for (int i = 0; i < styles.getLength(); ++i) {
467             Element style = (Element) styles.item(i);
468
469             NodeList fontStyleElement = style.getElementsByTagName(FONT_STYLE);
470             Element fontStyle = (Element) fontStyleElement.item(0);
471             int value = Integer.parseInt(fontStyle.getAttribute(VALUE));
472
473             if (value  == ITALIC || value == BOLDITALIC) {
474                 stylesIsItalicTable.put(style.getAttribute(NAME), true);
475             } else {
476                 stylesIsItalicTable.put(style.getAttribute(NAME), false);
477             }
478         }
479         return stylesIsItalicTable;
480     }
481
482     /**
483      * Get all default font style
484      * @return true if the font style is bold , false otherwise
485      */
486     public static Map<String, Boolean> getDefaultAllisItalic() {
487         /*load file*/
488         readDocument();
489         Map<String, Boolean> stylesIsItalicTable = new Hashtable<String, Boolean>();
490
491         Element root = document.getDocumentElement();
492         NodeList styles = root.getElementsByTagName(STYLE);
493
494         for (int i = 0; i < styles.getLength(); ++i) {
495             Element style = (Element) styles.item(i);
496
497             NodeList fontStyleElement = style.getElementsByTagName(FONT_STYLE);
498             Element fontStyle = (Element) fontStyleElement.item(0);
499             int value = Integer.parseInt(fontStyle.getAttribute(DEFAULT));
500
501             if (value  == ITALIC || value == BOLDITALIC) {
502                 stylesIsItalicTable.put(style.getAttribute(NAME), true);
503             } else {
504                 stylesIsItalicTable.put(style.getAttribute(NAME), false);
505             }
506         }
507         return stylesIsItalicTable;
508     }
509
510     /**
511      * Get the font setting
512      * @return the font
513      */
514     public static Font getFont() {
515
516         /*load file*/
517         readDocument();
518         Font font;
519         Element root = document.getDocumentElement();
520
521         NodeList profiles = root.getElementsByTagName(PROFILE);
522         Element scinotesProfile = (Element) profiles.item(0);
523
524         NodeList fontSizeElement = scinotesProfile.getElementsByTagName(FONT_SIZE);
525         Element fontSize = (Element) fontSizeElement.item(0);
526         int size = Integer.parseInt(fontSize.getAttribute(VALUE));
527
528         NodeList fontNameElement = scinotesProfile.getElementsByTagName(FONT_NAME);
529         Element fontName = (Element) fontNameElement.item(0);
530         String name = fontName.getAttribute(VALUE);
531
532         NodeList fontStyleElement = scinotesProfile.getElementsByTagName(FONT_STYLE);
533         Element fontStyle = (Element) fontStyleElement.item(0);
534         int style = Integer.parseInt(fontStyle.getAttribute(VALUE));
535
536         if (style == PLAIN) {
537             font = new Font(name, Font.PLAIN, size);
538
539         } else if (style == BOLD) {
540             font = new Font(name, Font.BOLD, size);
541
542         } else if (style == ITALIC) {
543             font = new Font(name, Font.ITALIC, size);
544
545         } else if (style == BOLDITALIC) {
546             font = new Font(name, Font.BOLD | Font.ITALIC , size);
547
548         } else {
549             font = new Font(name, Font.PLAIN, size);
550         }
551
552         return font;
553     }
554
555     /**
556      * Get Default Font Settings
557      * @return the default font
558      */
559
560     public static Font getDefaultFont() {
561         /*load file*/
562         readDocument();
563
564         Font font;
565         Element root = document.getDocumentElement();
566
567         NodeList profiles = root.getElementsByTagName(PROFILE);
568         Element scinotesProfile = (Element) profiles.item(0);
569
570         NodeList fontSizeElement = scinotesProfile.getElementsByTagName(FONT_SIZE);
571         Element fontSize = (Element) fontSizeElement.item(0);
572         int size = Integer.parseInt(fontSize.getAttribute(DEFAULT));
573
574         NodeList fontNameElement = scinotesProfile.getElementsByTagName(FONT_NAME);
575         Element fontName = (Element) fontNameElement.item(0);
576         String name = fontName.getAttribute(DEFAULT);
577
578         NodeList fontStyleElement = scinotesProfile.getElementsByTagName(FONT_STYLE);
579         Element fontStyle = (Element) fontStyleElement.item(0);
580         int style = Integer.parseInt(fontStyle.getAttribute(DEFAULT));
581
582         if (style == PLAIN) {
583             font = new Font(name, Font.PLAIN, size);
584
585         } else if (style == BOLD) {
586             font = new Font(name, Font.BOLD, size);
587
588         } else if (style == ITALIC) {
589             font = new Font(name, Font.ITALIC, size);
590
591         } else if (style == BOLDITALIC) {
592             font = new Font(name, Font.BOLD | Font.ITALIC , size);
593
594         } else {
595             font = new Font(name, Font.PLAIN, size);
596         }
597
598         return font;
599     }
600
601     /**
602      * Save a new font setting
603      * @param font the new font
604      */
605     public static void saveFont(Font font) {
606         readDocument();
607
608         Element root = document.getDocumentElement();
609
610         NodeList profiles = root.getElementsByTagName(PROFILE);
611         Element scinotesProfile = (Element) profiles.item(0);
612
613         NodeList fontSizeElement = scinotesProfile.getElementsByTagName(FONT_SIZE);
614         Element fontSize = (Element) fontSizeElement.item(0);
615         fontSize.setAttribute(VALUE, Integer.toString(font.getSize()));
616
617         NodeList fontNameElement = scinotesProfile.getElementsByTagName(FONT_NAME);
618         Element fontName = (Element) fontNameElement.item(0);
619         fontName.setAttribute(VALUE, font.getFontName());
620
621         NodeList fontStyleElement = scinotesProfile.getElementsByTagName(FONT_STYLE);
622         Element fontStyle = (Element) fontStyleElement.item(0);
623
624         if (!font.isBold() && !font.isItalic()) {
625             fontStyle.setAttribute(VALUE, "0");
626         } else if (font.isBold() && font.isItalic()) {
627             fontStyle.setAttribute(VALUE, "3");
628         } else if (font.isBold()) {
629             fontStyle.setAttribute(VALUE, "1");
630         } else {
631             fontStyle.setAttribute(VALUE, "2");
632         }
633
634         /* Save changes */
635         writeDocument();
636     }
637
638     /**
639      * Copy a file
640      * @param in src file
641      * @param out dest file
642      */
643     private static void copyFile(File in, File out) {
644         FileInputStream fis = null;
645         try {
646             fis = new FileInputStream(in);
647         } catch (FileNotFoundException e) {
648             e.printStackTrace();
649         }
650         FileOutputStream fos = null;
651         try {
652             fos = new FileOutputStream(out);
653         } catch (FileNotFoundException e) {
654             e.printStackTrace();
655         }
656         byte[] buf = new byte[BUFSIZE];
657         int i = 0;
658         try {
659             while ((i = fis.read(buf)) != -1) {
660                 fos.write(buf, 0, i);
661             }
662             fis.close();
663             fos.close();
664         } catch (IOException e) {
665             e.printStackTrace();
666         }
667     }
668
669     /**
670      * Retrieve from scinotesConfiguration.xml the infos about a tabulation
671      * @return a Tabulation containing infos
672      */
673     public static TabManager.Tabulation getDefaultTabulation() {
674         /* <style name="Tabulation" rep="vertical" value="4" white="false"> */
675         readDocument();
676
677         Element root = document.getDocumentElement();
678         NodeList styles = root.getElementsByTagName(STYLE);
679
680         for (int i = 0; i < styles.getLength(); ++i) {
681             Element style = (Element) styles.item(i);
682             if ("Tabulation".equals(style.getAttribute(NAME))) {
683                 String rep = style.getAttribute("rep").toLowerCase();
684                 int type = ScilabView.TABNOTHING;
685                 char rrep = ' ';
686                 if ("vertical".equals(rep)) {
687                     type = ScilabView.TABVERTICAL;
688                 } else if ("horizontal".equals(rep)) {
689                     type = ScilabView.TABHORIZONTAL;
690                 } else if ("doublechevrons".equals(rep)) {
691                     type = ScilabView.TABDOUBLECHEVRONS;
692                 } else if ("none".equals(rep)) {
693                     type = ScilabView.TABNOTHING;
694                 } else if (rep.length() >= 1) {
695                     type = ScilabView.TABCHARACTER;
696                     rrep = rep.charAt(0);
697                 }
698
699                 char one;
700                 int value = Integer.parseInt(style.getAttribute(VALUE));
701                 String white = style.getAttribute("white").toLowerCase();
702                 if (FALSE.equals(white)) {
703                     one = '\t';
704                 } else {
705                     one = ' ';
706                 }
707
708                 return new TabManager.Tabulation(one, value, type, rrep);
709             }
710         }
711         return null;
712     }
713
714     /**
715      * Retrieve form scinotesConfiguration.xml the infos the matchers
716      * @param kind should be "KeywordsHighlighter" or "OpenCloseHighlighter"
717      * @return an Object containing infos
718      */
719     public static MatchingBlockManager.Parameters getDefaultForMatcher(String kind) {
720         /* <KeywordsHighlighter color="#fff3d2" inside=TRUE type="filled"/> */
721
722         readDocument();
723
724         Element root = document.getDocumentElement();
725         NodeList matching = root.getElementsByTagName("Matching");
726         Element elem = (Element) matching.item(0);
727         boolean onmouseover = TRUE.equals(elem.getAttribute("onmouseover"));
728
729         NodeList mat = elem.getElementsByTagName(kind);
730         Element matcher = (Element) mat.item(0);
731
732         Color color = Color.decode(matcher.getAttribute("color"));
733         boolean inside = TRUE.equals(matcher.getAttribute("inside"));
734         String stype = matcher.getAttribute("type");
735         int type = 0;
736         if ("filled".equals(stype)) {
737             type = MatchingBlockManager.ScilabKeywordsPainter.FILLED;
738         } else if ("underlined".equals(stype)) {
739             type = MatchingBlockManager.ScilabKeywordsPainter.UNDERLINED;
740         } else if ("framed".equals(stype)) {
741             type = MatchingBlockManager.ScilabKeywordsPainter.FRAMED;
742         }
743
744         return new MatchingBlockManager.Parameters(color, inside, type, onmouseover);
745     }
746
747     /**
748      * Get the background Color
749      * @return the background Color
750      */
751     public static Color getSciNotesBackgroundColor() {
752         /* Load file */
753         readDocument();
754
755         Element root = document.getDocumentElement();
756
757         NodeList profiles = root.getElementsByTagName(EDITOR);
758         Element scinotesProfile = (Element) profiles.item(0);
759
760         NodeList allElements = scinotesProfile.getElementsByTagName(BACKGROUNDCOLOR);
761         Element scinotesBackground = (Element) allElements.item(0);
762
763         /*direct create a Color with "#FF00FF" string from the xml */
764         return Color.decode(scinotesBackground.getAttribute(VALUE));
765     }
766
767     /**
768      * Get the foreground Color
769      * @return the foreground Color
770      */
771     public static Color getSciNotesForegroundColor() {
772         /* Load file */
773         readDocument();
774
775         Element root = document.getDocumentElement();
776
777         NodeList profiles = root.getElementsByTagName(EDITOR);
778         Element scinotesProfile = (Element) profiles.item(0);
779
780         NodeList allElements = scinotesProfile.getElementsByTagName(FOREGROUNDCOLOR);
781         Element scinotesForeground = (Element) allElements.item(0);
782
783         /*direct create a Color with "#FF00FF" string from the xml */
784         return Color.decode(scinotesForeground.getAttribute(VALUE));
785     }
786
787     /**
788      * Save SciNotes BackgroundColor
789      * @param color the new Color
790      */
791     public static void saveSciNotesBackground(Color color) {
792
793         /* Load file */
794         readDocument();
795
796         Element root = document.getDocumentElement();
797
798         NodeList profiles = root.getElementsByTagName(EDITOR);
799         Element scinotesProfile = (Element) profiles.item(0);
800
801         NodeList allSizeElements = scinotesProfile.getElementsByTagName(BACKGROUNDCOLOR);
802         Element scinotesBackground = (Element) allSizeElements.item(0);
803
804         String rgb = Integer.toHexString(color.getRGB());
805         scinotesBackground.setAttribute(VALUE, COLORPREFIX + rgb.substring(2, rgb.length()));
806
807         /* Save changes */
808         writeDocument();
809     }
810
811     /**
812      * Save SciNotes foregroundColor
813      * @param color the new Color
814      */
815     public static void saveSciNotesForeground(Color color) {
816         readDocument();
817
818         Element root = document.getDocumentElement();
819
820         NodeList profiles = root.getElementsByTagName(EDITOR);
821         Element scinotesProfile = (Element) profiles.item(0);
822
823         NodeList allSizeElements = scinotesProfile.getElementsByTagName(FOREGROUNDCOLOR);
824         Element scinotesForeground = (Element) allSizeElements.item(0);
825
826         String rgb = Integer.toHexString(color.getRGB());
827         scinotesForeground.setAttribute(VALUE, COLORPREFIX + rgb.substring(2, rgb.length()));
828
829         /* Save changes */
830         writeDocument();
831     }
832
833     /**
834      * Save SciNotes autoIndent or not
835      * @param activated if autoIndent should be used or not
836      */
837     public static void saveAutoIndent(boolean activated) {
838         /* Load file */
839         readDocument();
840
841         Element root = document.getDocumentElement();
842
843         NodeList profiles = root.getElementsByTagName(PROFILE);
844         Element scinotesProfile = (Element) profiles.item(0);
845
846         NodeList allSizeElements = scinotesProfile.getElementsByTagName(AUTOINDENT);
847         Element scinotesAutoIndent = (Element) allSizeElements.item(0);
848         if (scinotesAutoIndent == null) {
849             Element autoIndent = document.createElement(AUTOINDENT);
850
851             autoIndent.setAttribute(VALUE, new Boolean(activated).toString());
852
853             scinotesProfile.appendChild((Node) autoIndent);
854         } else {
855             scinotesAutoIndent.setAttribute(VALUE, new Boolean(activated).toString());
856         }
857         /* Save changes */
858         writeDocument();
859     }
860
861     /**
862      * @return a boolean if autoIndent should be used or not
863      */
864     public static boolean getAutoIndent() {
865         /* Load file */
866         readDocument();
867
868         Element root = document.getDocumentElement();
869         NodeList profiles = root.getElementsByTagName(PROFILE);
870         Element scinotesProfile = (Element) profiles.item(0);
871         NodeList allSizeElements = scinotesProfile.getElementsByTagName(AUTOINDENT);
872         Element autoIndent = (Element) allSizeElements.item(0);
873
874         if (autoIndent == null) {
875             return true;
876         } else {
877             return new Boolean(autoIndent.getAttribute(VALUE));
878         }
879     }
880
881
882     /**
883      * Save SciNotes autoColorize or not
884      * @param activated if autoIndent should be used or not
885      */
886     public static void saveAutoColorize(boolean activated) {
887
888         /* Load file */
889         readDocument();
890
891         Element root = document.getDocumentElement();
892
893         NodeList profiles = root.getElementsByTagName(PROFILE);
894         Element scinotesProfile = (Element) profiles.item(0);
895
896         NodeList allSizeElements = scinotesProfile.getElementsByTagName(AUTOCOLORIZE);
897         Element scinotesAutoIndent = (Element) allSizeElements.item(0);
898         if (scinotesAutoIndent == null) {
899             Element autoColorize = document.createElement(AUTOCOLORIZE);
900
901             autoColorize.setAttribute(VALUE, new Boolean(activated).toString());
902
903             scinotesProfile.appendChild((Node) autoColorize);
904         } else {
905             scinotesAutoIndent.setAttribute(VALUE, new Boolean(activated).toString());
906         }
907         /* Save changes */
908         writeDocument();
909     }
910
911
912     /**
913      * @return a boolean to say if the doc is autocolorize
914      */
915     public static boolean getAutoColorize() {
916         /* Load file */
917         readDocument();
918
919         Element root = document.getDocumentElement();
920
921         NodeList profiles = root.getElementsByTagName(PROFILE);
922         Element scinotesProfile = (Element) profiles.item(0);
923
924         NodeList allSizeElements = scinotesProfile.getElementsByTagName(AUTOCOLORIZE);
925         Element autoColorize = (Element) allSizeElements.item(0);
926
927         if (autoColorize == null) {
928             return true;
929         } else {
930             return new Boolean(autoColorize.getAttribute(VALUE));
931         }
932     }
933
934
935     /**
936      * @param encoding the default encoding for the files
937      */
938     public static void saveDefaultEncoding(String encoding) {
939         /* Load file */
940         readDocument();
941
942         Element root = document.getDocumentElement();
943         NodeList profiles = root.getElementsByTagName(PROFILE);
944         Element scinotesProfile = (Element) profiles.item(0);
945         NodeList allSizeElements = scinotesProfile.getElementsByTagName(DEFAULTENCONDING);
946         Element scinotesAutoIndent = (Element) allSizeElements.item(0);
947         if (scinotesAutoIndent == null) {
948             Element defaultEncoding = document.createElement(DEFAULTENCONDING);
949
950             defaultEncoding.setAttribute(VALUE, encoding);
951
952             scinotesProfile.appendChild((Node) defaultEncoding);
953         } else {
954             scinotesAutoIndent.setAttribute(VALUE, encoding);
955         }
956         /* Save changes */
957         writeDocument();
958     }
959
960
961     /**
962      * @return the default encoding
963      */
964     public static String getDefaultEncoding() {
965         /* Load file */
966         readDocument();
967
968         Element root = document.getDocumentElement();
969         NodeList profiles = root.getElementsByTagName(PROFILE);
970         Element scinotesProfile = (Element) profiles.item(0);
971         NodeList allSizeElements = scinotesProfile.getElementsByTagName(DEFAULTENCONDING);
972         Element defaultEncoding = (Element) allSizeElements.item(0);
973
974         if (defaultEncoding == null || defaultEncoding.getAttribute(VALUE).equals("")) {
975             // If no default encoding read then used system default
976             saveDefaultEncoding(Charset.defaultCharset().name());
977             return Charset.defaultCharset().name();
978         } else {
979             return defaultEncoding.getAttribute(VALUE);
980         }
981     }
982
983     /**
984      * Get all the foreground Colors
985      * @return a Hashtable with the styles and the associated colors.
986      */
987     public static Map<String, Color> getAllForegroundColors() {
988         /* Load file */
989         readDocument();
990
991         Map<String, Color> stylesColorsTable = new Hashtable<String, Color>();
992
993         Element root = document.getDocumentElement();
994         NodeList styles = root.getElementsByTagName(STYLE);
995
996         for (int i = 0; i < styles.getLength(); ++i) {
997             Element style = (Element) styles.item(i);
998
999             NodeList allForegroundElements = style.getElementsByTagName(FOREGROUNDCOLOR);
1000             Element styleForeground = (Element) allForegroundElements.item(0);
1001             Color styleColor = Color.decode(styleForeground.getAttribute(VALUE));
1002             stylesColorsTable.put(style.getAttribute(NAME), styleColor);
1003         }
1004
1005         return stylesColorsTable;
1006     }
1007
1008     /**
1009      * @return a map containing styles names and the associated default font correctly derivated
1010      */
1011     public static Map<String, Font> getAllFontStyle() {
1012         return getAllFontStyle(getFont());
1013     }
1014
1015     /**
1016      * @param f the base font
1017      * @return a map containing styles names and the associated font correctly derivated
1018      */
1019     public static Map<String, Font> getAllFontStyle(Font f) {
1020         /* Load file */
1021         readDocument();
1022
1023         Font font = f;
1024         Map<String, Font> stylesFontsTable = new Hashtable<String, Font>();
1025
1026         Element root = document.getDocumentElement();
1027         NodeList styles = root.getElementsByTagName(STYLE);
1028
1029         for (int i = 0; i < styles.getLength(); ++i) {
1030             Element fstyles = (Element) styles.item(i);
1031
1032             NodeList allFontStyleElements = fstyles.getElementsByTagName(FONT_STYLE);
1033             Element fontStyle = (Element) allFontStyleElements.item(0);
1034             int style = Integer.parseInt(fontStyle.getAttribute(VALUE));
1035             String name = font.getName();
1036             int size = font.getSize();
1037             if (style == PLAIN) {
1038                 font = new Font(name, Font.PLAIN, size);
1039
1040             } else if (style == BOLD) {
1041                 font = new Font(name, Font.BOLD, size);
1042
1043             } else if (style == ITALIC) {
1044                 font = new Font(name, Font.ITALIC, size);
1045
1046             } else if (style == BOLDITALIC) {
1047                 font = new Font(name, Font.BOLD | Font.ITALIC , size);
1048
1049             } else {
1050                 font = new Font(name, Font.PLAIN, size);
1051             }
1052
1053             stylesFontsTable.put(fstyles.getAttribute(NAME), font);
1054         }
1055
1056         return stylesFontsTable;
1057     }
1058
1059
1060     /**
1061      * get all default foreground colors of scinotes
1062      * @return a Hashtable with the styles and the associated default colors.
1063      */
1064     public static Map<String, Color> getAllDefaultForegroundColors() {
1065         /* Load file */
1066         readDocument();
1067
1068         Map<String, Color> stylesDefaultColorsTable = new Hashtable<String, Color>();
1069
1070         Element root = document.getDocumentElement();
1071         NodeList styles = root.getElementsByTagName(STYLE);
1072
1073         for (int i = 0; i < styles.getLength(); ++i) {
1074             Element style = (Element) styles.item(i);
1075
1076             NodeList allForegroundElements = style.getElementsByTagName(FOREGROUNDCOLOR);
1077             Element styleForeground = (Element) allForegroundElements.item(0);
1078             Color styleColor = Color.decode(styleForeground.getAttribute(DEFAULT));
1079
1080             stylesDefaultColorsTable.put(style.getAttribute(NAME), styleColor);
1081         }
1082
1083         return stylesDefaultColorsTable;
1084     }
1085
1086     /**
1087      * @return a map containing styles names and an integer : 0 for nothing, 1 for underline, 2 for stroke
1088      * and 3 for stroke+underline
1089      */
1090     public static Map<String, Integer> getAllAttributes() {
1091         /* Load file */
1092         readDocument();
1093
1094         Map<String, Integer> attr = new Hashtable<String, Integer>();
1095
1096         Element root = document.getDocumentElement();
1097         NodeList styles = root.getElementsByTagName(STYLE);
1098
1099         for (int i = 0; i < styles.getLength(); ++i) {
1100             Element style = (Element) styles.item(i);
1101             int at = 0;
1102             String underline = style.getAttribute(UNDERLINE);
1103             if (TRUE.equals(underline)) {
1104                 at = 1;
1105             }
1106             String stroke = style.getAttribute(STROKE);
1107             if (TRUE.equals(stroke)) {
1108                 at += 2;
1109             }
1110             attr.put(style.getAttribute(NAME), at);
1111         }
1112
1113         return attr;
1114     }
1115
1116     /**
1117      * @return a map containing all defaults attributes
1118      */
1119     public static Map<String, Integer> getDefaultAllAttributes() {
1120         /* Load file */
1121         readDocument();
1122
1123         Map<String, Integer> attr = new Hashtable<String, Integer>();
1124
1125         Element root = document.getDocumentElement();
1126         NodeList styles = root.getElementsByTagName(STYLE);
1127
1128         for (int i = 0; i < styles.getLength(); ++i) {
1129             Element style = (Element) styles.item(i);
1130             int at = 0;
1131             String underline = style.getAttribute(DEFAULTUNDERLINE);
1132             if (TRUE.equals(underline)) {
1133                 at = 1;
1134             }
1135             String stroke = style.getAttribute(DEFAULTSTROKE);
1136             if (TRUE.equals(stroke)) {
1137                 at += 2;
1138             }
1139             attr.put(style.getAttribute(NAME), at);
1140         }
1141
1142         return attr;
1143     }
1144
1145     /**
1146      * save all foreground colors
1147      *@param stylesColorsTable a hashtable containing styles and the associated colors
1148      */
1149     public static void saveAllForegroundColors(Map<String, Color> stylesColorsTable) {
1150         /* Load file */
1151         readDocument();
1152
1153         Element root = document.getDocumentElement();
1154         NodeList styles = root.getElementsByTagName(STYLE);
1155
1156         for (int i = 0; i < styles.getLength(); ++i) {
1157             Element style = (Element) styles.item(i);
1158
1159             String styleName = style.getAttribute(NAME);
1160             NodeList allForegroundElements = style.getElementsByTagName(FOREGROUNDCOLOR);
1161             Element styleForeground = (Element) allForegroundElements.item(0);
1162
1163             Color color = stylesColorsTable.get(styleName);
1164
1165             String rgb = Integer.toHexString(color.getRGB());
1166             styleForeground.setAttribute(VALUE, COLORPREFIX + rgb.substring(2, rgb.length()));
1167
1168
1169         }
1170         /* Save changes */
1171         writeDocument();
1172     }
1173
1174     /**
1175      * save all style for the font
1176      * @param boldTable a hashtable containing style names and a boolean for the bold style
1177      * @param italicTable a hashtable containing style names and a boolean for the italic style
1178      */
1179     public static void saveAllFontStyle(Map<String, Boolean> boldTable, Map<String, Boolean> italicTable) {
1180         /* Load file */
1181         readDocument();
1182
1183         Element root = document.getDocumentElement();
1184         NodeList styles = root.getElementsByTagName(STYLE);
1185
1186         for (int i = 0; i < styles.getLength(); ++i) {
1187             Element style = (Element) styles.item(i);
1188
1189             String styleName = style.getAttribute(NAME);
1190             NodeList fontStyleElements = style.getElementsByTagName(FONT_STYLE);
1191             Element fontStyle = (Element) fontStyleElements.item(0);
1192
1193             int bold = 1;
1194             if (!boldTable.get(styleName)) {
1195                 bold = 0;
1196             }
1197             int italic = 2;
1198             if (!italicTable.get(styleName)) {
1199                 italic = 0;
1200             }
1201
1202             fontStyle.setAttribute(VALUE, Integer.toString(bold + italic));
1203         }
1204         /* Save changes */
1205         writeDocument();
1206     }
1207
1208     /**
1209      * save all style for the font
1210      * @param attTable a hashtable containing styles and the associated attribute
1211      */
1212     public static void saveAllAttributes(Map<String, Integer> attTable) {
1213         /* Load file */
1214         readDocument();
1215
1216         Element root = document.getDocumentElement();
1217         NodeList styles = root.getElementsByTagName(STYLE);
1218
1219         for (int i = 0; i < styles.getLength(); ++i) {
1220             Element style = (Element) styles.item(i);
1221
1222             String styleName = style.getAttribute(NAME);
1223
1224             String underline = TRUE;
1225             if ((attTable.get(styleName) & 1) != 1) {
1226                 underline = FALSE;
1227             }
1228             String stroke = TRUE;
1229             if ((attTable.get(styleName) & 2) != 2) {
1230                 stroke = FALSE;
1231             }
1232
1233             style.setAttribute(UNDERLINE, underline);
1234             style.setAttribute(STROKE, stroke);
1235         }
1236         /* Save changes */
1237         writeDocument();
1238     }
1239
1240     /**
1241      * Get the position of SciNotes Main Window
1242      * @return the position
1243      */
1244     public static Position getMainWindowPosition() {
1245         /* Load file */
1246         readDocument();
1247
1248         Element root = document.getDocumentElement();
1249
1250         NodeList profiles = root.getElementsByTagName(PROFILE);
1251         Element scinotesProfile = (Element) profiles.item(0);
1252
1253         NodeList allPositionElements = scinotesProfile.getElementsByTagName(MAINWINPOSITION);
1254         Element mainWindowPosition = (Element) allPositionElements.item(0);
1255         if (mainWindowPosition != null) {
1256             int x = Integer.parseInt(mainWindowPosition.getAttribute(XCOORD));
1257             int y = Integer.parseInt(mainWindowPosition.getAttribute(YCOORD));
1258             /* Avoid SciNotes Main Window to be out of the screen */
1259             if (x <= (Toolkit.getDefaultToolkit().getScreenSize().width - MARGIN)
1260                 && y <= (Toolkit.getDefaultToolkit().getScreenSize().height - MARGIN)) {
1261                 return new Position(x, y);
1262             } else {
1263                 return new Position(0, 0);
1264             }
1265         } else {
1266             return new Position(0, 0);
1267         }
1268     }
1269
1270
1271     /**
1272      * Save the position of SciNotes Main Window
1273      * @param position the position of SciNotes main Window
1274      */
1275     public static void saveMainWindowPosition(Position position) {
1276         readDocument();
1277
1278         Element root = document.getDocumentElement();
1279
1280         NodeList profiles = root.getElementsByTagName(PROFILE);
1281         Element scinotesProfile = (Element) profiles.item(0);
1282
1283         NodeList allPositionElements = scinotesProfile.getElementsByTagName(MAINWINPOSITION);
1284         Element mainWindowPosition = (Element) allPositionElements.item(0);
1285
1286
1287         mainWindowPosition.setAttribute(XCOORD, Integer.toString(position.getX()));
1288         mainWindowPosition.setAttribute(YCOORD, Integer.toString(position.getY()));
1289
1290         /* Save changes */
1291         writeDocument();
1292     }
1293
1294
1295     /**
1296      * Save the size of SciNotes Main Window
1297      * @param size the size of SciNotes main Window
1298      */
1299     public static void saveMainWindowSize(Size size) {
1300         readDocument();
1301
1302         Element root = document.getDocumentElement();
1303
1304         NodeList profiles = root.getElementsByTagName(PROFILE);
1305         Element scinotesProfile = (Element) profiles.item(0);
1306
1307         NodeList allPositionElements = scinotesProfile.getElementsByTagName(MAINWINSIZE);
1308         Element mainWindowSize = (Element) allPositionElements.item(0);
1309
1310
1311         mainWindowSize.setAttribute(WIDTH, Integer.toString(size.getWidth()));
1312         mainWindowSize.setAttribute(HEIGHT, Integer.toString(size.getHeight()));
1313
1314         /* Save changes */
1315         writeDocument();
1316
1317     }
1318
1319     /**
1320      * Get the size of SciNotes Main Window
1321      * @return the size
1322      */
1323     public static Size getMainWindowSize() {
1324
1325         readDocument();
1326
1327         Element root = document.getDocumentElement();
1328
1329         NodeList profiles = root.getElementsByTagName(PROFILE);
1330         Element scinotesProfile = (Element) profiles.item(0);
1331
1332         NodeList allSizeElements = scinotesProfile.getElementsByTagName(MAINWINSIZE);
1333         Element mainWindowSize = (Element) allSizeElements.item(0);
1334         if (mainWindowSize != null) {
1335             return new Size(Integer.parseInt(mainWindowSize.getAttribute(WIDTH)), Integer.parseInt(mainWindowSize.getAttribute(HEIGHT)));
1336         } else {
1337             return new Size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
1338         }
1339     }
1340
1341     /**
1342      * Get all the  recent opened files
1343      * @return a array of uri
1344      */
1345     public static List<File> getAllRecentOpenedFiles() {
1346         List<File> files = new ArrayList<File>();
1347         readDocument();
1348         Element root = (Element) document.getDocumentElement().getElementsByTagName(RECENT_FILES).item(0);
1349         if (root != null) {
1350             NodeList recentFiles = root.getElementsByTagName(DOCUMENT);
1351             for (int i = 0; i < recentFiles.getLength(); ++i) {
1352                 Element style = (Element) recentFiles.item(i);
1353
1354                 File temp = new File(style.getAttribute(PATH));
1355
1356                 if (temp.exists()) {
1357                     files.add(temp);
1358                 } else {
1359                     root.removeChild((Node) style);
1360                 }
1361
1362                 /* Save changes */
1363                 writeDocument();
1364             }
1365         }
1366         return files;
1367     }
1368
1369     /**
1370      * Add a file to recent Opened Files
1371      * @param filePath the path of the files to add
1372      */
1373     public static void saveToRecentOpenedFiles(String filePath) {
1374         readDocument();
1375
1376         Element root = (Element) document.getDocumentElement().getElementsByTagName(RECENT_FILES).item(0);
1377         NodeList recentFiles = root.getElementsByTagName(DOCUMENT);
1378         int numberOfFiles = recentFiles.getLength();
1379
1380         // we remove all the duplicate
1381         for (int i = 0; i < recentFiles.getLength();  ++i) {
1382             Element style = (Element) recentFiles.item(i);
1383             if (filePath.equals(style.getAttribute(PATH))) {
1384                 root.removeChild((Node) style);
1385                 numberOfFiles--;
1386             }
1387         }
1388
1389         // if we have reached the maximun , we remove the oldest files
1390         while (recentFiles.getLength() >= MAX_RECENT_FILES) {
1391             root.removeChild(root.getFirstChild());
1392         }
1393
1394         Element newFile =  document.createElement(DOCUMENT);
1395         newFile.setAttribute(PATH, filePath);
1396         root.appendChild((Node) newFile);
1397
1398         /* Save changes */
1399         writeDocument();
1400     }
1401
1402     /**
1403      * Read the file to modify
1404      */
1405     private static void readDocument() {
1406         File xml = null;
1407         DocumentBuilder docBuilder = null;
1408
1409         try {
1410             if (document == null) {
1411                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
1412                 docBuilder = factory.newDocumentBuilder();
1413
1414                 // read content of a XML file with DOM
1415                 xml = new File(USER_SCINOTES_CONFIG_FILE);
1416                 document = docBuilder.parse(xml);
1417             }
1418         } catch (ParserConfigurationException pce) {
1419             System.err.println(ERROR_READ + USER_SCINOTES_CONFIG_FILE);
1420         } catch (SAXException se) {
1421             System.err.println(ERROR_READ + USER_SCINOTES_CONFIG_FILE);
1422         } catch (IOException ioe) {
1423             System.err.println(ERROR_READ + USER_SCINOTES_CONFIG_FILE);
1424         }
1425
1426         try {
1427             if (keysMap == null) {
1428                 xml = new File(USER_SCINOTES_CONFIG_KEYS_FILE);
1429                 keysMap = new Properties();
1430                 keysMap.loadFromXML(new FileInputStream(xml));
1431             }
1432         } catch (FileNotFoundException e) {
1433             e.printStackTrace();
1434         } catch (IOException e) {
1435             e.printStackTrace();
1436         }
1437     }
1438
1439     /**
1440      * @param map the map to fill with the pairs (keystroke, action) found in file etc/keysConfiguration.xml
1441      */
1442     public static void addMapActionNameKeys(Map map) {
1443         for (Enumeration action = keysMap.propertyNames(); action.hasMoreElements();) {
1444             String name = (String) action.nextElement();
1445             KeyStroke ks = KeyStroke.getKeyStroke(keysMap.getProperty(name));
1446             map.put(name, ks);
1447         }
1448     }
1449
1450
1451     /**
1452      * Save the modifications
1453      */
1454     private static void writeDocument() {
1455
1456         Transformer transformer = null;
1457         try {
1458             transformer = TransformerFactory.newInstance().newTransformer();
1459         } catch (TransformerConfigurationException e1) {
1460             System.out.println(ERROR_WRITE + USER_SCINOTES_CONFIG_FILE);
1461         } catch (TransformerFactoryConfigurationError e1) {
1462             System.out.println(ERROR_WRITE + USER_SCINOTES_CONFIG_FILE);
1463         }
1464         transformer.setOutputProperty(OutputKeys.INDENT, "yes");
1465
1466         StreamResult result = new StreamResult(new File(USER_SCINOTES_CONFIG_FILE));
1467         DOMSource source = new DOMSource(document);
1468         try {
1469             transformer.transform(source, result);
1470         } catch (TransformerException e) {
1471             System.out.println(ERROR_WRITE + USER_SCINOTES_CONFIG_FILE);
1472         }
1473
1474
1475     }
1476
1477     /**
1478      * Add a file to recent Opened Files
1479      * @param exp the path of the files to add
1480      */
1481     public static void saveRecentSearch(String exp) {
1482         Node root = getXcosRoot();
1483         if (root == null || exp == null || exp.compareTo("") == 0) {
1484             return;
1485         }
1486
1487         Node recents = getNodeChild(root, RECENT_SEARCH);
1488         if (recents == null) {
1489             recents = document.createElement(RECENT_SEARCH);
1490             root.appendChild(recents);
1491         }
1492
1493         List<Node> search = getNodeChildren(recents, SEARCH);
1494
1495         while (search.size() >= MAX_RECENT_SEARCH) {
1496             removeRecentSearch(((Element) search.get(0)).getAttribute(EXPRESSION));
1497             search = getNodeChildren(recents, SEARCH);
1498         }
1499         //if path already in file no need to add it
1500         for (Node item : search) {
1501             if (exp.compareTo(((Element) item).getAttribute(EXPRESSION)) == 0) {
1502                 return;
1503             }
1504         }
1505
1506         Element newSearch = document.createElement(SEARCH);
1507         newSearch.setAttribute(EXPRESSION, exp);
1508         recents.appendChild((Node) newSearch);
1509
1510         /* Save changes */
1511         writeDocument();
1512     }
1513
1514     /**
1515      * @param exp the expression to remove
1516      */
1517     public static void removeRecentSearch(String exp) {
1518         Node root = getXcosRoot();
1519         if (root == null) {
1520             return;
1521         }
1522
1523         Node recent = getNodeChild(root, RECENT_SEARCH);
1524         List<Node> search = getNodeChildren(recent, SEARCH);
1525
1526         // remove node if exists
1527         for (Node file : search) {
1528             if (exp.compareTo(((Element) file).getAttribute(EXPRESSION)) == 0) {
1529                 recent.removeChild(file);
1530                 break;
1531             }
1532         }
1533         /* Save changes */
1534         writeDocument();
1535
1536     }
1537
1538     /**
1539      * @return a list of the recent searches
1540      */
1541     public static List<String> getRecentSearch() {
1542         List<String> files = new ArrayList<String>();
1543
1544         Node root = getXcosRoot();
1545         if (root == null) {
1546             return files;
1547         }
1548
1549         Node recent = getNodeChild(root, RECENT_SEARCH);
1550         List<Node> searches = getNodeChildren(recent, SEARCH);
1551         for (Node search : searches) {
1552             String exp = ((Element) search).getAttribute(EXPRESSION);
1553             if (exp != null && exp.compareTo("") != 0) {
1554                 files.add(exp);
1555             }
1556         }
1557
1558         return files;
1559     }
1560
1561     /**
1562      * @param exp the recent expression for a replacement
1563      */
1564     public static void saveRecentReplace(String exp) {
1565         Node root = getXcosRoot();
1566         if (root == null || exp == null || exp.compareTo("") == 0) {
1567             return;
1568         }
1569
1570         Node recent = getNodeChild(root, RECENT_REPLACE);
1571         if (recent == null) {
1572             recent = document.createElement(RECENT_REPLACE);
1573             root.appendChild(recent);
1574         }
1575
1576         List<Node> replace = getNodeChildren(recent, REPLACE);
1577
1578         while (replace.size() >= MAX_RECENT_REPLACE) {
1579             removeRecentReplace(((Element) replace.get(0)).getAttribute(EXPRESSION));
1580             replace = getNodeChildren(recent, REPLACE);
1581         }
1582         //if path already in file no need to add it
1583         for (Node item : replace) {
1584             if (exp.compareTo(((Element) item).getAttribute(EXPRESSION)) == 0) {
1585                 return;
1586             }
1587         }
1588
1589         Element newReplace = document.createElement(REPLACE);
1590         newReplace.setAttribute(EXPRESSION, exp);
1591         recent.appendChild((Node) newReplace);
1592
1593         /* Save changes */
1594         writeDocument();
1595     }
1596
1597     /**
1598      * @param filePath remove recent replace in the this file
1599      */
1600     public static void removeRecentReplace(String filePath) {
1601
1602         Node root = getXcosRoot();
1603         if (root == null) {
1604             return;
1605         }
1606
1607         Node recent = getNodeChild(root, RECENT_REPLACE);
1608         List<Node> replace = getNodeChildren(recent, REPLACE);
1609
1610         // remove node if exists
1611         for (Node exp : replace) {
1612             if (filePath.compareTo(((Element) exp).getAttribute(EXPRESSION)) == 0) {
1613                 recent.removeChild(exp);
1614                 break;
1615             }
1616
1617         }
1618         /* Save changes */
1619         writeDocument();
1620
1621     }
1622
1623     /**
1624      * @return the recent replace
1625      */
1626     public static List<String> getRecentReplace() {
1627         List<String> exps = new ArrayList<String>();
1628
1629         Node root = getXcosRoot();
1630         if (root == null) {
1631             return exps;
1632         }
1633
1634         Node recent = getNodeChild(root, RECENT_REPLACE);
1635         List<Node> replace = getNodeChildren(recent, REPLACE);
1636         for (Node file : replace) {
1637             String exp = ((Element) file).getAttribute(EXPRESSION);
1638             if (exp != null && exp.compareTo("") != 0) {
1639                 exps.add(exp);
1640             }
1641         }
1642
1643         return exps;
1644     }
1645
1646     /**
1647      * @return true for a regexp search
1648      */
1649     public static boolean getRegularExpression() {
1650         return getBooleanAttribute(REGULAR_EXPRESION, STATE_FLAG, false);
1651     }
1652
1653     /**
1654      * @param regualExp for a regexp search
1655      */
1656     public static void saveRegularExpression(boolean regualExp) {
1657         saveBooleanAttribute(REGULAR_EXPRESION, STATE_FLAG, regualExp);
1658     }
1659
1660     /**
1661      * @return true for a wholeWord search
1662      */
1663     public static boolean getWholeWord() {
1664         return getBooleanAttribute(WHOLE_WORD, STATE_FLAG, false);
1665     }
1666
1667     /**
1668      * @param wholeWord for a wholeWord search
1669      */
1670     public static void saveWholeWord(boolean wholeWord) {
1671         saveBooleanAttribute(WHOLE_WORD, STATE_FLAG, wholeWord);
1672     }
1673
1674     /**
1675      * @return true for a wordWrap search
1676      */
1677     public static boolean getWordWarp() {
1678         return getBooleanAttribute(WORD_WARP, STATE_FLAG, true);
1679     }
1680
1681     /**
1682      * @param wordWarp for a wordWrap search
1683      */
1684     public static void saveWordWarp(boolean wordWarp) {
1685         saveBooleanAttribute(WORD_WARP, STATE_FLAG, wordWarp);
1686     }
1687
1688     /**
1689      * @return true for a case sensitive search
1690      */
1691     public static boolean getCaseSensitive() {
1692         return getBooleanAttribute(CASE_SENSITIVE, STATE_FLAG, false);
1693     }
1694
1695     /**
1696      * @param caseSensitive for a case sensitive search
1697      */
1698     public static void saveCaseSensitive(boolean caseSensitive) {
1699         saveBooleanAttribute(CASE_SENSITIVE, STATE_FLAG, caseSensitive);
1700     }
1701
1702     /**
1703      * getBooleanAttribute
1704      * @param node the node name
1705      * @param attrib the attribute of the node
1706      * @param defaultValue true or false
1707      * @return the found boolean value or defaultValue if not found
1708      */
1709     private static boolean getBooleanAttribute(String node, String attrib, boolean defaultValue) {
1710         boolean flag = false;
1711         Node root = getXcosRoot();
1712         if (root == null) {
1713             return flag;
1714         }
1715         Node recent = getNodeChild(root, node);
1716         if (recent != null) {
1717             String exp = ((Element) recent).getAttribute(attrib);
1718             if (exp.compareTo(TRUE) == 0) {
1719                 flag = true;
1720             }
1721         } else {
1722             return defaultValue;
1723         }
1724         return flag;
1725     }
1726
1727     /**
1728      * saveBooleanAttribute
1729      * @param node the node name
1730      * @param attrib the attribute of the node
1731      * @param state "true" or "false"
1732      */
1733     private static void saveBooleanAttribute(String node, String attrib, boolean state) {
1734         Node root = getXcosRoot();
1735         if (root == null) {
1736             return;
1737         }
1738
1739         Node recent = getNodeChild(root, node);
1740         if (recent == null) {
1741             recent = document.createElement(node);
1742             root.appendChild(recent);
1743         }
1744
1745
1746         ((Element) recent).setAttribute(attrib, new Boolean(state).toString());
1747
1748         root.appendChild((Node) recent);
1749
1750         /* Save changes */
1751         writeDocument();
1752     }
1753
1754     /**
1755      * getNodeChild
1756      * @param par parent
1757      * @param nodeName the name
1758      * @return the node
1759      */
1760     private static Node getNodeChild(Node par, String nodeName) {
1761         Node parent = par;
1762         if (parent == null) {
1763             if (document == null) {
1764                 readDocument();
1765                 if (document == null) {
1766                     return null;
1767                 }
1768             }
1769             parent = document;
1770         }
1771
1772         Node currentNode = parent.getFirstChild();
1773         while (currentNode != null) {
1774             if (currentNode.getNodeName().compareTo(nodeName) == 0) {
1775                 return currentNode;
1776             }
1777             currentNode = currentNode.getNextSibling();
1778         }
1779         return currentNode;
1780     }
1781
1782     /**
1783      * getNodeChildren
1784      * @param par parent
1785      * @param childName the name
1786      * @return a list of nodes
1787      */
1788     private static List<Node> getNodeChildren(Node par, String childName) {
1789         Node parent = par;
1790         List<Node> nodes = new ArrayList<Node>();
1791         if (parent == null) {
1792             if (document == null) {
1793                 readDocument();
1794                 if (document == null) {
1795                     return nodes;
1796                 }
1797             }
1798             parent = document;
1799         }
1800
1801         Node currentNode = parent.getFirstChild();
1802         while (currentNode != null) {
1803             if (currentNode.getNodeName().compareTo(childName) == 0) {
1804                 nodes.add(currentNode);
1805             }
1806             currentNode = currentNode.getNextSibling();
1807         }
1808         return nodes;
1809
1810     }
1811
1812     /**
1813      * @return the root
1814      */
1815     private static Node getXcosRoot() {
1816         if (document == null) {
1817             readDocument();
1818             if (document == null) {
1819                 return null;
1820             }
1821         }
1822
1823         Node setting = getNodeChild(null, SETTING);
1824
1825         if (setting != null) {
1826             List<Node> nodes = getNodeChildren(setting, PROFILE);
1827             for (Node node : nodes) {
1828                 if (((Element) node).getAttribute(NAME).compareTo(SCINOTES) == 0) {
1829                     return node;
1830                 }
1831             }
1832         }
1833         return null;
1834     }
1835 }