Changeset c006fa359f7823874cf7a814cb87823276535eae

Timestamp:

01/06/07 23:58:06 (6 years ago)

Author:

Philipp Kern <phil@…>

Parents:

1662ea7cb97e74c04650ddda1130c2ea7a4d07ce

Children:

dae8a2ac150d973882215b5fb1d08b7135343f38

git-committer:

Philipp Kern <phil@0x539.de> / 2007-01-06T22:58:06Z+0000

Message:

[project @ Replaced mime map by file list in preferences]

Original author: Armin Burgmeier <armin@…>
Date: 2006-03-08 20:56:37+00:00

Files:

• inc/config.hpp (modified) (2 diffs)
• inc/document_settings.hpp (modified) (3 diffs)
• inc/folder.hpp (modified) (1 diff)
• inc/header.hpp (modified) (3 diffs)
• inc/mimemap.hpp (deleted)
• inc/preferences.hpp (modified) (3 diffs)
• inc/window.hpp (modified) (1 diff)
• src/config.cpp (modified) (2 diffs)
• src/document_settings.cpp (modified) (10 diffs)
• src/documentlist.cpp (modified) (4 diffs)
• src/docwindow.cpp (modified) (2 diffs)
• src/folder.cpp (modified) (2 diffs)
• src/header.cpp (modified) (5 diffs)
• src/mimemap.cpp (deleted)
• src/preferences.cpp (modified) (2 diffs)
• src/window.cpp (modified) (4 diffs)

inc/config.hpp

