Context Navigation

← Previous Changeset
Next Changeset →

Changeset 0a50e4462d8d144fea8ba7b0c44c2dde2aee87a3

Timestamp:

03/02/08 22:50:40 (5 years ago)

Author:

Armin Burgmeier <armin@…>

Parents:

5bb3ff6db213aceeb68df6620c9184a83d8d891e

Children:

99231c78b8defa19332fbca4349f7cb0675b0e81

git-committer:

Armin Burgmeier <armin@0x539.de> / 2008-03-02T21:50:40Z+0000

Message:

2008-03-02 Armin Burgmeier <armin@…>

configure.ac: Require at least gtkmm 2.12, drop gtksourceview1 support, post-branch-bump to 0.4.90.

inc/preferences.hpp:
src/preferences.cpp: Removed options not required for infinote, added user preferences page.

inc/preferencesdialog.hpp:
src/preferencesdialog.cpp: Adapted and redesigned preferences dialog to better meet the Gnome HIG. Currently disfunctional.

inc/header.hpp:
inc/folder.hpp:
inc/docwindow.hpp:
inc/window.hpp:
src/header.cpp:
src/folder.cpp:
src/chat.cpp:
src/togglewindow.cpp:
src/docwindow.cpp:
src/window.cpp: Adapt.

Files:

: 16 modified

ChangeLog (modified) (1 diff)
configure.ac (modified) (2 diffs)
inc/docwindow.hpp (modified) (2 diffs)
inc/folder.hpp (modified) (2 diffs)
inc/header.hpp (modified) (1 diff)
inc/preferences.hpp (modified) (6 diffs)
inc/preferencesdialog.hpp (modified) (8 diffs)
inc/window.hpp (modified) (2 diffs)
src/chat.cpp (modified) (1 diff)
src/docwindow.cpp (modified) (8 diffs)
src/folder.cpp (modified) (2 diffs)
src/header.cpp (modified) (2 diffs)
src/preferences.cpp (modified) (7 diffs)
src/preferencesdialog.cpp (modified) (9 diffs)
src/togglewindow.cpp (modified) (4 diffs)
src/window.cpp (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed

ChangeLog

r5bc7ec4	r0a50e446
	1	2008-03-02 Armin Burgmeier <armin@0x539.de>
	2
	3	* configure.ac: Require at least gtkmm 2.12, drop gtksourceview1
	4	support, post-branch-bump to 0.4.90.
	5
	6	* inc/preferences.hpp:
	7	* src/preferences.cpp: Removed options not required for infinote,
	8	added user preferences page.
	9
	10	* inc/preferencesdialog.hpp:
	11	* src/preferencesdialog.cpp: Adapted and redesigned preferences
	12	dialog to better meet the Gnome HIG. Currently disfunctional.
	13
	14	* inc/header.hpp:
	15	* inc/folder.hpp:
	16	* inc/docwindow.hpp:
	17	* inc/window.hpp:
	18	* src/header.cpp:
	19	* src/folder.cpp:
	20	* src/chat.cpp:
	21	* src/togglewindow.cpp:
	22	* src/docwindow.cpp:
	23	* src/window.cpp: Adapt.
	24
1	25	2008-01-31 Armin Burgmeier <armin@0x539.de>
2	26

configure.ac

rcfe2981	r0a50e446
3	3
4	4	AC_PREREQ(2.59)
5		AC_INIT([gobby], [0.4.6], [crew@0x539.de])
	5	AC_INIT([gobby], [0.4.90], [crew@0x539.de])
6	6	AM_INIT_AUTOMAKE(1.9 check-news)
7	7	AM_MAINTAINER_MODE
…	…
35	35	AM_CONDITIONAL(WIN32, test x$win32 = xtrue)
36	36
37		required_libs="libxml++-2.6 gtkmm-2.4 >= 2.6.0 gthread-2.0 net6-1.3 obby-0.4 >= 0.4.5"
38
39		# GtkSourceView2 support
40		AC_ARG_WITH([gtksourceview2],
41		AS_HELP_STRING([--with-gtksourceview2],
42		[whether to use gtksourceview2 instead of
43		gtksourceview1 [[default=no]]]),
44		[ac_cv_with_gtksourceview2=$withval],
45		[ac_cv_with_gtksourceview2=no])
46
47		AC_CACHE_CHECK([whether to use gtksourceview2 instead of gtksourceview1],
48		[ac_cv_with_gtksourceview2], [ac_cv_with_gtksourceview2=no])
49
50		if test "x$ac_cv_with_gtksourceview2" = "xyes" ; then
51		AC_DEFINE([WITH_GTKSOURCEVIEW2], 1,
52		[Define whether to use gtksourceview2 instead of gtksourceview1])
53		required_libs="$required_libs gtksourceview-2.0"
54		else
55		required_libs="$required_libs gtksourceview-1.0 >= 1.8"
56		fi
57
58		AM_CONDITIONAL(WITH_GTKSOURCEVIEW2, test x$ac_cv_with_gtksourceview2 != xno)
59		AC_CACHE_SAVE
	37	required_libs="libxml++-2.6 gtkmm-2.4 >= 2.12.0 gthread-2.0 net6-1.3 obby-0.4 >= 0.4.5 gtksourceview-2.0"
60	38
61	39	# Checks for libraries.
62	40	PKG_CHECK_MODULES([gobby], [$required_libs])
63		~~AC_CACHE_SAVE~~
64
65		~~# Check for the Gtkmm version available (either 2.6 or 2.8).~~
66		~~PKG_CHECK_GTKMM~~
67		~~if test "x$GTKMM_VER" = "x28" ; then~~
68		~~AC_DEFINE([GTKMM_GEQ_28], 1, [Defined if Gtkmm's version is 2.8 or greater])~~
69		fi
70	41	AC_CACHE_SAVE
71	42

inc/docwindow.hpp

r4cf90bd	r0a50e446
21	21
22	22	#include <gtkmm/scrolledwindow.h>
	23
23	24	#include <gtksourceview/gtksourceview.h>
	25	#include <gtksourceview/gtksourcelanguagemanager.h>
24	26
25	27	#include "features.hpp"
…	…
44	46	* The preferences are initially applied to the DocWindow.
45	47	*/
46		DocWindow(LocalDocumentInfo& info, const Preferences& preferences);
	48	DocWindow(LocalDocumentInfo& info, const Preferences& preferences,
	49	GtkSourceLanguageManager* manager);
47	50
48	51	/** @brief Returns the current cursor position in <em>row</em>

inc/folder.hpp

r35e39f6	r0a50e446
83	83	signal_tab_switched_type;
84	84
85		Folder(Header& header, const Preferences& preferences);
	85	Folder(Header& header, const Preferences& preferences,
	86	GtkSourceLanguageManager* lang_manager);
86	87
87	88	#if 0
…	…
189	190	const Preferences& m_preferences;
190	191
	192	GtkSourceLanguageManager* m_lang_manager;
	193
191	194	/** Contains a pointer to the current active obby buffer.
192	195	*/

inc/header.hpp

r4cf90bd	r0a50e446
28	28	#include <gtkmm/toolbar.h>
29	29
30		#include ~~"preferences.hpp" // Defines GtkSourceLanguageManager (gtksourceview1)~~
	30	#include <gtksourceview/gtksourcelanguagemanager.h>
31	31	#include "application_state.hpp"
32	32

inc/preferences.hpp

r4cf90bd	r0a50e446
1	1	/* gobby - A GTKmm driven libobby client
2		* Copyright (C) 2005~~, 2006~~ 0x539 dev group
	2	* Copyright (C) 2005 - 2008 0x539 dev group
3	3	*
4	4	* This program is free software; you can redistribute it and/or
…	…
24	24	#include "config.hpp"
25	25
26		~~#include <gtksourceview/gtksourcelanguage.h>~~
27
28		~~#ifdef WITH_GTKSOURCEVIEW2~~
29		~~# include <gtksourceview/gtksourcelanguagemanager.h>~~
30		~~#else~~
31		~~# include <gtksourceview/gtksourcelanguagesmanager.h>~~
32		~~#endif~~
33
34		~~#ifndef WITH_GTKSOURCEVIEW2~~
35		~~typedef GtkSourceLanguagesManager GtkSourceLanguageManager;~~
36		~~#endif~~
37
38	26	namespace Gobby
39	27	{
…	…
42	30	{
43	31	public:
44		/** Uninitialised preferences.
45		*/
46		Preferences();
	32	template<typename Type>
	33	class Option
	34	{
	35	public:
	36	typedef sigc::signal<void> signal_changed_type;
	37
	38	Option(const Type& initial_value):
	39	m_value(initial_value) {}
	40
	41	const Option<Type>& operator=(const Type& new_value)
	42	{
	43	m_value = new_value;
	44	notify();
	45	return *this;
	46	}
	47
	48	operator const Type&() const
	49	{
	50	return m_value;
	51	}
	52
	53	operator Type&()
	54	{
	55	return m_value;
	56	}
	57
	58	signal_changed_type signal_changed() const
	59	{
	60	return m_signal_changed;
	61	}
	62
	63	void notify() const
	64	{
	65	m_signal_changed.emit();
	66	}
	67
	68	protected:
	69	Type m_value;
	70	signal_changed_type m_signal_changed;
	71	};
47	72
48	73	/** Reads preferences values out of a config, using default values
49	74	* for values that do not exist in the config.
50	75	*/
51		Preferences(Config& m_config~~, GtkSourceLanguageManager* lang_mgr~~);
	76	Preferences(Config& m_config);
52	77
53	78	/** Serialises preferences back to config.
…	…
55	80	void serialise(Config& config) const;
56	81
	82	class User
	83	{
	84	public:
	85	User(Config::ParentEntry& entry);
	86	void serialise(Config::ParentEntry& entry) const;
	87
	88	Option<Glib::ustring> name;
	89	Option<double> hue;
	90	Option<std::string> host_directory;
	91	};
	92
57	93	class Editor
58	94	{
59	95	public:
60		~~Editor();~~
61	96	Editor(Config::ParentEntry& entry);
62	97	void serialise(Config::ParentEntry& entry) const;
63	98
64		~~unsigned int~~ tab_width;
65		~~bool~~ tab_spaces;
66		~~bool~~ indentation_auto;
67		~~bool~~ homeend_smart;
	99	Option<unsigned int> tab_width;
	100	Option<bool> tab_spaces;
	101	Option<bool> indentation_auto;
	102	Option<bool> homeend_smart;
68	103	};
69	104
…	…
71	106	{
72	107	public:
73		~~View();~~
74	108	View(Config::ParentEntry& entry);
75	109	void serialise(Config::ParentEntry& entry) const;
76	110
77		bool wrap_text;
78		bool wrap_words;
79		bool linenum_display;
80		bool curline_highlight;
81		bool margin_display;
82		unsigned int margin_pos;
83		bool bracket_highlight;
	111	Option<Gtk::WrapMode> wrap_mode;
	112	Option<bool> linenum_display;
	113	Option<bool> curline_highlight;
	114	Option<bool> margin_display;
	115	Option<unsigned int> margin_pos;
	116	Option<bool> bracket_highlight;
84	117	};
85	118
…	…
87	120	{
88	121	public:
89		~~Appearance();~~
90	122	Appearance(Config::ParentEntry& entry);
91	123	void serialise(Config::ParentEntry& entry) const;
92	124
93		Gtk::ToolbarStyle toolbar_show;
94		bool remember;
95		bool urgency_hint;
	125	Option<Gtk::ToolbarStyle> toolbar_show;
	126	Option<Pango::FontDescription> font;
96	127	};
97	128
98		class Font
99		{
100		public:
101		Font();
102		Font(Config::ParentEntry& entry);
103		void serialise(Config::ParentEntry& entry) const;
104
105		Pango::FontDescription desc;
106		};
107
108		class Behaviour
109		{
110		public:
111		Behaviour();
112		Behaviour(Config::ParentEntry& entry);
113		void serialise(Config::ParentEntry& entry) const;
114
115		bool auto_open_new_documents;
116		};
117
118		class FileList
119		{
120		public:
121		typedef std::map<Glib::ustring, GtkSourceLanguage*> map_type;
122
123		class iterator
124		{
125		private:
126		typedef map_type::const_iterator base_iterator;
127
128		public:
129		iterator(base_iterator iter);
130
131		iterator& operator++();
132		iterator operator++(int);
133
134		bool operator==(const iterator& other) const;
135		bool operator!=(const iterator& other) const;
136
137		const Glib::ustring& pattern() const;
138		GtkSourceLanguage* language() const;
139		private:
140		base_iterator m_iter;
141		};
142
143		FileList();
144		FileList(Config::ParentEntry& entry,
145		GtkSourceLanguageManager* lang_mgr);
146		FileList(const FileList& src);
147		~FileList();
148
149		void serialise(Config::ParentEntry& entry) const;
150
151		// This function may also return an already existing iterator
152		// when pattern is already in the map. Compare lang to be sure
153		// that the entry actually has been inserted.
154		iterator add(const Glib::ustring& pattern,
155		GtkSourceLanguage* lang);
156
157		iterator begin() const;
158		iterator end() const;
159		protected:
160		#ifndef WITH_GTKSOURCEVIEW2
161		iterator add_by_mime_type(const Glib::ustring& pattern,
162		const Glib::ustring& mime_type,
163		GtkSourceLanguageManager* lang_mgr);
164		#endif
165
166		map_type m_files;
167		};
168
	129	User user;
169	130	Editor editor;
170	131	View view;
171	132	Appearance appearance;
172		~~Font font;~~
173		~~Behaviour behaviour;~~
174		~~FileList files;~~
175	133	};
	134
	135	template<typename Type>
	136	std::ostream& operator<<(std::ostream& stream,
	137	const Preferences::Option<Type>& option)
	138	{
	139	stream << static_cast<const Type&>(option);
	140	return stream;
	141	}
176	142
177	143	}
178	144
179	145	#endif // _GOBBY_PREFERENCES_HPP_
180

inc/preferencesdialog.hpp

r3752fd8	r0a50e446
23	23	#include <gtkmm/frame.h>
24	24	#include <gtkmm/box.h>
25		~~#include <gtkmm/expander.h>~~
26	25	#include <gtkmm/label.h>
27	26	#include <gtkmm/spinbutton.h>
…	…
29	28	#include <gtkmm/comboboxtext.h>
30	29	#include <gtkmm/notebook.h>
31		#include <gtkmm/tooltips.h>
32		#include <gtkmm/liststore.h>
33		#include <gtkmm/treeview.h>
34		#include <gtkmm/cellrenderercombo.h>
35		#include <gtkmm/scrolledwindow.h>
36		#include <gtkmm/fontselection.h>
	30	#include <gtkmm/alignment.h>
	31	#include <gtkmm/filechooserbutton.h>
	32	#include <gtkmm/fontbutton.h>
	33	#include <gtkmm/colorbutton.h>
37	34	#include "preferences.hpp"
38	35
…	…
43	40	{
44	41	public:
	42	class Group: public Gtk::Frame
	43	{
	44	public:
	45	Group(const Glib::ustring& title);
	46	void add(Gtk::Widget& widget);
	47
	48	protected:
	49	Gtk::Alignment m_alignment;
	50	Gtk::VBox m_box;
	51	};
	52
45	53	class Page: public Gtk::Frame
46	54	{
47	55	public:
48	56	Page();
	57	void add(Gtk::Widget& widget);
49	58
50	59	protected:
	60	Gtk::VBox m_box;
	61	};
	62
	63	class User: public Page
	64	{
	65	public:
	66	User(const Preferences& preferences);
	67
	68	protected:
	69	Group m_group_settings;
	70	Group m_group_paths;
	71
	72	Gtk::HBox m_box_user_name;
	73	Gtk::Label m_lbl_user_name;
	74	Gtk::Entry m_ent_user_name;
	75
	76	Gtk::HBox m_box_user_color;
	77	Gtk::Label m_lbl_user_color;
	78	Gtk::ColorButton m_btn_user_color;
	79
	80	Gtk::HBox m_box_path_host_directory;
	81	Gtk::Label m_lbl_path_host_directory;
	82	Gtk::FileChooserButton m_btn_path_host_directory;
51	83	};
52	84
…	…
54	86	{
55	87	public:
56		~~#ifndef GTKMM_DISABLE_DEPRECATED~~
57		~~Editor(const Preferences& preferences,~~
58		~~Gtk::Tooltips& tooltips);~~
59		~~#else~~
60	88	Editor(const Preferences& preferences);
61		~~#endif~~
62
63		~~void set(Preferences::Editor& editor) const;~~
64	89
65	90	protected:
66		Gtk::VBox m_box;
67		Gtk::Frame m_frame_tab;
68		Gtk::Frame m_frame_indentation;
69		Gtk::Frame m_frame_homeend;
	91	Group m_group_tab;
	92	Group m_group_indentation;
	93	Group m_group_homeend;
70	94
71		~~Gtk::VBox m_box_tab;~~
72	95	Gtk::HBox m_box_tab_width;
73	96	Gtk::Label m_lbl_tab_width;
…	…
75	98	Gtk::CheckButton m_btn_tab_spaces;
76	99
77		~~Gtk::VBox m_box_indentation;~~
78	100	Gtk::CheckButton m_btn_indentation_auto;
79	101
80		~~Gtk::VBox m_box_homeend;~~
81	102	Gtk::CheckButton m_btn_homeend_smart;
82	103	};
…	…
89	110
90	111	protected:
91		virtual void on_margin_display_toggled();
	112	void on_wrap_text_toggled();
	113	void on_margin_display_toggled();
92	114
93		Gtk::VBox m_box;
94		Gtk::Frame m_frame_wrap;
95		Gtk::Frame m_frame_linenum;
96		Gtk::Frame m_frame_curline;
97		Gtk::Frame m_frame_margin;
98		Gtk::Frame m_frame_bracket;
	115	Group m_group_wrap;
	116	Group m_group_linenum;
	117	Group m_group_curline;
	118	Group m_group_margin;
	119	Group m_group_bracket;
99	120
100		~~Gtk::VBox m_box_wrap;~~
101	121	Gtk::CheckButton m_btn_wrap_text;
102	122	Gtk::CheckButton m_btn_wrap_words;
103	123
104		~~Gtk::VBox m_box_linenum;~~
105	124	Gtk::CheckButton m_btn_linenum_display;
106	125
107		~~Gtk::VBox m_box_curline;~~
108	126	Gtk::CheckButton m_btn_curline_highlight;
109	127
110		~~Gtk::VBox m_box_margin;~~
111	128	Gtk::CheckButton m_btn_margin_display;
112	129	Gtk::HBox m_box_margin_pos;
…	…
114	131	Gtk::SpinButton m_ent_margin_pos;
115	132
116		~~Gtk::VBox m_box_bracket;~~
117	133	Gtk::CheckButton m_btn_bracket_highlight;
118	134	};
…	…
122	138	public:
123	139	Appearance(const Preferences& preferences);
124		~~void set(Preferences::Appearance& appearance) const;~~
125	140
126	141	protected:
127		Gtk::VBox m_box;
128		Gtk::Frame m_frame_toolbar;
129		Gtk::Frame m_frame_windows;
	142	Group m_group_toolbar;
	143	Group m_group_font;
130	144
131		~~Gtk::VBox m_box_toolbar;~~
132	145	Gtk::ComboBoxText m_cmb_toolbar_style;
133	146
134		Gtk::VBox m_box_windows;
135		Gtk::CheckButton m_btn_remember;
136		Gtk::CheckButton m_btn_urgency_hint;
137		};
138
139		class Font: public Page
140		{
141		public:
142		Font(const Preferences& preferences);
143		void set(Preferences::Font& font) const;
144
145		protected:
146		void on_fontsel_realize();
147
148		Gtk::FontSelection m_font_sel;
149		Glib::ustring m_init_font;
150		};
151
152		class Behaviour: public Page
153		{
154		public:
155		Behaviour(const Preferences& preferences);
156		void set(Preferences::Behaviour& behaviour) const;
157
158		protected:
159		Gtk::VBox m_box;
160
161		Gtk::Frame m_frame_documents;
162		Gtk::VBox m_box_documents;
163		Gtk::CheckButton m_btn_auto_open;
164		};
165
166		class FileList: public Page
167		{
168		public:
169		// List of languages. TODO: Should be somewhere else
170		class LanguageColumns: public Gtk::TreeModel::ColumnRecord
171		{
172		public:
173		LanguageColumns();
174
175		Gtk::TreeModelColumn<GtkSourceLanguage*> language;
176		Gtk::TreeModelColumn<Glib::ustring> language_name;
177		};
178
179		class FileColumns: public Gtk::TreeModel::ColumnRecord
180		{
181		public:
182		FileColumns();
183
184		Gtk::TreeModelColumn<Glib::ustring> pattern;
185		Gtk::TreeModelColumn<Glib::ustring> mime_type;
186		Gtk::TreeModelColumn<Gtk::TreeIter> language;
187		};
188
189		FileList(Gtk::Window& parent,
190		const Preferences& preferences,
191		GtkSourceLanguageManager* lang_mgr);
192
193		void set(Preferences::FileList& files) const;
194
195		const LanguageColumns lang_columns;
196		const FileColumns file_columns;
197
198		protected:
199		struct LangCompare
200		{
201		bool operator()(GtkSourceLanguage* first, GtkSourceLanguage* second)
202		{
203		return first < second;
204		}
205		};
206
207		typedef std::map<
208		GtkSourceLanguage*,
209		Gtk::TreeIter,
210		LangCompare
211		> map_type;
212
213		void cell_data_file_language(Gtk::CellRenderer* renderer,
214		const Gtk::TreeIter& iter);
215
216		void on_pattern_edited(const Glib::ustring& path,
217		const Glib::ustring& new_text);
218		void on_mimetype_edited(const Glib::ustring& path,
219		const Glib::ustring& new_text);
220		void on_language_edited(const Glib::ustring& path,
221		const Glib::ustring& new_text);
222
223		void on_selection_changed();
224
225		void on_file_add();
226		void on_file_remove();
227
228		void set_language(const Gtk::TreeIter& row,
229		GtkSourceLanguage* lang);
230
231		Gtk::Window& m_parent;
232		GtkSourceLanguageManager* m_lang_mgr;
233
234		Gtk::CellRendererText* m_renderer_pattern;
235		Gtk::CellRendererCombo m_renderer_lang;
236		Gtk::CellRendererText* m_renderer_mimetype;
237
238		Gtk::TreeViewColumn m_viewcol_pattern;
239		Gtk::TreeViewColumn m_viewcol_lang;
240		Gtk::TreeViewColumn m_viewcol_mimetype;
241
242		Gtk::VBox m_vbox;
243		Gtk::Label m_intro;
244		Gtk::ScrolledWindow m_wnd;
245		Gtk::TreeView m_view;
246
247		Gtk::HButtonBox m_hbox;
248		Gtk::Button m_btn_add;
249		Gtk::Button m_btn_remove;
250
251		// Map for better access to iterators to the language list
252		map_type m_lang_map;
253
254		Glib::RefPtr<Gtk::ListStore> m_lang_list;
255		Glib::RefPtr<Gtk::ListStore> m_file_list;
	147	Gtk::FontButton m_btn_font;
256	148	};
257	149
258	150	PreferencesDialog(Gtk::Window& parent,
259		const Preferences& preferences,
260		GtkSourceLanguageManager* lang_mgr,
261		bool local);
262
263		void set(Preferences& preferences) const;
264
265		#if 0
266		const Editor& editor() const;
267		const View& view() const;
268		const Appearance& appearance() const;
269		#endif
	151	Preferences& preferences);
270	152
271	153	protected:
	154	virtual void on_response(int id);
	155
	156	Preferences& m_preferences;
	157
272	158	Gtk::Notebook m_notebook;
273	159
274		#ifndef GTKMM_DISABLE_DEPRECATED
275		Gtk::Tooltips m_tooltips;
276		#endif
277
	160	User m_page_user;
278	161	Editor m_page_editor;
279	162	View m_page_view;
280	163	Appearance m_page_appearance;
281		~~Font m_page_font;~~
282		~~Behaviour m_page_behaviour;~~
283		~~FileList m_page_files;~~
284	164	};
285	165

inc/window.hpp

r88d9d5e	r0a50e446
43	43	#include "finddialog.hpp"
44	44	#include "gotodialog.hpp"
	45	#include "preferencesdialog.hpp"
45	46	#include "folder.hpp"
46	47	#include "document_settings.hpp"
…	…
232	233
233	234	// Dialogs
	235	std::auto_ptr<PreferencesDialog> m_preferences_dlg;
234	236	std::auto_ptr<HostDialog> m_host_dlg;
235	237	std::auto_ptr<JoinDialog> m_join_dlg;

src/chat.cpp

r9d22d7c	r0a50e446
280	280
281	281	#ifdef GTKMM_GEQ_28
282		if(!m_focus && m_preferences.appearance.urgency_hint && is_visible())
283		m_parent.set_urgency_hint(true);
	282	// if(!m_focus && m_preferences.appearance.urgency_hint && is_visible())
	283	// m_parent.set_urgency_hint(true);
284	284	#endif
285	285	}

src/docwindow.cpp

r3c5bf1e	r0a50e446
22	22	#include <gtkmm/textview.h>
23	23
24		#ifdef WITH_GTKSOURCEVIEW2
25		# include <gtksourceview/gtksourcebuffer.h>
26		#endif
	24	#include <gtksourceview/gtksourcebuffer.h>
27	25
28	26	#include "preferences.hpp"
…	…
33	31	GtkWrapMode wrap_mode_from_preferences(const Gobby::Preferences& pref)
34	32	{
35		if(pref.view.wrap_text)
	33	return static_cast<GtkWrapMode>(static_cast<Gtk::WrapMode>(pref.view.wrap_mode));
	34	}
	35
	36	bool glob_matches(const gchar* const* globs, const std::string& str)
	37	{
	38	if(globs)
36	39	{
37		if(pref.view.wrap_words)
38		return GTK_WRAP_CHAR;
39		else
40		return GTK_WRAP_WORD;
	40	for(const gchar* const* glob = globs;
	41	*glob != NULL;
	42	++ glob)
	43	{
	44	Glib::PatternSpec spec(*glob);
	45	if(spec.match(str))
	46	return true;
	47	}
41	48	}
42		else
43		{
44		return GTK_WRAP_NONE;
45		}
	49
	50	return false;
46	51	}
47	52	}
48	53
49	54	Gobby::DocWindow::DocWindow(LocalDocumentInfo& info,
50		const Preferences& preferences):
	55	const Preferences& preferences,
	56	GtkSourceLanguageManager* manager):
51	57	m_view(GTK_SOURCE_VIEW(gtk_source_view_new())),
52	58	m_info(info), m_doc(info.get_content() ),
…	…
70	76	Glib::wrap(GTK_TEXT_BUFFER(buffer), true);
71	77
72		~~#ifdef WITH_GTKSOURCEVIEW2~~
73	78	// Set source language by filename
74	79	gtk_source_buffer_set_highlight_syntax(buffer, FALSE);
75		~~#else~~
76		~~gtk_source_buffer_set_highlight(buffer, FALSE);~~
77		~~#endif~~
78	80
79	81	// Enable indent-on-tab
80	82	gtk_source_view_set_indent_on_tab(m_view, TRUE);
81	83
82		~~for(Preferences::FileList::iterator iter = preferences.files.begin();~~
83		~~iter != preferences.files.end(~~);
84		++ iter)
85		{
86		~~Glib::PatternSpec spec(iter.pattern());~~
87		~~if(spec.match(info.get_title())~~ )
	84	const gchar* const* ids =
	85	gtk_source_language_manager_get_language_ids(manager);
	86
	87	if(ids)
	88	{
	89	for(const gchar* const* id = ids; *id != NULL; ++ id)
88	90	{
89		gtk_source_buffer_set_language(buffer, iter.language());
90		#ifdef WITH_GTKSOURCEVIEW2
91		gtk_source_buffer_set_highlight_syntax(buffer, TRUE);
92		#else
93		gtk_source_buffer_set_highlight(buffer, TRUE);
94		#endif
	91	GtkSourceLanguage* lang =
	92	gtk_source_language_manager_get_language(
	93	manager, *id);
	94
	95	if(lang)
	96	{
	97	gchar** globs = gtk_source_language_get_globs(lang);
	98	if(glob_matches(globs, info.get_title()))
	99	{
	100	set_language(lang);
	101	break;
	102	}
	103	g_strfreev(globs);
	104	}
95	105	}
96	106	}
97
98		~~#ifdef WITH_GTKSOURCEVIEW2~~
99		~~// Set a theme so we see anything.~~
100		~~// TODO: This should be temporary code until gtksourceview2 sets a default~~
101		~~// theme.~~
102		~~/* GtkSourceStyleManager* sm = gtk_source_style_manager_new();~~
103		~~GtkSourceStyleScheme* scheme = gtk_source_style_manager_get_scheme(sm, "gvim");~~
104		~~gtk_source_buffer_set_style_scheme(buffer, scheme);~~
105		~~g_object_unref(G_OBJECT(sm));*/~~
106		~~#endif~~
107	107
108	108	cpp_buffer->signal_mark_set().connect(
…	…
237	237
238	238	gtk_source_buffer_set_language(buffer, language);
239
240		~~#ifdef WITH_GTKSOURCEVIEW2~~
241	239	gtk_source_buffer_set_highlight_syntax(buffer, language != NULL);
242		~~#else~~
243		~~gtk_source_buffer_set_highlight(buffer, language != NULL);~~
244		~~#endif~~
245
246	240	m_signal_language_changed.emit();
247	241	}
…	…
360	354	GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_view));
361	355
362		~~#ifdef WITH_GTKSOURCEVIEW2~~
363	356	gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(m_view),
364	357	m_preferences.editor.tab_width);
365		~~#else~~
366		~~gtk_source_view_set_tabs_width(GTK_SOURCE_VIEW(m_view),~~
367		~~m_preferences.editor.tab_width);~~
368		~~#endif~~
369	358
370	359	gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(m_view),
…	…
372	361	gtk_source_view_set_auto_indent(GTK_SOURCE_VIEW(m_view),
373	362	m_preferences.editor.indentation_auto);
374		~~#ifdef WITH_GTKSOURCEVIEW2~~
375	363	gtk_source_view_set_smart_home_end(GTK_SOURCE_VIEW(m_view),
376	364	m_preferences.editor.homeend_smart ?
377	365	GTK_SOURCE_SMART_HOME_END_ALWAYS :
378	366	GTK_SOURCE_SMART_HOME_END_DISABLED);
379		~~#else~~
380		~~gtk_source_view_set_smart_home_end(GTK_SOURCE_VIEW(m_view),~~
381		~~m_preferences.editor.homeend_smart);~~
382		~~#endif~~
383	367
384	368	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_view),
…	…
388	372	gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(m_view),
389	373	m_preferences.view.curline_highlight);
390		~~#ifdef WITH_GTKSOURCEVIEW2~~
391	374	gtk_source_view_set_show_right_margin(GTK_SOURCE_VIEW(m_view),
392	375	m_preferences.view.margin_display);
…	…
395	378	gtk_source_buffer_set_highlight_matching_brackets(GTK_SOURCE_BUFFER(buffer),
396	379	m_preferences.view.bracket_highlight);
397		#else
398		gtk_source_view_set_show_margin(GTK_SOURCE_VIEW(m_view),
399		m_preferences.view.margin_display);
400		gtk_source_view_set_margin(GTK_SOURCE_VIEW(m_view),
401		m_preferences.view.margin_pos);
402		gtk_source_buffer_set_check_brackets(GTK_SOURCE_BUFFER(buffer),
403		m_preferences.view.bracket_highlight);
404		#endif
405
406		gtk_widget_modify_font(GTK_WIDGET(m_view), m_preferences.font.desc.gobj());
	380
	381	gtk_widget_modify_font(GTK_WIDGET(m_view), static_cast<Pango::FontDescription&>(m_preferences.appearance.font).gobj());