@@ -66 +66 @@
         {
         public:
+                class iterator
+                {
+                private:
+                        typedef std::map<Glib::ustring, Entry>::iterator
+                                base_type;
+
+                public:
+                        iterator(const base_type& base);
+
+                        iterator& operator++();
+                        iterator operator++(int);
+
+                        bool operator==(const iterator& other) const;
+                        bool operator!=(const iterator& other) const;
+
+                        const Glib::ustring& index() const;
+                        Entry& entry();
+
+                private:
+                        base_type m_iter;
+                };
+
                 Entry();
                 Entry(const Entry& other);
@@ -75 +97 @@
                 void save(xmlpp::Element& element) const;
 
+                bool has_entry(const Glib::ustring& index) const;
                 Entry& operator[](const Glib::ustring& index);
+
+                iterator begin();
+                iterator end();
 
                 template<typename T> T get(const T& default_value = T()) const

inc/document_settings.hpp

@@ -99 +99 @@
         /** @brief Returns the columns for the underlaying ListStore.
          */
-        const Columns& get_columns() const;
+//      const Columns& get_columns() const;
 
         /** @brief Returns the underlaying list that may be displayed by
@@ -124 +124 @@
         signal_document_remove_type document_remove_event() const;
 
+        const Columns columns;
 private:
         void on_document_insert(DocumentInfo& info);
@@ -139 +140 @@
 
         Glib::RefPtr<Gtk::ListStore> m_data;
-        Columns m_cols;
+        //Columns m_cols;
 
         Glib::RefPtr<Gdk::Pixbuf> m_icon;

inc/folder.hpp

@@ -89 +89 @@
         const MimeMap& get_mime_map() const;
 
+#if 0
         Glib::RefPtr<const Gtk::SourceLanguagesManager>
                 get_lang_manager() const;
+#endif
 
         // Calls from the window

inc/header.hpp

@@ -114 +114 @@
         };
 
-        Header(const ApplicationState& state);
+        typedef Glib::RefPtr<Gtk::SourceLanguagesManager> LangManager;
+
+        Header(const ApplicationState& state, const LangManager& lang_mgr);
 
         // Access to accelerator groups of the ui manager
@@ -120 +122 @@
         Glib::RefPtr<const Gtk::AccelGroup> get_accel_group() const;
 
-        Glib::RefPtr<Gtk::SourceLanguagesManager>
+        /*Glib::RefPtr<Gtk::SourceLanguagesManager>
                 get_lang_manager();
         Glib::RefPtr<const Gtk::SourceLanguagesManager>
-                get_lang_manager() const;
+                get_lang_manager() const;*/
 
         // Access to toolbar & menubar
@@ -180 +182 @@
 
         const Glib::RefPtr<Gtk::UIManager> m_ui_manager;
-        Glib::RefPtr<Gtk::SourceLanguagesManager> m_lang_manager;
+        //Glib::RefPtr<Gtk::SourceLanguagesManager> m_lang_manager;
 
         Gtk::MenuBar* m_menubar;

inc/preferences.hpp

@@ -23 +23 @@
 #include "config.hpp"
 
+#include "sourceview/sourcelanguage.hpp"
+#include "sourceview/sourcelanguagesmanager.hpp"
+
 namespace Gobby
 {
@@ -29 +32 @@
 {
 public:
+        typedef Glib::RefPtr<Gtk::SourceLanguage> Language;
+        typedef Glib::RefPtr<Gtk::SourceLanguagesManager> LangManager;
+
         /** Uninitialised preferences.
          */
         Preferences();
 
-        /** Reads preferences values out of a config.
+        /** Reads preferences values out of a config, using default values
+         * for values that do not exist in the config.
          */
-        Preferences(Config& m_config);
-
-        /** Copies preferences.
-         */
-        Preferences(const Preferences& other);
-        ~Preferences();
-
-        /** Copies preferences.
-         */
-        Preferences& operator=(const Preferences& other);
+        Preferences(Config& m_config, const LangManager& lang_mgr);
 
         /** Serialises preferences back to config.
          */
-        void serialise(Config& config);
+        void serialise(Config& config) const;
 
-        struct
+        class Editor
         {
+        public:
+                Editor();
+                Editor(Config::Entry& entry);
+                void serialise(Config::Entry& entry) const;
+
                 unsigned int tab_width;
                 bool tab_spaces;
                 bool indentation_auto;
                 bool homeend_smart;
-        } editor;
+        };
 
-        struct
+        class View
         {
+        public:
+                View();
+                View(Config::Entry& entry);
+                void serialise(Config::Entry& entry) const;
+
                 bool wrap_text;
                 bool wrap_words;
@@ -67 +75 @@
                 unsigned int margin_pos;
                 bool bracket_highlight;
-        } view;
+        };
 
-        struct
+        class Appearance
         {
+        public:
+                Appearance();
+                Appearance(Config::Entry& entry);
+                void serialise(Config::Entry& entry) const;
+
                 Gtk::ToolbarStyle toolbar_show;
                 bool remember;
-        } appearance;
+        };
+
+        class FileList
+        {
+        public:
+                typedef std::map<Glib::ustring, Language> map_type;
+
+                class iterator
+                {
+                private:
+                        typedef map_type::const_iterator base_iterator;
+
+                public:
+                        iterator(base_iterator iter);
+
+                        iterator& operator++();
+                        iterator operator++(int);
+
+                        const Glib::ustring& pattern() const;
+                        const Language& language() const;
+                private:
+                        base_iterator m_iter;
+                };
+
+                FileList();
+                FileList(Config::Entry& entry, const LangManager& lang_mgr);
+
+                void serialise(Config::Entry& entry) const;
+
+                // This function may also return an already existing iterator
+                // when pattern is already in the map. Compare lang to be sure
+                // that the entry actually has been inserted.
+                iterator add(const Glib::ustring& pattern,
+                             const Language& lang);
+
+                iterator begin() const;
+                iterator end() const;
+        protected:
+                iterator add_by_mime_type(const Glib::ustring& pattern,
+                                          const Glib::ustring& mime_type,
+                                          const LangManager& lang_mgr);
+
+                map_type m_files;
+        };
+
+        Editor editor;
+        View view;
+        Appearance appearance;
+        FileList files;
 };
 

inc/window.hpp