407	382
408	383	// Cursor position may have changed because of new tab width

src/folder.cpp

r4cf90bd	r0a50e446
114	114
115	115	Gobby::Folder::Folder(Header& header,
116		const Preferences& preferences):
	116	const Preferences& preferences,
	117	GtkSourceLanguageManager* lang_manager):
117	118	Gtk::Notebook(),
118	119	m_block_language(false), m_header(header), m_preferences(preferences),
119		m_buffer(NULL)
	120	m_lang_manager(lang_manager), m_buffer(NULL)
120	121	{
121	122	set_scrollable(true);
…	…
324	325	// Create new document
325	326	DocWindow* new_wnd =
326		Gtk::manage(new DocWindow(info, m_preferences) );
	327	Gtk::manage(new DocWindow(info, m_preferences, m_lang_manager) );
327	328
328	329	// Watch update signal to emit document_updated signal if a document

src/header.cpp

r7fdfee0	r0a50e446
615	615
616	616	// Get available languages
617		~~#ifdef WITH_GTKSOURCEVIEW2~~
618	617	GSList* lang_list = NULL;
619	618	const gchar* const* ids = gtk_source_language_manager_get_language_ids(lang_mgr);
…	…
626	625	}
627	626	}
628		~~#else~~
629		~~const GSList* list = gtk_source_languages_manager_get_available_languages(~~
630		~~lang_mgr);~~
631
632		~~// Copy the list, so we can sort languages by name~~
633		~~GSList* lang_list = g_slist_copy(const_cast<GSList*>(list));~~
634		~~#endif~~
635	627
636	628	lang_list = g_slist_sort(lang_list, &language_sort_callback);

src/preferences.cpp

r7fdfee0	r0a50e446
1	1	/* gobby - A GTKmm driven libobby client
2		* Copyright (C) 2005~~, 2006~~ 0x539 dev group
	2	* Copyright (C) 2005 - 2008 0x539 dev group
3	3	*
4	4	* This program is free software; you can redistribute it and/or
…	…
17	17	*/
18	18
19		~~#include <cstring>~~
20
21	19	#include "features.hpp"
22
23		~~#ifdef WITH_GTKSOURCEVIEW2~~
24		~~# include <gtksourceview/gtksourcelanguagemanager.h>~~
25		~~#else~~
26		~~# include <gtksourceview/gtksourcelanguagesmanager.h>~~
27		~~#endif~~
28	20	#include "preferences.hpp"
29	21
30		namespace
31		{
32		GtkSourceLanguage*
33		get_language_from_mime_type(GtkSourceLanguageManager* manager,
34		const gchar* mime_type)
35		{
36		#ifdef WITH_GTKSOURCEVIEW2
37		const gchar* const* ids = gtk_source_language_manager_get_language_ids(manager);
38		if(ids == NULL) return NULL;
39
40		for(const gchar* const* id = ids; *id != NULL; ++ id)
41		{
42		GtkSourceLanguage* language = gtk_source_language_manager_get_language(manager, *id);
43		g_assert(language != NULL);
44
45		gchar** mime_types =
46		gtk_source_language_get_mime_types(
47		GTK_SOURCE_LANGUAGE(language)
48		);
49
50		if(mime_types != NULL)
51		{
52		for(gchar** type = mime_types; *type != NULL; ++type)
53		{
54		if(strcmp(mime_type, *type) == 0)
55		{
56		g_strfreev(mime_types);
57		return language;
58		}
59		}
60
61		g_strfreev(mime_types);
62		}
63		}
64
65		return NULL;
66		#else
67		return gtk_source_languages_manager_get_language_from_mime_type(
68		manager, mime_type);
69		#endif
70		}
71		}
72
73		Gobby::Preferences::Editor::Editor()
	22	Gobby::Preferences::User::User(Config::ParentEntry& entry):
	23	name(entry.get_value<Glib::ustring>("name", Glib::get_user_name())),
	24	hue(entry.get_value<double>("hue", Glib::Rand().get_double())),
	25	host_directory(entry.get_value<std::string>("host-directory", Glib::build_filename(Glib::get_home_dir(), ".infinote")))
74	26	{
75	27	}
76	28
	29	void Gobby::Preferences::User::serialise(Config::ParentEntry& entry) const
	30	{
	31	entry.set_value("name", name);
	32	entry.set_value("hue", hue);
	33	entry.set_value("host-directory", host_directory);
	34	}
	35
77	36	Gobby::Preferences::Editor::Editor(Config::ParentEntry& entry):
78		tab_width(entry~~["tab"].get_value<unsigned int>("~~width", 8)),
79		tab_spaces(entry~~["tab"].get_value<bool>("~~spaces", false)),
80		indentation_auto(entry~~["indentation"].get_value<bool>("auto~~", true)),
81		homeend_smart(entry~~["homeend"].get_value<bool>("smart~~", true) )
	37	tab_width(entry.get_value<unsigned int>("tab_width", 8)),
	38	tab_spaces(entry.get_value<bool>("tab_insert_spaces", false)),
	39	indentation_auto(entry.get_value<bool>("auto_indentation", true)),
	40	homeend_smart(entry.get_value<bool>("smart_homeend", true) )
82	41	{
83	42	}
…	…
85	44	void Gobby::Preferences::Editor::serialise(Config::ParentEntry& entry) const
86	45	{
87		entry["tab"].set_value("width", tab_width);
88		entry["tab"].set_value("spaces", tab_spaces);
89		entry["indentation"].set_value("auto", indentation_auto);
90		entry["homeend"].set_value("smart", homeend_smart);
91		}
92
93		Gobby::Preferences::View::View()
94		{
	46	entry.set_value("tab_width", tab_width);
	47	entry.set_value("tab_insert_spaces", tab_spaces);
	48	entry.set_value("auto_indentation", indentation_auto);
	49	entry.set_value("smart_homeend", homeend_smart);
95	50	}
96	51
97	52	Gobby::Preferences::View::View(Config::ParentEntry& entry):
98		wrap_text(entry["wrap"].get_value<bool>("text", true) ),
99		wrap_words(entry["wrap"].get_value<bool>("words", true) ),
100		linenum_display(entry["linenum"].get_value<bool>("display", true) ),
	53	wrap_mode(
	54	static_cast<Gtk::WrapMode>(
	55	entry.get_value<int>(
	56	"wrap_mode",
	57	static_cast<int>(Gtk::WRAP_WORD_CHAR)
	58	)
	59	)
	60	),
	61	linenum_display(entry.get_value<bool>("display_line_numbers", true)),
101	62	curline_highlight(
102		entry~~["curline"].get_value<bool>("highlight~~", true)
	63	entry.get_value<bool>("highlight_current_line", true)
103	64	),
104		margin_display(entry["margin"].get_value<bool>("display", true) ),
105		margin_pos(entry["margin"].get_value<unsigned int>("pos", 80) ),
106		bracket_highlight(entry["bracket"].get_value<bool>("highlight", true) )
	65	margin_display(entry.get_value<bool>("margin_display", true) ),
	66	margin_pos(entry.get_value<unsigned int>("margin_position", 80) ),
	67	bracket_highlight(
	68	entry.get_value<bool>("highlight_matching_brackets", true)
	69	)