@@ -133 +133 @@
         // Config
         Config& m_config;
+        Glib::RefPtr<Gtk::SourceLanguagesManager> m_lang_manager;
         Preferences m_preferences;
         const IconManager& m_icon_mgr;

src/config.cpp

@@ -93 +93 @@
 }
 
+Gobby::Config::Entry::iterator::iterator(const base_type& base):
+        m_iter(base)
+{
+}
+
+Gobby::Config::Entry::iterator& Gobby::Config::Entry::iterator::operator++()
+{
+        ++ m_iter;
+        return *this;
+}
+
+Gobby::Config::Entry::iterator Gobby::Config::Entry::iterator::operator++(int)
+{
+        iterator temp(*this);
+        ++ *this;
+        return temp;
+}
+
+bool Gobby::Config::Entry::iterator::operator==(const iterator& other) const
+{
+        return m_iter == other.m_iter;
+}
+
+bool Gobby::Config::Entry::iterator::operator!=(const iterator& other) const
+{
+        return m_iter != other.m_iter;
+}
+
+const Glib::ustring& Gobby::Config::Entry::iterator::index() const
+{
+        return m_iter->first;
+}
+
+Gobby::Config::Entry& Gobby::Config::Entry::iterator::entry()
+{
+        return m_iter->second;
+}
+
 Gobby::Config::Entry::Entry()
 {
@@ -146 +184 @@
 }
 
+bool Gobby::Config::Entry::has_entry(const Glib::ustring& index) const
+{
+        return m_table.find(index) != m_table.end();
+}
+
 Gobby::Config::Entry&
 Gobby::Config::Entry::operator[](const Glib::ustring& index)
 {
         return m_table[index];
+}
+
+Gobby::Config::Entry::iterator Gobby::Config::Entry::begin()
+{
+        return iterator(m_table.begin() );
+}
+
+Gobby::Config::Entry::iterator Gobby::Config::Entry::end()
+{
+        return iterator(m_table.end() );
 }
 

src/document_settings.cpp

@@ -57 +57 @@
         m_icon(window.render_icon(Gtk::Stock::EDIT, Gtk::ICON_SIZE_BUTTON))
 {
-        m_data = Gtk::ListStore::create(m_cols);
+        m_data = Gtk::ListStore::create(columns);
 }
 
@@ -88 +88 @@
         get_original_encoding(const LocalDocumentInfo& info) const
 {
-        return (*get_iter(info))[m_cols.original_encoding];
+        return (*get_iter(info))[columns.original_encoding];
 }
 
@@ -95 +95 @@
                               const Glib::ustring& encoding)
 {
-        (*get_iter(info))[m_cols.original_encoding] = encoding;
+        (*get_iter(info))[columns.original_encoding] = encoding;
 }
 
@@ -101 +101 @@
         get_path(const LocalDocumentInfo& info) const
 {
-        return (*get_iter(info))[m_cols.path];
+        return (*get_iter(info))[columns.path];
 }
 
@@ -107 +107 @@
                                        const Glib::ustring& path)
 {
-        (*get_iter(info))[m_cols.path] = path;
+        (*get_iter(info))[columns.path] = path;
 }
 
@@ -114 +114 @@
 {
         return m_columns;
-}*/
+}
 
 const Gobby::DocumentSettings::Columns&
 Gobby::DocumentSettings::get_columns() const
 {
-        return m_cols;
-}
+        return columns;
+}*/
 
 Glib::RefPtr<Gtk::ListStore> Gobby::DocumentSettings::get_list()
@@ -169 +169 @@
 
         Gtk::TreeIter iter = m_data->append();
-        (*iter)[m_cols.info] = &local_info;
-        (*iter)[m_cols.icon] = m_icon;
-        (*iter)[m_cols.color] = document_color(local_info);
-        (*iter)[m_cols.title] = local_info.get_title();
+        (*iter)[columns.info] = &local_info;
+        (*iter)[columns.icon] = m_icon;
+        (*iter)[columns.color] = document_color(local_info);
+        (*iter)[columns.title] = local_info.get_title();
 
         m_map[&local_info] = iter;