107	70	{
108	71	}
…	…
110	73	void Gobby::Preferences::View::serialise(Config::ParentEntry& entry) const
111	74	{
112		entry["wrap"].set_value("text", wrap_text);
113		entry["wrap"].set_value("words", wrap_words);
114		entry["linenum"].set_value("display", linenum_display);
115		entry["curline"].set_value("highlight", curline_highlight);
116		entry["margin"].set_value("display", margin_display);
117		entry["margin"].set_value("pos", margin_pos);
118		entry["bracket"].set_value("highlight", bracket_highlight);
119		}
120
121		Gobby::Preferences::Appearance::Appearance()
122		{
	75	entry.set_value("wrap_mode", static_cast<int>(wrap_mode));
	76	entry.set_value("display_line_numbers", linenum_display);
	77	entry.set_value("highlight_current_line", curline_highlight);
	78	entry.set_value("margin_display", margin_display);
	79	entry.set_value("margin_position", margin_pos);
	80	entry.set_value("highlight_matching_brackets", bracket_highlight);
123	81	}
124	82
…	…
126	84	toolbar_show(
127	85	static_cast<Gtk::ToolbarStyle>(
128		entry~~["toolbar"]~~.get_value<int>(
129		"show",
	86	entry.get_value<int>(
	87	"toolbar_show",
130	88	static_cast<int>(Gtk::TOOLBAR_BOTH)
131	89	)
132	90	)
133	91	),
134		~~remember(entry["windows"].get_value<bool>("remember", true) ),~~
135		~~urgency_hint(entry["windows"].get_value<bool>("urgency_hint", true)~~ )
	92	font(Pango::FontDescription(entry.get_value<Glib::ustring>(
	93	"font", "Monospace 10")))
136	94	{
137	95	}
…	…
140	98	serialise(Config::ParentEntry& entry) const
141	99	{
142		entry["toolbar"].set_value("show", static_cast<int>(toolbar_show) );
143		entry["windows"].set_value("remember", remember);
144		entry["windows"].set_value("urgency_hint", urgency_hint);
	100	entry.set_value("toolbar_show", static_cast<int>(toolbar_show) );
	101
	102	entry.set_value(
	103	"font",
	104	static_cast<const Pango::FontDescription&>(font).to_string()
	105	);
145	106	}
146	107
147		Gobby::Preferences::Font::Font()
148		{
149		}
150
151		Gobby::Preferences::Font::Font(Config::ParentEntry& entry):
152		desc(entry.get_value<Glib::ustring>("desc", "Monospace 10") )
153		{
154		}
155
156		void Gobby::Preferences::Font::serialise(Config::ParentEntry& entry) const
157		{
158		entry.set_value("desc", desc.to_string());
159		}
160
161		Gobby::Preferences::Behaviour::Behaviour()
162		{
163		}
164
165		Gobby::Preferences::Behaviour::Behaviour(Config::ParentEntry& entry):
166		auto_open_new_documents(entry.get_value<bool>(
167		"auto_open_new_documents", false))
168		{
169		}
170
171		void Gobby::Preferences::Behaviour::serialise(Config::ParentEntry& entry) const
172		{
173		entry.set_value("auto_open_new_documents", auto_open_new_documents);
174		}
175
176		Gobby::Preferences::FileList::iterator::iterator(const base_iterator iter):
177		m_iter(iter)
178		{
179		}
180
181		Gobby::Preferences::FileList::iterator&
182		Gobby::Preferences::FileList::iterator::operator++()
183		{
184		++ m_iter;
185		return *this;
186		}
187
188		Gobby::Preferences::FileList::iterator
189		Gobby::Preferences::FileList::iterator::operator++(int)
190		{
191		iterator temp(m_iter);
192		++ *this;
193		return temp;
194		}
195
196		bool Gobby::Preferences::FileList::iterator::
197		operator==(const iterator& other) const
198		{
199		return m_iter == other.m_iter;
200		}
201
202		bool Gobby::Preferences::FileList::iterator::
203		operator!=(const iterator& other) const
204		{
205		return m_iter != other.m_iter;
206		}
207
208		const Glib::ustring& Gobby::Preferences::FileList::iterator::pattern() const
209		{
210		return m_iter->first;
211		}
212
213		GtkSourceLanguage*
214		Gobby::Preferences::FileList::iterator::language() const
215		{
216		return m_iter->second;
217		}
218
219		Gobby::Preferences::FileList::FileList()
220		{
221		}
222
223		Gobby::Preferences::FileList::FileList(Config::ParentEntry& entry,
224		GtkSourceLanguageManager* lang_mgr)
225		{
226		if(entry.begin() != entry.end() )
227		{
228		for(Config::ParentEntry::iterator iter = entry.begin();
229		iter != entry.end();
230		++ iter)
231		{
232		Config::Entry& ent = *iter;
233		Config::ParentEntry* parent_entry =
234		dynamic_cast<Config::ParentEntry*>(&ent);
235
236		// Don't know what it is...
237		if(parent_entry == NULL) continue;
238
239		Glib::ustring pattern = parent_entry->get_value<
240		Glib::ustring
241		>("pattern", "unknown");
242
243		Glib::ustring mime = parent_entry->get_value<
244		Glib::ustring
245		>("mime_type", "unknown");
246
247		GtkSourceLanguage* lang = get_language_from_mime_type(
248		lang_mgr, mime.c_str());
249
250		if(lang)
251		{
252		m_files[pattern] = lang;
253		g_object_ref(G_OBJECT(lang));
254		}
255		}
256		}
257		else
258		{
259		#ifdef WITH_GTKSOURCEVIEW2
260		const gchar* const* ids = gtk_source_language_manager_get_language_ids(lang_mgr);
261		if(ids == NULL) return; // No languages available
262
263		for(const gchar* const* id = ids; *id != NULL; ++ id)
264		{
265		GtkSourceLanguage* language = gtk_source_language_manager_get_language(lang_mgr, *id);
266
267		gchar** globs = gtk_source_language_get_globs(language);
268		if(globs != NULL)
269		{
270		for(gchar** glob = globs; *glob != NULL; ++ glob)
271		{
272		add(*glob, language);
273		}
274
275		g_strfreev(globs);
276		}
277		}
278		#else
279		// Default list
280		add_by_mime_type("*.ada", "text/x-ada", lang_mgr);
281		add_by_mime_type("*.c", "text/x-csrc", lang_mgr);
282		add_by_mime_type("*.h", "text/x-chdr", lang_mgr);
283		add_by_mime_type("*.cpp", "text/x-c++src", lang_mgr);
284		add_by_mime_type("*.hpp", "text/x-c++hdr", lang_mgr);
285		add_by_mime_type("*.cc", "text/x-c++src", lang_mgr);
286		add_by_mime_type("*.hh", "text/x-c++hdr", lang_mgr);
287		add_by_mime_type("*.cs", "text/x-csharp", lang_mgr);
288		add_by_mime_type("*.css", "text/css", lang_mgr);
289		add_by_mime_type("*.diff", "text/x-diff", lang_mgr);
290		add_by_mime_type("*.patch", "text/x-diff", lang_mgr);
291		add_by_mime_type("*.f", "text/x-fortran", lang_mgr);
292		add_by_mime_type("*.f77", "text/x-fortran", lang_mgr);
293		add_by_mime_type("*.hs", "text/x-haskell", lang_mgr);
294		add_by_mime_type("*.htm", "text/html", lang_mgr);
295		add_by_mime_type("*.html", "text/html", lang_mgr);
296		add_by_mime_type("*.xhtml", "text/html", lang_mgr);
297		add_by_mime_type("*.idl", "text/x-idl", lang_mgr);
298		add_by_mime_type("*.java", "text/x-java", lang_mgr);
299		add_by_mime_type("*.js", "application/x-javascript", lang_mgr);
300		add_by_mime_type("*.tex", "text/x-tex", lang_mgr);
301		add_by_mime_type("*.latex", "text/x-tex", lang_mgr);
302		add_by_mime_type("*.lua", "text/x-lua", lang_mgr);
303		add_by_mime_type("*.dpr", "text/x-pascal", lang_mgr);
304		add_by_mime_type("*.pas", "text/x-pascal", lang_mgr);
305		add_by_mime_type("*.pl", "text/x-perl", lang_mgr);
306		add_by_mime_type("*.pm", "text/x-perl", lang_mgr);
307		add_by_mime_type("*.php", "text/x-php", lang_mgr);
308		add_by_mime_type("*.php3", "text/x-php", lang_mgr);
309		add_by_mime_type("*.php4", "text/x-php", lang_mgr);
310		add_by_mime_type("*.php5", "text/x-php", lang_mgr);
311		add_by_mime_type(
312		"*.po",
313		"text/x-gettext-translation",
314		lang_mgr
315		);
316		add_by_mime_type("*.py", "text/x-python", lang_mgr);
317		add_by_mime_type("*.rb", "text/x-ruby", lang_mgr);
318		add_by_mime_type("*.sql", "text/x-sql", lang_mgr);
319		add_by_mime_type("*.texi", "text/x-texinfo", lang_mgr);
320		add_by_mime_type("*.bas", "text/x-vb", lang_mgr);
321		add_by_mime_type("*.vbs", "text/x-vb", lang_mgr);
322		add_by_mime_type("*.v", "text/x-verilog-src", lang_mgr);
323		add_by_mime_type("*.xml", "text/xml", lang_mgr);
324		add_by_mime_type(
325		"*.desktop",
326		"application/x-gnome-app-info",
327		lang_mgr
328		);
329		add_by_mime_type("*.tcl", "text/x-tcl", lang_mgr);
330		add_by_mime_type("Makefile", "text/x-makefile", lang_mgr);
331		#endif
332		}
333		}
334
335		Gobby::Preferences::FileList::FileList(const FileList& src):
336		m_files(src.m_files)
337		{
338		// TODO: It would also be great if we would not need to ref all the
339		// languages.
340		for(map_type::iterator iter = m_files.begin();
341		iter != m_files.end();
342		++ iter)
343		{
344		g_object_ref(G_OBJECT(iter->second));
345		}
346		}
347
348		Gobby::Preferences::FileList::~FileList()
349		{
350		for(map_type::iterator iter = m_files.begin();
351		iter != m_files.end();
352		++ iter)
353		{
354		g_object_unref(G_OBJECT(iter->second));
355		}
356		}
357
358		void Gobby::Preferences::FileList::serialise(Config::ParentEntry& entry) const
359		{
360		int num = 0;
361
362		for(map_type::const_iterator iter = m_files.begin();
363		iter != m_files.end();
364		++ iter)
365		{
366		std::stringstream stream;
367		stream << "file" << (++num);
368
369		gchar* mime_type = NULL;
370		#ifdef WITH_GTKSOURCEVIEW2
371		gchar** mime_types =
372		gtk_source_language_get_mime_types(iter->second);
373		if(mime_types != NULL && *mime_types != NULL)
374		mime_type = g_strdup(*mime_types);
375		g_strfreev(mime_types);
376		#else
377		GSList* mime_types =
378		gtk_source_language_get_mime_types(iter->second);
379		for(GSList* cur = mime_types; cur != NULL; cur = cur->next)
380		{
381		if(!mime_type)
382		mime_type = static_cast<gchar*>(cur->data);
383		else
384		g_free(cur->data);
385		}
386		g_slist_free(mime_types);
387		#endif
388
389		Config::ParentEntry& main = entry.set_parent(stream.str());
390
391		main.set_value("pattern", iter->first);
392		if(mime_type != NULL)
393		main.set_value("mime_type", mime_type);
394
395		g_free(mime_type);
396		}
397		}
398
399		Gobby::Preferences::FileList::iterator
400		Gobby::Preferences::FileList::add(const Glib::ustring& pattern,
401		GtkSourceLanguage* lang)
402		{
403		//map_type::iterator iter = m_files.find(pattern);
404		//if(iter != m_files.end() ) return iter;
405		g_object_ref(G_OBJECT(lang));
406		return iterator(m_files.insert(std::make_pair(pattern, lang) ).first);
407		}
408
409		#ifndef WITH_GTKSOURCEVIEW2
410		Gobby::Preferences::FileList::iterator
411		Gobby::Preferences::FileList::add_by_mime_type(const Glib::ustring& pattern,
412		const Glib::ustring& mime_type,
413		GtkSourceLanguageManager* lang_mgr)
414		{
415		GtkSourceLanguage* lang =
416		gtk_source_languages_manager_get_language_from_mime_type(
417		lang_mgr, mime_type.c_str());
418
419		if(lang != NULL)
420		return add(pattern, lang);
421		else
422		return iterator(m_files.end());
423		}
424		#endif
425
426		Gobby::Preferences::FileList::iterator
427		Gobby::Preferences::FileList::begin() const
428		{
429		return iterator(m_files.begin() );
430		}
431
432		Gobby::Preferences::FileList::iterator
433		Gobby::Preferences::FileList::end() const
434		{
435		return iterator(m_files.end() );
436		}
437
438		Gobby::Preferences::Preferences()
439		{
440		// Uninitialised preferences
441		}
442
443		Gobby::Preferences::Preferences(Config& config, GtkSourceLanguageManager* mgr):
	108	Gobby::Preferences::Preferences(Config& config):
	109	user(config.get_root()["user"]),
444	110	editor(config.get_root()["editor"]),
445	111	view(config.get_root()["view"]),
446		appearance(config.get_root()["appearance"]),
447		font(config.get_root()["font"]),
448		behaviour(config.get_root()["behaviour"]),
449		files(config.get_root()["files"], mgr)
	112	appearance(config.get_root()["appearance"])
450	113	{
451	114	}
…	…
454	117	{
455	118	// Serialise into config
	119	user.serialise(config.get_root()["user"]);
456	120	editor.serialise(config.get_root()["editor"]);
457	121	view.serialise(config.get_root()["view"]);
458	122	appearance.serialise(config.get_root()["appearance"]);
459		~~font.serialise(config.get_root()["font"]);~~
460		~~behaviour.serialise(config.get_root()["behaviour"]);~~
461		~~files.serialise(config.get_root()["files"]);~~
462	123	}
463	124

src/preferencesdialog.cpp

r7fdfee0	r0a50e446
1	1	/* gobby - A GTKmm driven libobby client
2		* Copyright (C) 2005 0x539 dev group
	2	* Copyright (C) 2005 - 2008 0x539 dev group
3	3	*
4	4	* This program is free software; you can redistribute it and/or
…	…
17	17	*/
18	18
19		~~#include <cstring>~~
20	19	#include <stdexcept>
21	20	#include <gtkmm/stock.h>
…	…
29	28	namespace
30	29	{
31		~~gint lang_sort(gconstpointer first, gconstpointer second)~~
32		{
33		~~return strcmp(~~
34		~~gtk_source_language_get_name(GTK_SOURCE_LANGUAGE(first)),~~
35		~~gtk_source_language_get_name(GTK_SOURCE_LANGUAGE(second))~~
36		);
37		}
38
39	30	Gtk::ToolbarStyle rownum_to_toolstyle(int rownum)
40	31	{
…	…
49	40	}
50	41
	42	Gobby::PreferencesDialog::Group::Group(const Glib::ustring& title):
	43	m_box(false, 6)
	44	{
	45	Gtk::Label* title_label = Gtk::manage(new Gtk::Label);
	46	title_label->set_markup(
	47	"<b>" + Glib::Markup::escape_text(title) + "</b>");
	48	set_label_widget(*title_label);
	49	title_label->show();
	50
	51	m_box.show();
	52
	53	m_alignment.set_padding(6, 0, 12, 0);
	54	m_alignment.add(m_box);
	55	m_alignment.show();
	56
	57	set_shadow_type(Gtk::SHADOW_NONE);
	58	Gtk::Frame::add(m_alignment);
	59	}
	60
	61	void Gobby::PreferencesDialog::Group::add(Gtk::Widget& widget)
	62	{
	63	m_box.pack_start(widget, Gtk::PACK_SHRINK);
	64	}
	65
51	66	Gobby::PreferencesDialog::Page::Page():
52		Gtk::Frame()
53		{
	67	Gtk::Frame(), m_box(false, 12)
	68	{
	69	Gtk::Frame::add(m_box);
	70	m_box.show();
	71
54	72	// Remove shadow - use the frame just as container
55	73	set_shadow_type(Gtk::SHADOW_NONE);
56		set_border_width(10);
57		}
58
59		#ifndef GTKMM_DISABLE_DEPRECATED
60		Gobby::PreferencesDialog::Editor::Editor(const Preferences& preferences,
61		Gtk::Tooltips& tooltips):
62		#else
	74	set_border_width(12);
	75	}
	76
	77	void Gobby::PreferencesDialog::Page::add(Gtk::Widget& widget)
	78	{
	79	m_box.pack_start(widget, Gtk::PACK_SHRINK);
	80	}
	81
	82	Gobby::PreferencesDialog::User::User(const Preferences& preferences):
	83	m_group_settings(_("Settings")),
	84	m_group_paths(_("Paths")),
	85	m_box_user_name(false, 6),
	86	m_lbl_user_name(_("User name:")),
	87	m_box_user_color(false, 6),
	88	m_lbl_user_color(_("User color:")),
	89	m_box_path_host_directory(false, 6),
	90	m_btn_path_host_directory(Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER),
	91	m_lbl_path_host_directory(_("Host directory:"))
	92	{
	93	m_lbl_user_name.show();
	94	m_ent_user_name.set_text(preferences.user.name);
	95	m_ent_user_name.show();
	96
	97	m_box_user_name.pack_start(m_lbl_user_name, Gtk::PACK_SHRINK);
	98	m_box_user_name.pack_start(m_ent_user_name, Gtk::PACK_EXPAND_WIDGET);
	99	m_box_user_name.show();
	100
	101	Gdk::Color color;
	102	color.set_hsl(preferences.user.hue, 0.8, 1.0);
	103	m_lbl_user_color.show();
	104	m_btn_user_color.set_color(color);
	105	m_btn_user_color.show();
	106
	107	m_box_user_color.pack_start(m_lbl_user_color, Gtk::PACK_SHRINK);
	108	m_box_user_color.pack_start(
	109	m_btn_user_color, Gtk::PACK_EXPAND_WIDGET);
	110	m_box_user_color.show();
	111
	112	m_group_settings.add(m_box_user_name);
	113	m_group_settings.add(m_box_user_color);
	114	m_group_settings.show();
	115
	116	m_lbl_path_host_directory.show();
	117	m_btn_path_host_directory.set_current_folder(
	118	static_cast<const std::string&>(
	119	preferences.user.host_directory));
	120	m_btn_path_host_directory.show();
	121
	122	m_box_path_host_directory.set_tooltip_text(
	123	_("The directory into which locally hosted sessions "
	124	"are permanently stored"));
	125	m_box_path_host_directory.pack_start(
	126	m_lbl_path_host_directory, Gtk::PACK_SHRINK);
	127	m_box_path_host_directory.pack_start(
	128	m_btn_path_host_directory, Gtk::PACK_EXPAND_WIDGET);
	129	m_box_path_host_directory.show();
	130
	131	m_group_paths.add(m_box_path_host_directory);
	132	m_group_paths.show();
	133
	134	add(m_group_settings);
	135	add(m_group_paths);
	136	}
	137
63	138	Gobby::PreferencesDialog::Editor::Editor(const Preferences& preferences):
64		#endif
65		m_frame_tab(_("Tab Stops") ),
66		m_frame_indentation(_("Indentation") ),
67		m_frame_homeend(_("Home/End behaviour") ),
	139	m_group_tab(_("Tab Stops") ),
	140	m_group_indentation(_("Indentation") ),
	141	m_group_homeend(_("Home/End behaviour") ),
68	142	m_lbl_tab_width(_("Tab width:"), Gtk::ALIGN_RIGHT),
69	143	m_btn_tab_spaces(_("Insert spaces instead of tabs") ),
…	…
76	150	bool homeend_smart = preferences.editor.homeend_smart;
77	151
	152	m_lbl_tab_width.show();
78	153	m_ent_tab_width.set_range(1, 8);
79	154	m_ent_tab_width.set_value(tab_width);
80	155	m_ent_tab_width.set_increments(1, 1);
81
82		#ifndef GTKMM_DISABLE_DEPRECATED
83		~~// TODO: Improve this description~~
84		~~tooltips.set_tip(m_btn_homeend_smart,~~
85		~~_("With this option enabled, Home/End keys move to first/last~~ "
86		"~~character before going to the start/end of the line.") );~~
87		#endif
88
89		m_box_tab_width.set_spacing(5);
	156	m_ent_tab_width.show();
	157
	158	m_btn_homeend_smart.set_tooltip_text(
	159	_("With this option enabled, Home/End keys move to "
	160	"first/last character before going to the start/end of the "
	161	"line.")
	162	);
	163
	164	m_box_tab_width.set_spacing(6);
90	165	m_box_tab_width.pack_start(m_lbl_tab_width, Gtk::PACK_SHRINK);
91	166	m_box_tab_width.pack_start(m_ent_tab_width, Gtk::PACK_EXPAND_WIDGET);
	167	m_box_tab_width.show();
92	168
93	169	m_btn_tab_spaces.set_active(tab_spaces);
	170	m_btn_tab_spaces.show();
94	171	m_btn_indentation_auto.set_active(indentation_auto);
	172	m_btn_indentation_auto.show();
95	173	m_btn_homeend_smart.set_active(homeend_smart);
96
97		m_box_tab.set_spacing(5);
98		m_box_tab.set_border_width(5);
99		m_box_tab.pack_start(m_box_tab_width, Gtk::PACK_SHRINK);
100		m_box_tab.pack_start(m_btn_tab_spaces, Gtk::PACK_SHRINK);
101
102		m_box_indentation.set_spacing(5);
103		m_box_indentation.set_border_width(5);
104		m_box_indentation.pack_start(m_btn_indentation_auto, Gtk::PACK_SHRINK);
105
106		m_box_homeend.set_spacing(5);
107		m_box_homeend.set_border_width(5);
108		m_box_homeend.pack_start(m_btn_homeend_smart, Gtk::PACK_SHRINK);
109
110		m_frame_tab.add(m_box_tab);
111		m_frame_indentation.add(m_box_indentation);
112		m_frame_homeend.add(m_box_homeend);
113
114		m_box.set_spacing(5);
115		m_box.pack_start(m_frame_tab, Gtk::PACK_SHRINK);
116		m_box.pack_start(m_frame_indentation, Gtk::PACK_SHRINK);
117		m_box.pack_start(m_frame_homeend, Gtk::PACK_SHRINK);
118
119		add(m_box);
120		}
121
122		void Gobby::PreferencesDialog::Editor::set(Preferences::Editor& editor) const
123		{
124		editor.tab_width = m_ent_tab_width.get_value_as_int();
125		editor.tab_spaces = m_btn_tab_spaces.get_active();
126		editor.indentation_auto = m_btn_indentation_auto.get_active();
127		editor.homeend_smart = m_btn_homeend_smart.get_active();
	174	m_btn_homeend_smart.show();
	175
	176	m_group_tab.add(m_box_tab_width);
	177	m_group_tab.add(m_btn_tab_spaces);
	178	m_group_tab.show();
	179
	180	m_group_indentation.add(m_btn_indentation_auto);
	181	m_group_indentation.show();
	182
	183	m_group_homeend.add(m_btn_homeend_smart);
	184	m_group_homeend.show();
	185
	186	add(m_group_tab);
	187	add(m_group_indentation);
	188	add(m_group_homeend);
128	189	}
129	190
130	191	Gobby::PreferencesDialog::View::View(const Preferences& preferences):
131		m_~~frame~~_wrap(_("Text wrapping") ),
132		m_~~frame~~_linenum(_("Line numbers") ),
133		m_~~frame~~_curline(_("Current line") ),
134		m_~~frame~~_margin(_("Right margin") ),
135		m_~~frame~~_bracket(_("Bracket matching") ),
	192	m_group_wrap(_("Text wrapping") ),
	193	m_group_linenum(_("Line numbers") ),
	194	m_group_curline(_("Current line") ),
	195	m_group_margin(_("Right margin") ),
	196	m_group_bracket(_("Bracket matching") ),
136	197	m_btn_wrap_text(_("Enable text wrapping") ),
137	198	m_btn_wrap_words(_("Do not split words over two lines") ),
…	…
142	203	m_btn_bracket_highlight(_("Highlight matching bracket") )
143	204	{
144		bool wrap_text = preferences.view.wrap_text;
145		bool wrap_words = preferences.view.wrap_words;
	205	Gtk::WrapMode mode = preferences.view.wrap_mode;
146	206	bool linenum_display = preferences.view.linenum_display;
147	207	bool curline_highlight = preferences.view.curline_highlight;
…	…
151	211
152	212	m_btn_margin_display.signal_toggled().connect(
153		sigc::mem_fun(*this, &View::on_margin_display_toggled) );
	213	sigc::mem_fun(*this, &View::on_margin_display_toggled));
	214	m_btn_wrap_text.signal_toggled().connect(
	215	sigc::mem_fun(*this, &View::on_wrap_text_toggled));
154	216
155	217	m_ent_margin_pos.set_range(1, 1024);
156	218	m_ent_margin_pos.set_value(margin_pos);
157	219	m_ent_margin_pos.set_increments(1, 16);
158
159		m_btn_wrap_text.set_active(wrap_text);
160		m_btn_wrap_words.set_active(!wrap_words);
	220	m_ent_margin_pos.show();
	221
	222	m_btn_wrap_text.set_active(mode != Gtk::WRAP_NONE);
	223	m_btn_wrap_text.show();
	224	m_btn_wrap_words.set_active(mode == Gtk::WRAP_WORD_CHAR);
	225	m_btn_wrap_words.set_sensitive(mode != Gtk::WRAP_NONE);
	226	m_btn_wrap_words.show();
161	227	m_btn_linenum_display.set_active(linenum_display);
	228	m_btn_linenum_display.show();
162	229	m_btn_curline_highlight.set_active(curline_highlight);
	230	m_btn_curline_highlight.show();
163	231	m_btn_margin_display.set_active(margin_display);
	232	m_btn_margin_display.show();
164	233	m_btn_bracket_highlight.set_active(bracket_highlight);
165
166		m_box_margin_pos.set_spacing(5);
	234	m_btn_bracket_highlight.show();
	235
	236
	237	m_box_margin_pos.set_spacing(6);
	238	m_box_margin_pos.set_sensitive(margin_display);
167	239	m_box_margin_pos.pack_start(m_lbl_margin_pos, Gtk::PACK_SHRINK);
168	240	m_box_margin_pos.pack_start(m_ent_margin_pos, Gtk::PACK_EXPAND_WIDGET);
169		m_box_wrap.set_spacing(5);
170		m_box_wrap.set_border_width(5);
171		m_box_wrap.pack_start(m_btn_wrap_text, Gtk::PACK_SHRINK);
172		m_box_wrap.pack_start(m_btn_wrap_words, Gtk::PACK_SHRINK);
173
174		m_box_linenum.set_spacing(5);
175		m_box_linenum.set_border_width(5);
176		m_box_linenum.pack_start(m_btn_linenum_display, Gtk::PACK_SHRINK);
177
178		m_box_curline.set_spacing(5);
179		m_box_curline.set_border_width(5);
180		m_box_curline.pack_start(m_btn_curline_highlight, Gtk::PACK_SHRINK);
181
182		m_box_margin.set_spacing(5);
183		m_box_margin.set_border_width(5);
184		m_box_margin.pack_start(m_btn_margin_display, Gtk::PACK_SHRINK);
185		m_box_margin.pack_start(m_box_margin_pos, Gtk::PACK_SHRINK);
186
187		m_box_bracket.set_spacing(5);
188		m_box_bracket.set_border_width(5);
189		m_box_bracket.pack_start(m_btn_bracket_highlight, Gtk::PACK_SHRINK);
	241	m_box_margin_pos.show();
	242
	243	m_group_wrap.add(m_btn_wrap_text);
	244	m_group_wrap.add(m_btn_wrap_words);
	245	m_group_wrap.show();
	246
	247	m_group_linenum.add(m_btn_linenum_display);
	248	m_group_linenum.show();
	249
	250	m_group_curline.add(m_btn_curline_highlight);
	251	m_group_curline.show();
	252
	253	m_group_margin.add(m_btn_margin_display);
	254	m_group_margin.add(m_box_margin_pos);
	255	m_group_margin.show();
	256
	257	m_group_bracket.add(m_btn_bracket_highlight);
	258	m_group_bracket.show();
190	259
191		m_frame_wrap.add(m_box_wrap);
192		m_frame_linenum.add(m_box_linenum);
193		m_frame_curline.add(m_box_curline);
194		m_frame_margin.add(m_box_margin);
195		m_frame_bracket.add(m_box_bracket);
196
197		m_box.set_spacing(5);
198		m_box.pack_start(m_frame_wrap, Gtk::PACK_SHRINK);
199		m_box.pack_start(m_frame_linenum, Gtk::PACK_SHRINK);
200		m_box.pack_start(m_frame_curline, Gtk::PACK_SHRINK);
201		m_box.pack_start(m_frame_margin, Gtk::PACK_SHRINK);
202		m_box.pack_start(m_frame_bracket, Gtk::PACK_SHRINK);
203
204		add(m_box);
205		}
206
207		void Gobby::PreferencesDialog::View::set(Preferences::View& view) const
208		{
209		view.wrap_text = m_btn_wrap_text.get_active();
210		view.wrap_words = !m_btn_wrap_words.get_active();
211		view.linenum_display = m_btn_linenum_display.get_active();
212		view.curline_highlight = m_btn_curline_highlight.get_active();
213		view.margin_display = m_btn_margin_display.get_active();
214		view.margin_pos = m_ent_margin_pos.get_value_as_int();
215		view.bracket_highlight = m_btn_bracket_highlight.get_active();
	260	add(m_group_wrap);
	261	add(m_group_linenum);
	262	add(m_group_curline);
	263	add(m_group_margin);
	264	add(m_group_bracket);
	265	}
	266
	267	void Gobby::PreferencesDialog::View::on_wrap_text_toggled()
	268	{
	269	m_btn_wrap_words.set_sensitive(m_btn_wrap_text.get_active());
216	270	}
217	271
218	272	void Gobby::PreferencesDialog::View::on_margin_display_toggled()
219	273	{
220		m_box_margin_pos.set_sensitive(m_btn_margin_display.get_active() );
	274	m_box_margin_pos.set_sensitive(m_btn_margin_display.get_active());
221	275	}
222	276
223	277	Gobby::PreferencesDialog::Appearance::
224	278	Appearance(const Gobby::Preferences& preferences):
225		m_frame_toolbar(_("Toolbar") ),
226		m_frame_windows(_("Windows") ),
227		m_btn_remember(_("Remember the positions and states") ),
228		m_btn_urgency_hint(
229		_("Highlight the window on incoming chat messages") )
	279	m_group_toolbar(_("Toolbar") ),
	280	m_group_font(_("Font") )
230	281	{
231	282	Gtk::ToolbarStyle style = preferences.appearance.toolbar_show;
232		bool remember = preferences.appearance.remember;
233		bool urgency_hint = preferences.appearance.urgency_hint;
	283	const Pango::FontDescription& font = preferences.appearance.font;
234	284
235	285	m_cmb_toolbar_style.append_text(_("Show text only") );
…	…
237	287	m_cmb_toolbar_style.append_text(_("Show both icons and text") );
238	288	m_cmb_toolbar_style.append_text(_("Show text besides icons") );
	289	m_cmb_toolbar_style.show();
239	290
240	291	switch(style)
…	…
247	298	}
248	299
249		m_box_toolbar.set_spacing(5);
250		m_box_toolbar.set_border_width(5);
251		m_box_toolbar.pack_start(m_cmb_toolbar_style, Gtk::PACK_SHRINK);
252
253		m_frame_toolbar.add(m_box_toolbar);
254
255		m_box_windows.set_spacing(5);
256		m_box_windows.set_border_width(5);
257		m_btn_remember.set_active(remember);
258		m_btn_urgency_hint.set_active(urgency_hint);
259		m_box_windows.pack_start(m_btn_remember, Gtk::PACK_SHRINK);
260		m_box_windows.pack_start(m_btn_urgency_hint, Gtk::PACK_SHRINK);
261
262		m_frame_windows.add(m_box_windows);
263
264		m_box.set_spacing(5);
265		m_box.pack_start(m_frame_toolbar, Gtk::PACK_SHRINK);
266		m_box.pack_start(m_frame_windows, Gtk::PACK_SHRINK);
267
268		add(m_box);
269		}
270
271		void Gobby::PreferencesDialog::Appearance::
272		set(Preferences::Appearance& appearance) const
273		{
274		appearance.toolbar_show = rownum_to_toolstyle(
275		m_cmb_toolbar_style.get_active_row_number()
276		);
277
278		appearance.remember = m_btn_remember.get_active();
279		appearance.urgency_hint = m_btn_urgency_hint.get_active();
280		}
281
282		Gobby::PreferencesDialog::Font::Font(const Preferences& preferences):
283		m_init_font(preferences.font.desc.to_string() )
284		{
285		// Call to set_font_name does not work before realization of the
286		// font selection widget
287		m_font_sel.signal_realize().connect(
288		sigc::mem_fun(*this, &Font::on_fontsel_realize)
289		);
290
291		add(m_font_sel);
292		}
293
294		void Gobby::PreferencesDialog::Font::on_fontsel_realize()
295		{
296		m_font_sel.set_font_name(m_init_font);
297		m_init_font.clear();
298		}
299
300		void Gobby::PreferencesDialog::Font::set(Preferences::Font& font) const
301		{
302		if(m_init_font.empty() )
303		font.desc = Pango::FontDescription(m_font_sel.get_font_name());
304		else
305		font.desc = Pango::FontDescription(m_init_font);
306		}
307
308		Gobby::PreferencesDialog::Behaviour::Behaviour(const Preferences& preferences):
309		m_frame_documents(_("Document management") ),
310		m_btn_auto_open(_("Open new remotely-created documents automatically") )
311		{
312		bool auto_open = preferences.behaviour.auto_open_new_documents;
313
314		m_btn_auto_open.set_active(auto_open);
315		m_box_documents.set_spacing(5);
316		m_box_documents.set_border_width(5);
317		m_box_documents.pack_start(m_btn_auto_open, Gtk::PACK_SHRINK);
318		m_frame_documents.add(m_box_documents);
319
320		m_box.pack_start(m_frame_documents, Gtk::PACK_SHRINK);
321
322		add(m_box);
323		}
324
325		void Gobby::PreferencesDialog::Behaviour::set(
326		Preferences::Behaviour& preferences) const
327		{
328		preferences.auto_open_new_documents = m_btn_auto_open.get_active();
329		}
330
331		Gobby::PreferencesDialog::FileList::LanguageColumns::LanguageColumns()
332		{
333		add(language);
334		add(language_name);
335		}
336
337		Gobby::PreferencesDialog::FileList::FileColumns::FileColumns()
338		{
339		add(pattern);
340		add(mime_type);
341		add(language);
342		}
343
344		Gobby::PreferencesDialog::FileList::FileList(Gtk::Window& parent,
345		const Preferences& preferences,
346		GtkSourceLanguageManager* lang_mgr):
347		m_parent(parent), m_lang_mgr(lang_mgr),
348		m_viewcol_pattern(_("Pattern"), file_columns.pattern),
349		m_viewcol_lang(_("Language"), m_renderer_lang),
350		m_viewcol_mimetype(_("Mime type"), file_columns.mime_type),
351		m_intro(
352		_("This is a list of all recognized file types"),
353		Gtk::ALIGN_LEFT
354		),
355		m_hbox(Gtk::BUTTONBOX_END, 12),
356		m_btn_add(Gtk::Stock::ADD), m_btn_remove(Gtk::Stock::REMOVE),
357		m_lang_list(Gtk::ListStore::create(lang_columns) ),
358		m_file_list(Gtk::ListStore::create(file_columns) )
359		{
360		#ifdef WITH_GTKSOURCEVIEW2
361		GSList* languages = NULL;
362		const gchar* const* ids = gtk_source_language_manager_get_language_ids(lang_mgr);
363		if(ids != NULL)
364		{
365		for(const gchar* const* id = ids; *id != NULL; ++ id)
366		{
367		GtkSourceLanguage* language = gtk_source_language_manager_get_language(lang_mgr, *id);
368		languages = g_slist_prepend(languages, language);
369		}
370		}
371		#else
372		const GSList* list =
373		gtk_source_languages_manager_get_available_languages(lang_mgr);
374		GSList* languages = g_slist_copy(const_cast<GSList*>(list));
375		#endif
376
377		languages = g_slist_sort(languages, &lang_sort);
378
379		for(GSList* iter = languages; iter != NULL; iter = iter->next)
380		{
381		Gtk::TreeIter tree_it = m_lang_list->append();
382		(*tree_it)[lang_columns.language] = GTK_SOURCE_LANGUAGE(iter->data);
383		(*tree_it)[lang_columns.language_name] =
384		gtk_source_language_get_name(GTK_SOURCE_LANGUAGE(iter->data));
385
386		m_lang_map[GTK_SOURCE_LANGUAGE(iter->data)] = tree_it;
387		}
388
389		g_slist_free(languages);
390
391		m_renderer_pattern = static_cast<Gtk::CellRendererText*>(
392		m_viewcol_pattern.get_first_cell_renderer()
393		);
394
395		m_renderer_mimetype = static_cast<Gtk::CellRendererText*>(
396		m_viewcol_mimetype.get_first_cell_renderer()
397		);
398
399		m_renderer_pattern->property_editable() = true;
400		m_renderer_pattern->signal_edited().connect(
401		sigc::mem_fun(*this, &FileList::on_pattern_edited)
402		);
403
404		m_renderer_mimetype->property_editable() = true;
405		m_renderer_mimetype->signal_edited().connect(
406		sigc::mem_fun(*this, &FileList::on_mimetype_edited)
407		);
408
409		m_renderer_lang.property_has_entry() = false;
410		m_renderer_lang.property_model() = m_lang_list;
411		m_renderer_lang.property_text_column() = 1;
412		m_renderer_lang.property_editable() = true;
413		m_renderer_lang.signal_edited().connect(
414		sigc::mem_fun(*this, &FileList::on_language_edited)
415		);
416
417		m_viewcol_lang.set_cell_data_func(
418		m_renderer_lang,
419		sigc::mem_fun(*this, &FileList::cell_data_file_language)
420		);
421
422
423		m_viewcol_pattern.set_sort_column(file_columns.pattern);
424		//m_viewcol_lang.set_sort_column(file_columns.language);
425		m_viewcol_mimetype.set_sort_column(file_columns.mime_type);
426
427		const Preferences::FileList& filelist = preferences.files;
428
429		for(Preferences::FileList::iterator iter = filelist.begin();
430		iter != filelist.end();
431		++ iter)
432		{
433		/* std::list<Glib::ustring> mime_types =
434		iter.language()->get_mime_types();*/
435
436		Gtk::TreeIter tree_it = m_file_list->append();
437		(*tree_it)[file_columns.pattern] = iter.pattern();
438		set_language(tree_it, iter.language() );
439		}
440
441		m_view.set_model(m_file_list);
442
443		m_view.append_column(m_viewcol_pattern);
444		m_view.append_column(m_viewcol_lang);
445		//m_view.append_column(m_viewcol_mimetype);
446
447		m_view.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
448		m_view.get_selection()->signal_changed().connect(
449		sigc::mem_fun(*this, &FileList::on_selection_changed)
450		);
451
452		m_view.set_rules_hint(true);
453
454		m_btn_add.signal_clicked().connect(
455		sigc::mem_fun(*this, &FileList::on_file_add)
456		);
457
458		m_btn_remove.signal_clicked().connect(
459		sigc::mem_fun(*this, &FileList::on_file_remove)
460		);
461
462		m_hbox.add(m_btn_remove);
463		m_hbox.add(m_btn_add);
464
465		m_wnd.add(m_view);
466		m_wnd.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
467		m_wnd.set_shadow_type(Gtk::SHADOW_IN);
468
469		m_vbox.pack_start(m_intro, Gtk::PACK_SHRINK);
470		m_vbox.pack_start(m_wnd, Gtk::PACK_EXPAND_WIDGET);
471		m_vbox.pack_start(m_hbox, Gtk::PACK_SHRINK);
472		m_vbox.set_spacing(8);
473
474		add(m_vbox);
475
476		on_selection_changed();
477		}
478
479		void Gobby::PreferencesDialog::FileList::set(Preferences::FileList& files) const
480		{
481		Gtk::TreeNodeChildren children = m_file_list->children();
482		for(Gtk::TreeIter iter = children.begin();
483		iter != children.end();
484		++ iter)
485		{
486		Gtk::TreeIter lang_it = (*iter)[file_columns.language];
487		files.add(
488		(*iter)[file_columns.pattern],
489		(*lang_it)[lang_columns.language]
490		);
491		}
492		}
493
494		void Gobby::PreferencesDialog::FileList::
495		cell_data_file_language(Gtk::CellRenderer* renderer,
496		const Gtk::TreeIter& iter)
497		{
498		Gtk::TreeIter lang_it = (*iter)[file_columns.language];
499		static_cast<Gtk::CellRendererText*>(renderer)->property_text() =
500		(*lang_it)[lang_columns.language_name];
501		}
502
503		void Gobby::PreferencesDialog::FileList::
504		on_pattern_edited(const Glib::ustring& path,
505		const Glib::ustring& new_text)
506		{
507		if(new_text.empty() )
508		{
509		Gtk::MessageDialog dlg(
510		m_parent,
511		_("Pattern must not be empty."),
512		false,
513		Gtk::MESSAGE_ERROR,
514		Gtk::BUTTONS_OK,
515		true
516		);
517
518		dlg.run();
519
520		// TODO: Take iterator at beginning and remove here back to
521		// path to avoid borkage
522		/*m_view.set_cursor(
523		Gtk::TreePath(path),
524		m_viewcol_pattern,
525		true
526		);*/
527		}
528		else
529		{
530		Gtk::TreeIter iter = m_file_list->get_iter(Gtk::TreePath(path));
531		(*iter)[file_columns.pattern] = new_text;
532		}
533		}
534
535		void Gobby::PreferencesDialog::FileList::
536		on_mimetype_edited(const Glib::ustring& path,
537		const Glib::ustring& new_text)
538		{
539		#ifdef WITH_GTKSOURCEVIEW2
540		const gchar* const* ids = gtk_source_language_manager_get_language_ids(m_lang_mgr);
541
542		GtkSourceLanguage* lang = NULL;
543
544		if(ids != NULL)
545		{
546		for(const gchar* const* id = ids; *id != NULL; ++ id)
547		{
548		GtkSourceLanguage* language = gtk_source_language_manager_get_language(m_lang_mgr, *id);
549
550		gchar** mime_types = gtk_source_language_get_mime_types(language);
551		for(gchar** mime_type = mime_types; *mime_type != NULL; ++ mime_type)
552		{
553		if(strcmp(*mime_type, new_text.c_str()) == 0)
554		{
555		lang = language;
556		break;
557		}
558		}
559
560		g_strfreev(mime_types);
561		if(lang != NULL) break;
562		}
563		}
564		#else
565		GtkSourceLanguage* lang =
566		gtk_source_languages_manager_get_language_from_mime_type(
567		m_lang_mgr, new_text.c_str());
568		#endif
569
570		if(!lang)
571		{
572		obby::format_string str(
573		_("There is no language with the mime type '%0%'.")
574		);
575
576		str << new_text.raw();
577
578		Gtk::MessageDialog dlg(
579		m_parent,
580		str.str(),
581		false,
582		Gtk::MESSAGE_ERROR,
583		Gtk::BUTTONS_OK,
584		true
585		);
586
587		dlg.run();
588		}
589		else
590		{
591		set_language(m_file_list->get_iter(Gtk::TreePath(path)), lang);
592		}
593		}
594
595		void Gobby::PreferencesDialog::FileList::
596		on_language_edited(const Glib::ustring& path,
597		const Glib::ustring& new_text)
598		{
599		// We do not get an iterator/path/whatever that points to the
600		// chosen language in the language list.
601		GtkSourceLanguage* lang = NULL;
602		Gtk::TreeNodeChildren children = m_lang_list->children();
603
604		for(Gtk::TreeIter iter = children.begin();
605		iter != children.end();
606		++ iter)
607		{
608		if( (*iter)[lang_columns.language_name] == new_text)
609		{
610		lang = (*iter)[lang_columns.language];
611		break;
612		}
613		}
614
615		if(!lang)
616		{
617		// The language must exist since we added all available
618		// languages to that list
619		throw std::logic_error(
620		"Gobby::PreferencesDialog::FileList::"
621		"on_language_edited:\n"
622		"Chosen language is not in language list"
623		);
624		}
625
626		set_language(m_file_list->get_iter(Gtk::TreePath(path)), lang);
627		}
628
629		void Gobby::PreferencesDialog::FileList::on_selection_changed()
630		{
631		std::list<Gtk::TreePath> list =
632		m_view.get_selection()->get_selected_rows();
633
634		m_btn_remove.set_sensitive(list.begin() != list.end() );
635		}
636
637		void Gobby::PreferencesDialog::FileList::on_file_add()
638		{
639		Gtk::TreeIter iter = m_file_list->append();
640		set_language(iter, m_lang_map.begin()->first);
641
642		m_view.set_cursor(
643		m_file_list->get_path(iter),
644		m_viewcol_pattern,
645		true
646		);
647		}
648
649		void Gobby::PreferencesDialog::FileList::on_file_remove()
650		{
651		std::list<Gtk::TreePath> list =
652		m_view.get_selection()->get_selected_rows();
653
654		std::list<Gtk::TreeIter> iter_list;
655
656		// Path offsets get borked when removing multiple rows, so we
657		// convert all paths to iterators before
658		for(std::list<Gtk::TreePath>::const_iterator iter = list.begin();
659		iter != list.end();
660		++ iter)
661		{
662		iter_list.push_back(m_file_list->get_iter(*iter) );
663		}
664
665		for(std::list<Gtk::TreeIter>::const_iterator iter = iter_list.begin();
666		iter != iter_list.end();
667		++ iter)
668		{
669		m_file_list->erase(*iter);
670		}
671		}
672
673		void Gobby::PreferencesDialog::FileList::set_language(const Gtk::TreeIter& row,
674		GtkSourceLanguage* lang)
675		{
676		map_type::const_iterator lang_it = m_lang_map.find(lang);
677		if(lang_it == m_lang_map.end() )
678		{
679		throw std::logic_error(
680		"Gobby::PreferencesDialog::FileList::set_language:\n"
681		"Given language is not in language map"
682		);
683		}
684
685		(*row)[file_columns.language] = lang_it->second;
686		#ifdef WITH_GTKSOURCEVIEW2
687		gchar** mime_types = gtk_source_language_get_mime_types(lang);
688
689		if(mime_types && *mime_types)
690		(row)[file_columns.mime_type] = mime_types;
691
692		g_strfreev(mime_types);
693		#else
694		GSList* mime_types = gtk_source_language_get_mime_types(lang);
695		for(GSList* cur = mime_types; cur != NULL; cur = cur->next)
696		{
697		if(cur == mime_types)
698		(*row)[file_columns.mime_type] =
699		static_cast<gchar*>(cur->data);
700		g_free(cur->data);
701		}
702		g_slist_free(mime_types);
703		#endif
	300	m_btn_font.set_font_name(font.to_string());
	301	m_btn_font.show();
	302
	303	m_group_toolbar.add(m_cmb_toolbar_style);
	304	m_group_toolbar.show();
	305
	306	m_group_font.add(m_btn_font);
	307	m_group_font.show();
	308
	309	add(m_group_toolbar);
	310	add(m_group_font);
704	311	}
705	312
706	313	Gobby::PreferencesDialog::PreferencesDialog(Gtk::Window& parent,
707		const Preferences& preferences,
708		GtkSourceLanguageManager* lang_mgr,
709		bool local)
710		: Gtk::Dialog(_("Preferences"), parent, true),
711		#ifndef GTKMM_DISABLE_DEPRECATED
712		m_page_editor(preferences, m_tooltips),
713		#else
	314	Preferences& preferences)
	315	: Gtk::Dialog(_("Preferences"), parent),
	316	m_preferences(preferences),
	317	m_page_user(preferences),