@@ -201 +201 @@
 {
         LocalDocumentInfo& local_info = dynamic_cast<LocalDocumentInfo&>(info);
-        (*get_iter(local_info))[m_cols.title] = local_info.get_title();
+        (*get_iter(local_info))[columns.title] = local_info.get_title();
 }
 
@@ -208 +208 @@
 {
         if(&user == &info.get_buffer().get_self() )
-                (*get_iter(info))[m_cols.color] = document_color(info);
+                (*get_iter(info))[columns.color] = document_color(info);
 }
 
@@ -215 +215 @@
 {
         if(&user == &info.get_buffer().get_self() )
-                (*get_iter(info))[m_cols.color] = document_color(info);
+                (*get_iter(info))[columns.color] = document_color(info);
 }
 

src/documentlist.cpp

@@ -48 +48 @@
         m_btn_subscribe(_("Subscribe") )
 {
-        m_view_col.pack_start(settings.get_columns().icon, false);
-        m_view_col.pack_start(settings.get_columns().title, false);
+        m_view_col.pack_start(settings.columns.icon, false);
+        m_view_col.pack_start(settings.columns.title, false);
         m_view_col.set_spacing(5);
 
@@ -68 +68 @@
         m_view_col.add_attribute(
                 renderer->property_foreground_gdk(),
-                settings.get_columns().color
+                settings.columns.color
         );
 
-        m_view_col.set_sort_column(settings.get_columns().title);
+        m_view_col.set_sort_column(settings.columns.title);
 
         m_tree_view.add_events(Gdk::BUTTON_PRESS_MASK);
@@ -178 +178 @@
 
                 LocalDocumentInfo* info =
-                        (*tree_iter)[m_settings.get_columns().info];
+                        (*tree_iter)[m_settings.columns.info];
 
                 if(can_subscribe(*info) )
@@ -202 +202 @@
 
                 LocalDocumentInfo* info =
-                        (*tree_iter)[m_settings.get_columns().info];
+                        (*tree_iter)[m_settings.columns.info];
 
                 if(can_subscribe(*info) )

src/docwindow.cpp

@@ -63 +63 @@
 
         // TODO: Set source language by filename
-        buf->set_highlight(true);
+        buf->set_highlight(false);
 
         buf->signal_mark_set().connect(
@@ -148 +148 @@
 void Gobby::DocWindow::grab_focus()
 {
+        Gtk::ScrolledWindow::grab_focus();
         m_view.grab_focus();
 }

src/folder.cpp

@@ -145 +145 @@
 }
 
+#if 0
 Glib::RefPtr<const Gtk::SourceLanguagesManager>
 Gobby::Folder::get_lang_manager() const
@@ -150 +151 @@
         return m_header.get_lang_manager();
 }
+#endif
 
 void Gobby::Folder::obby_start(LocalBuffer& buf)

src/header.cpp

@@ -203 +203 @@
 }
 
-Gobby::Header::Header(const ApplicationState& state):
+Gobby::Header::Header(const ApplicationState& state,
+                      const LangManager& lang_mgr):
         group_app(Gtk::ActionGroup::create() ),
         group_session(Gtk::ActionGroup::create() ),
@@ -409 +410 @@
         ),
 
-        m_ui_manager(Gtk::UIManager::create() ),
-        m_lang_manager(Gtk::SourceLanguagesManager::create() )
+        m_ui_manager(Gtk::UIManager::create() )
 {
         // Assign auto actions
@@ -600 +600 @@
         // Get available languages
         std::list<Glib::RefPtr<Gtk::SourceLanguage> > lang_list =
-                m_lang_manager->get_available_languages();
+                lang_mgr->get_available_languages();
 
         // Sort languages by name
@@ -708 +708 @@
 }
 
+#if 0
 Glib::RefPtr<Gtk::SourceLanguagesManager> Gobby::Header::get_lang_manager()
 {
@@ -718 +719 @@
         return m_lang_manager;
 }
+#endif
 
 Gtk::MenuBar& Gobby::Header::get_menubar()

src/preferences.cpp

@@ -19 +19 @@
 #include "preferences.hpp"
 
+Gobby::Preferences::Editor::Editor()
+{
+}
+
+Gobby::Preferences::Editor::Editor(Config::Entry& entry):
+        tab_width(entry["tab"]["width"].get<unsigned int>(8)),
+        tab_spaces(entry["tab"]["spaces"].get<bool>(false)),
+        indentation_auto(entry["indentation"]["auto"].get<bool>(true)),
+        homeend_smart(entry["homeend"]["smart"].get<bool>(true) )
+{
+}
+
+void Gobby::Preferences::Editor::serialise(Config::Entry& entry) const
+{
+        entry["tab"]["width"].set(tab_width);
+        entry["tab"]["spaces"].set(tab_spaces);
+        entry["indentation"]["auto"].set(indentation_auto);
+        entry["homeend"]["smart"].set(homeend_smart);
+}
+
+Gobby::Preferences::View::View()
+{
+}
+
+Gobby::Preferences::View::View(Config::Entry& entry):
+        wrap_text(entry["wrap"]["text"].get<bool>(true) ),
+        wrap_words(entry["wrap"]["words"].get<bool>(true) ),
+        linenum_display(entry["linenum"]["display"].get<bool>(true) ),
+        curline_highlight(entry["curline"]["highlight"].get<bool>(true) ),
+        margin_display(entry["margin"]["display"].get<bool>(true) ),
+        margin_pos(entry["margin"]["pos"].get<unsigned int>(80) ),
+        bracket_highlight(entry["bracket"]["highlight"].get<bool>(true) )
+{
+}
+
+void Gobby::Preferences::View::serialise(Config::Entry& entry) const
+{
+        entry["wrap"]["text"].set(wrap_text);
+        entry["wrap"]["words"].set(wrap_words);
+        entry["linenum"]["display"].set(linenum_display);
+        entry["curline"]["highlight"].set(curline_highlight);
+        entry["margin"]["display"].set(margin_display);
+        entry["margin"]["pos"].set(margin_pos);
+        entry["bracket"]["highlight"].set(bracket_highlight);
+}
+
+Gobby::Preferences::Appearance::Appearance()
+{
+}
+
+Gobby::Preferences::Appearance::Appearance(Config::Entry& entry):
+        toolbar_show(
+                static_cast<Gtk::ToolbarStyle>(
+                        entry["toolbar"]["show"].get<int>(
+                                static_cast<int>(Gtk::TOOLBAR_BOTH)
+                        )
+                )
+        ),
+        remember(entry["windows"]["remember"].get<bool>(true) )
+{
+}
+
+void Gobby::Preferences::Appearance::serialise(Config::Entry& entry) const
+{
+        entry["toolbar"]["show"].set(static_cast<int>(toolbar_show) );
+        entry["windows"]["remember"].set(remember);
+}
+
+Gobby::Preferences::FileList::iterator::iterator(const base_iterator iter):
+        m_iter(iter)
+{
+}
+
+Gobby::Preferences::FileList::iterator&
+Gobby::Preferences::FileList::iterator::operator++()
+{
+        ++ m_iter;
+        return *this;
+}
+
+Gobby::Preferences::FileList::iterator
+Gobby::Preferences::FileList::iterator::operator++(int)
+{
+        iterator temp(m_iter);
+        ++ *this;
+        return temp;
+}
+
+const Glib::ustring& Gobby::Preferences::FileList::iterator::pattern() const
+{
+        return m_iter->first;
+}
+
+const Gobby::Preferences::Language&
+Gobby::Preferences::FileList::iterator::language() const
+{
+        return m_iter->second;
+}
+
+Gobby::Preferences::FileList::FileList()
+{
+}
+
+Gobby::Preferences::FileList::FileList(Config::Entry& entry,
+                                       const LangManager& lang_mgr)
+{
+        if(entry.begin() != entry.end() )
+        {
+                for(Config::Entry::iterator iter = entry.begin();
+                    iter != entry.end();
+                    ++ iter)
+                {
+                        Config::Entry& ent = iter.entry();
+
+                        Glib::ustring pattern =
+                                ent["pattern"].get<Glib::ustring>("unknown");
+                        Glib::ustring mime =
+                                ent["mime_type"].get<Glib::ustring>("unknown");
+
+                        Glib::RefPtr<Gtk::SourceLanguage> lang =
+                                lang_mgr->get_language_from_mime_type(mime);
+
+                        if(lang) m_files[pattern] = lang;
+                }
+        }
+        else
+        {
+                // Default list
+                add_by_mime_type("*.ada", "text/x-ada", lang_mgr);
+                add_by_mime_type("*.ada", "text/x-ada", lang_mgr);
+                add_by_mime_type("*.c", "text/x-c", lang_mgr);
+                add_by_mime_type("*.h", "text/x-c++", lang_mgr);
+                add_by_mime_type("*.hh", "text/x-c++", lang_mgr);
+                add_by_mime_type("*.cpp", "text/x-c++", lang_mgr);
+                add_by_mime_type("*.hpp", "text/x-c++", lang_mgr);
+                add_by_mime_type("*.cc", "text/x-c++", lang_mgr);
+                add_by_mime_type("*.cs", "text/x-csharp", lang_mgr);
+                add_by_mime_type("*.css", "text/css", lang_mgr);
+                add_by_mime_type("*.diff", "text/x-diff", lang_mgr);
+                add_by_mime_type("*.patch", "text/x-diff", lang_mgr);
+                add_by_mime_type("*.f", "text/x-fortran", lang_mgr);
+                add_by_mime_type("*.f77", "text/x-fortran", lang_mgr);
+                add_by_mime_type("*.hs", "text/x-haskell", lang_mgr);
+                add_by_mime_type("*.htm", "text/html", lang_mgr);
+                add_by_mime_type("*.html", "text/html", lang_mgr);
+                add_by_mime_type("*.xhtml", "text/html", lang_mgr);
+                add_by_mime_type("*.idl", "text/x-idl", lang_mgr);
+                add_by_mime_type("*.java", "text/x-java", lang_mgr);
+                add_by_mime_type("*.js", "text/x-javascript", lang_mgr);
+                add_by_mime_type("*.tex", "text/x-tex", lang_mgr);
+                add_by_mime_type("*.latex", "text/x-tex", lang_mgr);
+                add_by_mime_type("*.lua", "text/x-lua", lang_mgr);
+                add_by_mime_type("*.dpr", "text/x-pascal", lang_mgr);
+                add_by_mime_type("*.pas", "text/x-pascal", lang_mgr);
+                add_by_mime_type("*.pl", "text/x-perl", lang_mgr);
+                add_by_mime_type("*.pm", "text/x-perl", lang_mgr);
+                add_by_mime_type("*.php", "text/x-php", lang_mgr);
+                add_by_mime_type("*.php3", "text/x-php", lang_mgr);
+                add_by_mime_type("*.php4", "text/x-php", lang_mgr);
+                add_by_mime_type("*.php5", "text/x-php", lang_mgr);
+                add_by_mime_type(
+                        "*.po",
+                        "text/x-gettext-translation",
+                        lang_mgr
+                );
+                add_by_mime_type("*.py", "text/x-python", lang_mgr);
+                add_by_mime_type("*.rb", "text/x-ruby", lang_mgr);
+                add_by_mime_type("*.sql", "text/x-sql", lang_mgr);
+                add_by_mime_type("*.texi", "text/x-texinfo", lang_mgr);
+                add_by_mime_type("*.bas", "text/x-vb", lang_mgr);
+                add_by_mime_type("*.vbs", "text/x-vb", lang_mgr);
+                add_by_mime_type("*.v", "text/x-verilog-src", lang_mgr);
+                add_by_mime_type("*.xml", "text/xml", lang_mgr);
+                add_by_mime_type(
+                        "*.desktop",
+                        "application/x-gnome-app-info",
+                        lang_mgr
+                );
+                add_by_mime_type("*.tcl", "text/x-tcl", lang_mgr);
+                add_by_mime_type("Makefile", "text/x-Maxefile", lang_mgr);
+        }
+}
+
+void Gobby::Preferences::FileList::serialise(Config::Entry& entry) const
+{
+        int num = 0;
+
+        for(map_type::const_iterator iter = m_files.begin();
+            iter != m_files.end();
+            ++ iter)
+        {
+                std::stringstream stream;
+                stream << "file" << (++num);
+
+                std::list<Glib::ustring> mime_types =
+                        iter->second->get_mime_types();
+
+                Config::Entry& main = entry[stream.str()];
+
+                main["pattern"].set(iter->first);
+                main["mime_type"].set(mime_types.front());
+        }
+}
+
+Gobby::Preferences::FileList::iterator
+Gobby::Preferences::FileList::add(const Glib::ustring& pattern,
+                                  const Language& lang)
+{
+        //map_type::iterator iter = m_files.find(pattern);
+        //if(iter != m_files.end() ) return iter;
+        return iterator(m_files.insert(std::make_pair(pattern, lang) ).first);
+}
+
+Gobby::Preferences::FileList::iterator
+Gobby::Preferences::FileList::add_by_mime_type(const Glib::ustring& pattern,
+                                               const Glib::ustring& mime_type,
+                                               const LangManager& lang_mgr)
+{
+        Glib::RefPtr<Gtk::SourceLanguage> lang =
+                lang_mgr->get_language_from_mime_type(mime_type);
+
+        if(lang)
+                return add(pattern, lang);
+        else
+                return iterator(m_files.end());
+}
+
+Gobby::Preferences::FileList::iterator
+Gobby::Preferences::FileList::begin() const
+{
+        return iterator(m_files.begin() );
+}
+
+Gobby::Preferences::FileList::iterator
+Gobby::Preferences::FileList::end() const
+{
+        return iterator(m_files.end() );
+}
+
 Gobby::Preferences::Preferences()
 {
@@ -24 +263 @@
 }
 
-Gobby::Preferences::Preferences(Config& config)
-{
-        // Read preferences from config
-        editor.tab_width =
-                config["editor"]["tab"]["width"].get<unsigned int>(8);
-        editor.tab_spaces = config["editor"]["tab"]["spaces"].get<bool>(false);
-        editor.indentation_auto =
-                config["editor"]["indentation"]["auto"].get<bool>(true);
-        editor.homeend_smart =
-                config["editor"]["homeend"]["smart"].get<bool>(true);
-
-        view.wrap_text = config["view"]["wrap"]["text"].get<bool>(true);
-        view.wrap_words = config["view"]["wrap"]["words"].get<bool>(true);
-        view.linenum_display =
-                config["view"]["linenum"]["display"].get<bool>(true);
-        view.curline_highlight =
-                config["view"]["curline"]["highlight"].get<bool>(true);
-        view.margin_display =
-                config["view"]["margin"]["display"].get<bool>(true);
-        view.margin_pos =
-                config["view"]["margin"]["pos"].get<unsigned int>(80);
-        view.bracket_highlight =
-                config["view"]["bracket"]["highlight"].get<bool>(true);
-
-        appearance.toolbar_show = static_cast<Gtk::ToolbarStyle>(
-                config["appearance"]["toolbar"]["show"].get<int>(
-                        static_cast<int>(Gtk::TOOLBAR_BOTH)
-                )
-        );
-        appearance.remember =
-                config["appearance"]["windows"]["remember"].get<bool>(true);
-}
-
-Gobby::Preferences::Preferences(const Preferences& other)
-{
-        *this = other;
-}
-
-Gobby::Preferences::~Preferences()
-{
-}
-
-void Gobby::Preferences::serialise(Config& config)
+Gobby::Preferences::Preferences(Config& config, const LangManager& lang_mgr):
+        editor(config["editor"]),
+        view(config["view"]),
+        appearance(config["appearance"]),
+        files(config["files"], lang_mgr)
+{
+}
+
+void Gobby::Preferences::serialise(Config& config) const
 {
         // Serialise into config
-        config["editor"]["tab"]["width"].set(editor.tab_width);
-        config["editor"]["tab"]["spaces"].set(editor.tab_spaces);
-        config["editor"]["indentation"]["auto"].set(editor.indentation_auto);
-        config["editor"]["homeend"]["smart"].set(editor.homeend_smart);
-
-        config["view"]["wrap"]["text"].set(view.wrap_text);
-        config["view"]["wrap"]["words"].set(view.wrap_words);
-        config["view"]["linenum"]["display"].set(view.linenum_display);
-        config["view"]["curline"]["highlight"].set(view.curline_highlight);
-        config["view"]["margin"]["display"].set(view.margin_display);
-        config["view"]["margin"]["pos"].set(view.margin_pos);
-        config["view"]["bracket"]["highlight"].set(view.bracket_highlight);
-
-        config["appearance"]["toolbar"]["show"].set(
-                static_cast<int>(appearance.toolbar_show) );
-        config["appearance"]["windows"]["remember"].set(appearance.remember);
-}
-
-Gobby::Preferences& Gobby::Preferences::operator=(const Preferences& other)
-{
-        editor = other.editor;
-        view = other.view;
-        appearance = other.appearance;
-
-        return *this;
-}
-
+        editor.serialise(config["editor"]);
+        view.serialise(config["view"]);
+        appearance.serialise(config["appearance"]);
+        files.serialise(config["files"]);
+}

src/window.cpp

@@ -51 +51 @@
 Gobby::Window::Window(const IconManager& icon_mgr, Config& config):
         Gtk::Window(Gtk::WINDOW_TOPLEVEL), m_config(config),
-        m_preferences(m_config), m_icon_mgr(icon_mgr),
+        m_lang_manager(Gtk::SourceLanguagesManager::create() ),
+        m_preferences(m_config, m_lang_manager), m_icon_mgr(icon_mgr),
 #ifdef WITH_HOWL
         m_zeroconf(NULL),
 #endif
         m_application_state(APPLICATION_NONE),
-        m_document_settings(*this), m_header(m_application_state),
+        m_document_settings(*this),
+        m_header(m_application_state, m_lang_manager),
         m_userlist(*this, m_header, m_preferences, config["windows"]),
         m_documentlist(
@@ -472 +474 @@
         dlg.get_vbox()->pack_start(m_chk_default_ext, Gtk::PACK_SHRINK);
         // This option confuses the overwrite confirmation :/
-//      m_chk_default_ext.show();
+        //m_chk_default_ext.show();
 
 #ifdef GTKMM_GEQ_28
@@ -529 +531 @@
         dlg.set_version(PACKAGE_VERSION);
         dlg.set_comments(_("A collaborative text editor"));
-        dlg.set_copyright("Copyright (C) 2005 0x539 dev group <crew@0x539.de>");
+
+        dlg.set_copyright(
+                "Copyright (C) 2005, 2006 0x539 dev "
+                "group <crew@0x539.de>"
+        );
+
         dlg.set_logo(m_icon_mgr.gobby);
 
@@ -986 +993 @@
         {
                 // Quit session
-                obby_end();
+                if(m_buffer.get() != NULL && m_buffer->is_open() )
+                        obby_end();
                 // End program
                 Gtk::Main::quit();