714	318	m_page_editor(preferences),
715		~~#endif~~
716	319	m_page_view(preferences),
717		m_page_appearance(preferences),
718		m_page_font(preferences),
719		m_page_behaviour(preferences),
720		m_page_files(*this, preferences, lang_mgr)
721		{
722		m_notebook.append_page(m_page_editor, _("Editor") );
723		m_notebook.append_page(m_page_view, _("View") );
724
725		// Appearance only affects the global Gobby window
726		if(!local) m_notebook.append_page(m_page_appearance, _("Appearance") );
727		m_notebook.append_page(m_page_font, _("Font") );
728		if(!local) m_notebook.append_page(m_page_behaviour, _("Behaviour") );
729		if(!local) m_notebook.append_page(m_page_files, _("Files") );
730
731		get_vbox()->set_spacing(5);
	320	m_page_appearance(preferences)
	321	{
	322	m_notebook.append_page(m_page_user, _("User"));
	323	m_notebook.append_page(m_page_editor, _("Editor"));
	324	m_notebook.append_page(m_page_view, _("View"));
	325	m_notebook.append_page(m_page_appearance, _("Appearance"));
	326
	327	m_page_user.show();
	328	m_page_editor.show();
	329	m_page_view.show();
	330	m_page_appearance.show();
	331
	332	get_vbox()->set_spacing(6);
732	333	get_vbox()->pack_start(m_notebook, Gtk::PACK_EXPAND_WIDGET);
733
734		add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
735		add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
736
737		set_border_width(10);
738		set_default_size(350, 400);
739		//set_resizable(false);
740
741		show_all();
742		}
743
744		void Gobby::PreferencesDialog::set(Preferences& preferences) const
745		{
746		m_page_editor.set(preferences.editor);
747		m_page_view.set(preferences.view);
748		m_page_appearance.set(preferences.appearance);
749		m_page_font.set(preferences.font);
750		m_page_behaviour.set(preferences.behaviour);
751		m_page_files.set(preferences.files);
752		}
753
	334	m_notebook.show();
	335
	336	add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
	337
	338	set_border_width(12);
	339	}
	340
	341	void Gobby::PreferencesDialog::on_response(int id)
	342	{
	343	hide();
	344	}

src/togglewindow.cpp

r9a19324	r0a50e446
31	31	sigc::mem_fun(*this, &ToggleWindow::on_activate) );
32	32
33		if(preferences.appearance.remember)
	33	/*if(preferences.appearance.remember)
34	34	{
35	35	// Read the ToggleWindow's last position from config
…	…
52	52	sigc::mem_fun(*this, &Gtk::Widget::show) );
53	53	}
54		}
	54	}*/
55	55
56	56	set_type_hint(Gdk::WINDOW_TYPE_HINT_UTILITY);
…	…
59	59	Gobby::ToggleWindow::~ToggleWindow()
60	60	{
61		if(m_preferences.appearance.remember)
	61	//if(m_preferences.appearance.remember)
62	62	{
63		int x, y, w, h;
	63	/* int x, y, w, h;
64	64	get_position(x, y);
65	65	get_size(w, h);
…	…
69	69	m_config_entry.set_value("width", w);
70	70	m_config_entry.set_value("height", h);
71		m_config_entry.set_value("visible", is_visible() );
	71	m_config_entry.set_value("visible", is_visible() );*/
72	72	}
73	73	}

src/window.cpp

re3caa739	r0a50e446
48	48	Gobby::Window::Window(const IconManager& icon_mgr, Config& config):
49	49	Gtk::Window(Gtk::WINDOW_TOPLEVEL), m_config(config),
50		~~#ifdef WITH_GTKSOURCEVIEW2~~
51	50	m_lang_manager(gtk_source_language_manager_new()),
52		#else
53		m_lang_manager(gtk_source_languages_manager_new()),
54		#endif
55		m_preferences(m_config, m_lang_manager), m_icon_mgr(icon_mgr),
	51	m_preferences(m_config), m_icon_mgr(icon_mgr),
56	52	m_application_state(APPLICATION_NONE),
57	53	m_document_settings(*this),
58	54	m_header(m_application_state, m_lang_manager),
59		m_folder(m_header, m_preferences),
	55	m_folder(m_header, m_preferences, m_lang_manager),
60	56	m_userlist(
61	57	*this,
…	…
200	196	}
201	197	#endif
202
203		~~if(m_preferences.appearance.remember)~~
204		{
205		~~Config::ParentEntry& screen = config.get_root()["screen"];~~
206
207		~~// Restore the window's position from the configuration~~
208		~~const int x = windows["main"].get_value<int>("x", 0);~~
209		~~const int y = windows["main"].get_value<int>("y", 0);~~
210		~~const int w = windows["main"].get_value<int>("width", 0);~~
211		~~const int h = windows["main"].get_value<int>("height", 0);~~
212
213		~~const int s_w = screen.get_value<int>("width", 0);~~
214		~~const int s_h = screen.get_value<int>("height", 0);~~
215		~~bool first_run = (x == 0 && y == 0 && w == 0 && h == 0);~~
216
217		~~Glib::RefPtr<Gdk::Screen> scr(get_screen() );~~
218		~~if( (scr->get_width() >= s_w && scr->get_height() >= s_h) &&~~
219		~~(!first_run) )~~
220		{
221		~~move(x, y);~~
222		~~resize(w, h);~~
223		}
224		}
225	198	}
226	199
…	…
238	211	m_header.action_window_chat->get_active()
239	212	);
240
241		~~// Save the window's current position~~
242		~~if(m_preferences.appearance.remember)~~
243		{
244		~~int x, y, w, h;~~
245		~~get_position(x, y); get_size(w, h);~~
246		~~Glib::RefPtr<Gdk::Screen> scr(get_screen() );~~
247
248		~~windows["main"].set_value("x", x);~~
249		~~windows["main"].set_value("y", y);~~
250		~~windows["main"].set_value("width", w);~~
251		~~windows["main"].set_value("height", h);~~
252
253		~~Config::ParentEntry& screen = m_config.get_root()["screen"];~~
254		~~screen.set_value("width", scr->get_width() );~~
255		~~screen.set_value("height", scr->get_height() );~~
256		}
257	213
258	214	/* Free explictely to make sure that the avahi poll is no longer
…	…
638	594	void Gobby::Window::on_settings_document_insert(LocalDocumentInfo& info)
639	595	{
640		~~// Mark automatically opened documents and subscribe to them.~~
641		~~if(m_preferences.behaviour.auto_open_new_documents~~
642		~~&& !info.is_subscribed() )~~
643		{
644		~~m_document_settings.set_automatically_opened(info, true);~~
645		~~info.subscribe();~~
646		}
647
648	596	// Set the path from which this document was opened,
649	597	// if we opened that file.
…	…
875	823	void Gobby::Window::on_edit_preferences()
876	824	{
877		PreferencesDialog dlg(*this, m_preferences, m_lang_manager, false);
878
879		// Info label
880		Gtk::Label lbl_info(_(
881		"Click on \"Apply\" to apply the new settings to documents "
882		"that are currently open. \"OK\" will just store the values "
883		"to use them with newly created documents."
884		) );
885
886		// Show info label and apply button if documents are open
887		if(m_buffer.get() && m_buffer->document_count() > 0)
888		{
889		// TODO: How to get the label to use all available space?
890		lbl_info.set_line_wrap(true);
891		lbl_info.set_alignment(Gtk::ALIGN_LEFT);
892
893		dlg.get_vbox()->pack_start(lbl_info, Gtk::PACK_SHRINK);
894		dlg.add_button(Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
895		lbl_info.show();
896		}
897
898		int result = dlg.run();
899		if(result == Gtk::RESPONSE_OK \|\| result == Gtk::RESPONSE_APPLY)
900		{
901		// Use new preferences
902		Preferences prefs;
903		dlg.set(prefs);
904		m_preferences = prefs;
905
906		// Apply window preferences
907		apply_preferences();
908
909		// Apply preferences to open documents.
910		if(result == Gtk::RESPONSE_APPLY)
911		{
912		for(int i = 0; i < m_folder.get_n_pages(); ++ i)
913		{
914		DocWindow& doc = static_cast<DocWindow>(
915		m_folder.get_nth_page(i) );
916		doc.set_preferences(m_preferences);
917		}
918		}
919		}
	825	if(m_preferences_dlg.get() == NULL)
	826	m_preferences_dlg.reset(
	827	new PreferencesDialog(*this, m_preferences));
	828
	829	m_preferences_dlg->present();
920	830	}
921	831
…	…
967	877	void Gobby::Window::on_view_preferences()
968	878	{
	879	#if 0
969	880	// Get current page
970	881	DocWindow* doc = get_current_document();
…	…
1014	925	doc->set_preferences(prefs);
1015	926	}
	927	#endif
1016	928	}
1017	929

Context Navigation

Changeset 0a50e4462d8d144fea8ba7b0c44c2dde2aee87a3

Legend:

Download in other formats: