Merge lp:~chaghi/zim/zim-profiles into lp:~jaap.karssenberg/zim/pyzim

[Mariano Draghi]

Support for notebook profiles, and preferences and styles per profile. Fixes bug #539370 and bug #656446

=== modified file 'tests/config.py'
--- tests/config.py	2011-11-06 12:22:35 +0000
+++ tests/config.py	2012-03-18 15:46:18 +0000
@@ -366,6 +366,37 @@
 		))
 		self.assertTrue(isinstance(mydict.order, list))
 
+	def testChangeFile(self):
+		'''Test changing the file used as datastore'''
+		file = XDG_CONFIG_HOME.file('zim/config_TestConfigFile.conf')
+		if file.exists():
+			file.remove()
+		assert not file.exists()
+		conf = ConfigDictFile(file)
+		conf['Foo']['xyz'] = 'foooooo'
+		conf['Bar']['empty'] = ''
+		conf.write()
+		text = u'''\
+[Foo]
+xyz=foooooo
+
+[Bar]
+empty=
+
+'''
+		self.assertEqual(file.read(), text)
+		file_new = XDG_CONFIG_HOME.file('zim/config_TestConfigFile2.conf')
+		if file_new.exists():
+			file_new.remove()
+		assert not file_new.exists()
+		conf.change_file(file_new)
+		file.remove()
+		conf.write()
+		assert not file.exists()
+		self.assertEqual(file_new.read(), text)
+
+		del conf
+		file_new.remove()
 
 class TestHeaders(TestCase):
 

=== modified file 'tests/gui.py'
--- tests/gui.py	2012-03-17 19:39:28 +0000
+++ tests/gui.py	2012-03-18 15:46:18 +0000
@@ -293,6 +293,7 @@
 			'icon': './icon.png',
 			'document_root': File('/foo').path, # win32 save test
 			'shared': False,
+			'profile': '',
 		}
 		config2 = {
 			'name': 'Notebook Bar',
@@ -301,6 +302,7 @@
 			'icon': './picture.png',
 			'document_root': File('/bar').path, # win32 save test
 			'shared': True,
+			'profile': 'foo',
 		}
 		notebook.save_properties(**config1)
 		self.assertEqual(notebook.config['Notebook'], config1)
@@ -417,6 +419,11 @@
 		items = menu.get_children()
 		self.assertGreater(len(items), 3)
 
+		# open notebook (so the default plugins are loaded)
+		nb = ui.notebook
+		ui.notebook = None
+		ui.open_notebook(nb)
+
 		# remove plugins
 		self.assertGreater(len(ui.plugins), 3) # default plugins
 		plugins = [p.plugin_key for p in ui.plugins]

=== modified file 'tests/notebook.py'
--- tests/notebook.py	2011-12-11 14:03:58 +0000
+++ tests/notebook.py	2012-03-18 15:46:18 +0000
@@ -9,13 +9,13 @@
 import os
 
 from zim.fs import File, Dir
-from zim.config import config_file
+from zim.config import config_file, ConfigDictFile, XDG_CONFIG_HOME
 from zim.notebook import *
 from zim.index import *
 import zim.errors
 from zim.formats import ParseTree
 
-from zim import _get_default_or_only_notebook
+from zim import NotebookInterface, _get_default_or_only_notebook
 	# private, but want to check it anyway
 
 
@@ -745,3 +745,133 @@
 
 		text = ''.join(notebook.get_page(Path('page3:page1:child')).dump('wiki'))
 		self.assertEqual(text, 'I have backlinks !\n')
+
+
+class TestProfiles(tests.TestCase):
+
+	def setUp(self):
+		path = self.get_tmp_name()
+		self.notebook = tests.new_notebook(fakedir=path)
+
+	def testProfilePreferences(self):
+		'''Test the profile is used and its preferences applied'''
+
+		assert not self.notebook.profile
+
+		# set up a test profile
+		file = XDG_CONFIG_HOME.file('zim/profiles/profile_TestProfile.conf')
+		if file.exists():
+			file.remove()
+		assert not file.exists()
+		profile = ConfigDictFile(file)
+		profile['GtkInterface'] = {}
+		profile['General']['plugins'] = ['calendar',]
+		profile['CalendarPlugin']['embedded'] = True
+		profile['CalendarPlugin']['granularity'] = 'Week'
+		profile['CalendarPlugin']['namespace'] = 'TestProfile'
+		profile.write()
+
+		# se the profile name in the notebook, open it, and
+		# check that the profila was applied
+		self.notebook.config['Notebook']['profile'] = 'profile_TestProfile'
+		self.assertEqual(self.notebook.profile, 'profile_TestProfile')
+		interface = NotebookInterface(self.notebook)
+		self.assertEqual(interface.preferences.file, file)
+		self.assertTrue(len(interface.preferences['GtkInterface'].keys()) == 0)
+		self.assertTrue(len(interface.plugins) == 1)
+		self.assertEqual(interface.preferences['General']['plugins'][0],
+				   'calendar')
+		self.assertTrue(interface.preferences['CalendarPlugin']['embedded'])
+		self.assertEqual(interface.preferences['CalendarPlugin']['granularity'],
+				   'Week')
+		self.assertEqual(interface.preferences['CalendarPlugin']['namespace'],
+				   'TestProfile')
+
+
+	def testNewProfile(self):
+		'''Test that current preferences are used if the profile doesn't exist '''
+		assert not self.notebook.profile
+
+		# create a completely default base configuration
+		base = XDG_CONFIG_HOME.file('zim/preferences.conf')
+		if base.exists():
+			base.remove()
+		assert not base.exists()
+		interface = NotebookInterface(self.notebook)
+		interface.preferences.write() # ensure the preferences are saved
+		assert base.exists()
+
+		# set up a test profile
+		file = XDG_CONFIG_HOME.file('zim/profiles/profile_TestProfile.conf')
+		if file.exists():
+			file.remove()
+		assert not file.exists()
+
+		# change the profile name, and reload the profile
+		# check that the current preferences didn't change
+		self.notebook.config['Notebook']['profile'] = 'profile_TestProfile'
+		self.assertEqual(self.notebook.profile, 'profile_TestProfile')
+		interface.load_profile()
+		self.assertEqual(interface.preferences.file, file)
+		interface.preferences.write() # ensure the preferences are saved
+
+		self.assertEqual(file.read(), base.read())
+
+	def testPluginUnload(self):
+		'''Test unloading plugins not present in the profile configuration'''
+		assert not self.notebook.profile
+
+		# open notebook with the default profile
+		interface = NotebookInterface(self.notebook)
+		# we need more than one plugin loaded for this test
+		assert len(interface.plugins) > 1
+
+		# create a profile just with the 1st loaded plugin
+		plugin_to_keep = interface.plugins[0].plugin_key
+		interface.preferences['General']['plugins'] = [plugin_to_keep,]
+		file = XDG_CONFIG_HOME.file('zim/profiles/profile_TestProfile.conf')
+		if file.exists():
+			file.remove()
+		assert not file.exists()
+		interface.preferences.change_file(file)
+		interface.preferences.write()
+
+		# load the new profile and check that all plugins but the one
+		# we kept were unloaded
+		self.notebook.config['Notebook']['profile'] = 'profile_TestProfile'
+		interface.load_profile()
+		self.assertEqual(len(interface.plugins), 1)
+		self.assertEqual(interface.plugins[0].plugin_key, plugin_to_keep)
+
+	def testIndependentPluginsAreKept(self):
+		'''Test that independent plugins already loaded are added to the profile if not present'''
+		assert not self.notebook.profile
+
+        # ensure that the base configuration declares an independent plugin
+		interface = NotebookInterface(self.notebook)
+		if 'automount' not in interface.preferences['General']['plugins']:
+			interface.preferences['General']['plugins'].append('automount')
+		interface.preferences.write() # ensure the preferences are saved
+		base = config_file('preferences.conf')
+		assert base.file.exists()
+		self.assertTrue('automount' in base['General']['plugins'])
+
+		# recreate the interface ensuring it's loading the automount plugin
+		interface = NotebookInterface(self.notebook)
+		self.assertTrue('automount' in [p.plugin_key for p in interface.plugins])
+
+		# create a profile without the automount plugin
+		file = XDG_CONFIG_HOME.file('zim/profiles/profile_TestProfile.conf')
+		if file.exists():
+			file.remove()
+		assert not file.exists()
+		profile = ConfigDictFile(file)
+		profile['General']['plugins'] = []
+		profile.write()
+
+		# load the new profile and check that the automount plugin was kept
+		self.notebook.config['Notebook']['profile'] = 'profile_TestProfile'
+		interface.load_profile()
+		self.assertTrue('automount' in interface.preferences['General']['plugins'])
+		self.assertTrue('automount' in [p.plugin_key for p in interface.plugins])
+

=== modified file 'tests/pageview.py'
--- tests/pageview.py	2012-02-17 23:41:57 +0000
+++ tests/pageview.py	2012-03-18 15:46:18 +0000
@@ -11,7 +11,7 @@
 from zim.formats import wiki, ParseTree
 from zim.notebook import Path
 from zim.gui.pageview import *
-from zim.config import ConfigDict
+from zim.config import ConfigDict, ConfigDictFile, XDG_CONFIG_HOME
 from zim.gui.clipboard import Clipboard
 
 
@@ -1793,6 +1793,37 @@
 		buffer = textview.get_buffer()
 		self.assertEqual(buffer.get_text(*buffer.get_bounds()), 'Foo')
 
+	def testProfile(self):
+		'''Test that style for a specific profile is applied.'''
+		# first test without profile
+		pageview = setUpPageView()
+		pageview.ui.notebook.config['Notebook']['profile'] = None
+		pageview.on_preferences_changed(pageview.ui)
+		file = XDG_CONFIG_HOME.file('zim/style.conf')
+		self.assertEqual(pageview.style.file, file)
+
+		# create a new style based on the default one, changing some properties
+		new_style = ConfigDictFile(file)
+		new_style['TextView']['indent'] = 50
+		new_style['TextView']['font'] = 'Sans 8'
+		new_style['TextView']['linespacing'] = 10
+		file = XDG_CONFIG_HOME.file('zim/styles/style_testProfile.conf')
+		if file.exists():
+			file.remove()
+		new_style.change_file(file)
+		new_style.write()
+
+		# test the pageview with the profile
+		pageview.ui.notebook.config['Notebook']['profile'] = 'style_testProfile'
+		pageview.on_preferences_changed(pageview.ui)
+		self.assertEqual(pageview.style.file, file)
+		self.assertEqual(pageview.style['TextView']['indent'], 50)
+		self.assertEqual(pageview.style['TextView']['font'], 'Sans 8')
+		self.assertEqual(pageview.style['TextView']['linespacing'], 10)
+
+		# if we don't have a notebook, we shouldn't fail!
+		pageview.ui.notebook = None
+		pageview.on_preferences_changed(pageview.ui)
 
 
 class MockUI(tests.MockObject):

=== modified file 'tests/plugins.py'
--- tests/plugins.py	2012-01-09 20:51:16 +0000
+++ tests/plugins.py	2012-03-18 15:46:18 +0000
@@ -23,6 +23,9 @@
 		self.assertTrue('spell' in plugins)
 		self.assertTrue('linkmap' in plugins)
 
+		# plugins listed here will be tested for is_profile_independent == True
+		profile_independent = ['automount',]
+
 		seen = {
 			'name': set(),
 			'description': set(),
@@ -70,6 +73,13 @@
 				self.assertTrue(isinstance(dep[i][1],bool))
 				self.assertTrue(isinstance(dep[i][2],bool))
 
+			# test is_profile_independent
+			self.assertTrue(isinstance(plugin.is_profile_independent,bool))
+			if name in profile_independent:
+				self.assertTrue(plugin.is_profile_independent)
+			else:
+				self.assertFalse(plugin.is_profile_independent)
+
 	def testDefaulPlugins(self):
 		'''Test loading default plugins'''
 		# Note that we use parent interface class here, so plugins

=== modified file 'zim/__init__.py'
--- zim/__init__.py	2012-02-28 20:28:58 +0000
+++ zim/__init__.py	2012-03-18 15:46:18 +0000
@@ -109,7 +109,8 @@
 
 from zim.fs import File, Dir
 from zim.errors import Error
-from zim.config import data_dir, config_file, log_basedirs, ZIM_DATA_DIR
+from zim.config import data_dir, config_file, log_basedirs, ZIM_DATA_DIR, \
+					   XDG_CONFIG_HOME, ConfigDictFile
 
 
 logger = logging.getLogger('zim')
@@ -500,6 +501,9 @@
 	@signal: C{open-notebook (notebook)}:
 	Emitted to open a notebook in this interface
 
+	@signal: C{preferences-changed ()}:
+	Emitted when preferences have changed
+
 	@cvar ui_type: string to tell plugins what interface is supported
 	by this class. Currently this can be "gtk" or "html". If "ui_type"
 	is None we run without interface (e.g. commandline export).
@@ -516,6 +520,7 @@
 	# define signals we want to use - (closure type, return type and arg types)
 	__gsignals__ = {
 		'open-notebook': (gobject.SIGNAL_RUN_LAST, None, (object,)),
+		'preferences-changed': (gobject.SIGNAL_RUN_LAST, None, ()),
 	}
 
 	ui_type = None
@@ -531,32 +536,51 @@
 		self.notebook = None
 		self.plugins = []
 
+		# Here we'll keep the list of the base plugins, i.e., those configured
+		# in the general preferences.conf, or the default ones. This is 
+		# needed in two scenarios:
+		#   - When opening a Notebook, firt we'll load only the 'independent'
+		#     plugins, and will keep only those in the preferences. When the
+		#     profile is loaded, we'll need the complete list of plugins that
+		#     we were supposed to load.
+		#   - When changing to a profile that doesn't exist yet, we'll need
+		#     to know which are the base/default ones
+		self._base_plugins = None
+
 		self.preferences = config_file('preferences.conf')
 		self.uistate = None
 
 		if not notebook is None:
 			self.open_notebook(notebook)
 
-	def load_plugins(self):
+	def load_plugins(self, independent_only=False):
 		'''Loads all the plugins defined in the preferences
 
 		Typically called from the constructor of sub-classes.
+
+		@param independent_only: if True, load only the plugins flagged
+		as profile independent.
+
 		'''
 		default = ['calendar', 'insertsymbol', 'printtobrowser', 'versioncontrol']
 		self.preferences['General'].setdefault('plugins', default)
 		plugins = self.preferences['General']['plugins']
 		plugins = set(plugins) # Eliminate doubles
 
+		# Keep the base/default plugins
+		if independent_only or self._base_plugins is None:
+			self._base_plugins = sorted(plugins)
+
 		# Plugins should not have dependency on order of being added
 		# but sort them here to make behavior predictable.
 		for name in sorted(plugins):
-			self.load_plugin(name)
+			self.load_plugin(name, independent_only)
 
 		loaded = [p.plugin_key for p in self.plugins]
 		if set(loaded) != plugins:
 			self.preferences['General']['plugins'] = sorted(loaded)
 
-	def load_plugin(self, name):
+	def load_plugin(self, name, independent_only=False):
 		'''Load a single plugin by name
 
 		Load an plugin object and attach it to the current application
@@ -569,7 +593,10 @@
 		@param name: the plugin name as understood by
 		L{zim.plugins.get_plugin()}
 
-		@returns: the plugin object or C{None} when failed
+		@param independent_only: if True, load the plugin only if it is
+		flagged as profile independent. Otherwise ignore it
+
+		@returns: the plugin object or C{None} when failed or ignored
 
 		@todo: make load_plugin raise exception on failure
 		'''
@@ -582,13 +609,19 @@
 
 		try:
 			klass = zim.plugins.get_plugin(name)
-			if not klass.check_dependencies_ok():
-				raise AssertionError, 'Dependencies failed for plugin %s' % name
-			plugin = klass(self)
+			if independent_only and not klass.is_profile_independent:
+				plugin = None
+				logger.debug('Ignoring plugin %s.', name)
+			else:
+				if not klass.check_dependencies_ok():
+					raise AssertionError, 'Dependencies failed for plugin %s' % name
+				plugin = klass(self)
 		except:
 			logger.exception('Failed to load plugin %s', name)
 			return None
 		else:
+			if not plugin:
+				return None
 			self.plugins.append(plugin)
 			logger.debug('Loaded plugin %s (%s)', name, plugin)
 
@@ -677,6 +710,110 @@
 			self.emit('open-notebook', notebook)
 			return None
 
+	def load_profile(self, profile_changed=True):
+		'''Load the specific profile for a Notebook.
+
+		If the notebook defines its own profile, update the preferences
+		with it. Check if there are any plugins to load and initialize them.
+
+		@param profile_changed: indicates that the profile is being loaded
+		on top of a previous one. When opening the L{Notebook} it will be
+		False. Any other call should use True
+
+		@emits: preferences-changed
+		'''
+		assert not self.notebook is None, 'BUG: Must open a notebook first'
+
+		# restore the complete list of base/default plugins, if needed
+		# this is important if we are changing the profile (maybe the new one
+		# does not exist yet) or if we don't have a profile (we are either
+		# opening the notebook, or going back to the default profile)
+		if (profile_changed or not self.notebook.profile) and \
+	                               self._base_plugins is not None:
+			self.preferences['General']['plugins'] = self._base_plugins
+
+		profile = None
+		if self.notebook.profile:
+			# use a specific profile. If it exists, merge its preferences
+			logger.debug('Using profile %s', self.notebook.profile)
+			file = XDG_CONFIG_HOME.file(('zim','profiles',self.notebook.profile + '.conf'))
+			if file.exists():
+				profile = ConfigDictFile(file)
+				self._merge_profile_preferences(profile)
+		else:
+			# use the general/base profile
+			logger.debug('Using the base profile')
+			base_profile = config_file('preferences.conf')
+			file = base_profile.file
+			if profile_changed:
+				self._merge_profile_preferences(base_profile)
+
+		if profile_changed or profile:
+			# unload any loaded plugins not present in the merged
+			# preferenfces. If we are changing the profile, or have just
+			# loaded a specific one, we might have loaded plugins that don't
+			# belong to this configuration
+			for plugin in [p for p in self.plugins if p.plugin_key not in self.preferences['General']['plugins']]:
+				# we don't use unload_plugin because it would trigger
+				# a preferences.write() !!!
+				plugin.disconnect()
+				self.plugins.remove(plugin)
+				logger.debug('Unloaded plugin %s', plugin.plugin_key)
+
+		# Load the plugins. This will pull the non-independent plugins
+		# when opening a Notebook, or the complete set of plugins configured
+		# for the profile we're just loading
+		self.load_plugins()
+
+		# change the file used to store the preferences, if needed
+		if profile_changed or self.notebook.profile:
+			self.preferences.change_file(file)
+			self.emit('preferences-changed')
+			if profile_changed:
+				# refresh the preferences for all the loaded plugins
+				for plugin in self.plugins:
+					plugin.preferences = self.preferences[plugin.__class__.__name__]
+					plugin.emit('preferences-changed')
+
+
+	def _merge_profile_preferences(self, conf):
+		logger.debug('Merging profile preferences')
+
+		# sections of the preferences that might be overriden
+		# by a notebook profile
+		overridable_sections = ['GtkInterface', 'PageView', 'General',]
+
+		# Override the preferences with the notebook's own profile
+		for section in overridable_sections:
+			if conf.has_key(section):
+				self.preferences[section] = conf[section]
+				logger.debug('Overriding section %s with with the configured profile', section)
+
+		# replace the preferences for each plugin with the ones defined
+		# in the profile. Ignore the profile independent ones.
+		import zim.plugins
+		for name in self.preferences['General']['plugins']:
+			try:
+				klass = zim.plugins.get_plugin(name)
+			except:
+				logger.exception('Failed to find plugin %s', name)
+				continue
+
+			if klass.is_profile_independent:
+				continue
+			config_key = klass.__name__
+			if conf.has_key(config_key):
+				self.preferences[config_key] = conf[config_key]
+				logger.debug('Overriding section %s with the configured profile', config_key)
+		# add any independent plugins already loaded to the profile
+		# configuration
+		plugins = self.preferences['General']['plugins']
+		loaded = [p.plugin_key for p in self.plugins \
+				  if p.is_profile_independent and p.plugin_key not in plugins]
+		plugins.extend(loaded)
+		self.preferences['General']['plugins'] = sorted(plugins)
+				
+
 	def do_open_notebook(self, notebook):
 		assert self.notebook is None, 'BUG: other notebook opened already'
 		self.notebook = notebook
@@ -689,6 +826,8 @@
 			from zim.config import ConfigDict
 			self.uistate = ConfigDict()
 
+		self.load_profile(False)
+
 	def cmd_export(self, format='html', template=None, page=None, output=None, root_url=None, index_page=None):
 		'''Convenience method hat wraps L{zim.exporter.Exporter} for
 		commandline export

=== modified file 'zim/config.py'
--- zim/config.py	2012-03-17 17:01:16 +0000
+++ zim/config.py	2012-03-18 15:46:18 +0000
@@ -770,6 +770,12 @@
 		self.set_modified(False)
 		return operation
 
+	def change_file(self, file):
+		'''Change the underlaying file used to read/write data
+		'''
+		self.file = file
+		self.set_modified(True)
+
 
 class ConfigDictFile(ConfigFile, ConfigDict):
 	pass

=== modified file 'zim/gui/__init__.py'
--- zim/gui/__init__.py	2012-03-17 19:39:28 +0000
+++ zim/gui/__init__.py	2012-03-18 15:46:18 +0000
@@ -378,7 +378,6 @@
 		'open-page': (gobject.SIGNAL_RUN_LAST, None, (object, object)),
 		'close-page': (gobject.SIGNAL_RUN_LAST, None, (object, bool)),
 		'new-window': (gobject.SIGNAL_RUN_LAST, None, (object,)),
-		'preferences-changed': (gobject.SIGNAL_RUN_LAST, None, ()),
 		'readonly-changed': (gobject.SIGNAL_RUN_LAST, None, ()),
 		'quit': (gobject.SIGNAL_RUN_LAST, None, ()),
 		'start-index-update': (gobject.SIGNAL_RUN_LAST, None, ()),
@@ -479,7 +478,10 @@
 				lambda o, event: event.keyval == gtk.keysyms.F6
 					and self.mainwindow.toggle_fullscreen())
 
-		self.load_plugins()
+		# If opening a notebook, load only the independent plugins at
+		# this stage.
+		independent_only = notebook is not None
+		self.load_plugins(independent_only)
 
 		self._custom_tool_ui_id = None
 		self._custom_tool_actiongroup = None
@@ -542,8 +544,8 @@
 		else:
 			pass # Will check default in main()
 
-	def load_plugin(self, name):
-		plugin = NotebookInterface.load_plugin(self, name)
+	def load_plugin(self, name, independent_only=False):
+		plugin = NotebookInterface.load_plugin(self, name, independent_only)
 		if plugin and self._finalize_ui:
 			plugin.finalize_ui(self)
 
@@ -1179,6 +1181,11 @@
 		for action in ('open_document_root', 'open_document_folder'):
 			action = self.actiongroup.get_action(action)
 			action.set_sensitive(has_doc_root)
+			# check if the profile was changed, and load the new one
+			if notebook.profile_changed:
+				logger.debug('Profile changed to "%s"', notebook.profile)
+				notebook.profile_changed = False # clear the flag
+				self.load_profile(True) # load the profile
 
 	def open_page(self, path=None):
 		'''Method to open a page in the mainwindow, and menu action for

=== modified file 'zim/gui/pageview.py'
--- zim/gui/pageview.py	2012-03-17 16:01:31 +0000
+++ zim/gui/pageview.py	2012-03-18 15:46:18 +0000
@@ -31,7 +31,7 @@
 from zim.errors import Error
 from zim.notebook import Path, interwiki_link
 from zim.parsing import link_type, Re, url_re
-from zim.config import config_file
+from zim.config import config_file, ConfigDictFile, XDG_CONFIG_HOME
 from zim.formats import get_format, increase_list_iter, \
 	ParseTree, TreeBuilder, ParseTreeBuilder, \
 	BULLET, CHECKED_BOX, UNCHECKED_BOX, XCHECKED_BOX
@@ -4425,6 +4425,7 @@
 			#~ action.connect('activate', lambda o, *a: logger.warn(o.get_name()))
 			action.connect('activate', self.do_toggle_format_action)
 
+		self._profile = None # last used profile to avoid reloading the conf
 		if self.style is None:
 			PageView.style = config_file('style.conf')
 		self.on_preferences_changed(self.ui)
@@ -4437,6 +4438,22 @@
 		self.view.grab_focus()
 
 	def on_preferences_changed(self, ui):
+		if ui.notebook and (not self._profile or self._profile != ui.notebook.profile):
+			# the profile has changed. Keep record of the new one
+			# and if there's a style for the profile, use it
+			self._profile = ui.notebook.profile # update current profile
+			if self._profile:
+				file = XDG_CONFIG_HOME.file(('zim','styles',self._profile + '.conf'))
+			if self._profile and file.exists():
+                # use the specific style
+				PageView.style.change_file(file)
+				PageView.style.read()
+				logger.debug('Loaded specific style for profile %s',
+								self._profile)
+			else:
+                # use the general style
+				PageView.style = config_file('style.conf')
+				logger.debug('Using the general style')
 		self._reload_style()
 		self.view.set_cursor_visible(
 			self.preferences['read_only_cursor'] or not self.readonly)

=== modified file 'zim/notebook.py'
--- zim/notebook.py	2012-02-17 19:36:00 +0000
+++ zim/notebook.py	2012-03-18 15:46:18 +0000
@@ -534,6 +534,7 @@
 	if os.name == 'nt': endofline = 'dos'
 	else: endofline = 'unix'
 	config['Notebook']['endofline'] = endofline
+	config['Notebook']['profile'] = None
 	config.write()
 
 
@@ -688,6 +689,10 @@
 	@ivar config: A L{ConfigDict} for the notebook config
 	(the C{X{notebook.zim}} config file in the notebook folder)
 	@ivar lock: An L{AsyncLock} for async notebook operations
+	@ivar profile: The name of the profile used by the notebook (empty means
+	default profile)
+	@ivar profile_changed: Flag indicating if the profile was changed and the
+	new one has to be loaded
 
 	In general this lock is not needed when only reading data from
 	the notebook. However it should be used when doing operations that
@@ -723,6 +728,7 @@
 		('interwiki', 'string', _('Interwiki Keyword'), lambda v: not v or is_interwiki_keyword_re.search(v)), # T: label for properties dialog
 		('icon', 'image', _('Icon')), # T: label for properties dialog
 		('document_root', 'dir', _('Document Root')), # T: label for properties dialog
+		('profile', 'string', _('Profile')), # T: label for properties dialog
 		('shared', 'bool', _('Shared Notebook')), # T: label for properties dialog
 		#~ ('autosave', 'bool', _('Auto-version when closing the notebook')),
 			# T: label for properties dialog
@@ -750,6 +756,7 @@
 			# async file operations. This one is more abstract for the
 			# notebook as a whole, regardless of storage
 		self.readonly = True
+		self.profile_changed = False
 
 		if dir:
 			assert isinstance(dir, Dir)
@@ -797,6 +804,7 @@
 		else: endofline = 'unix'
 		self.config['Notebook'].setdefault('endofline', endofline, check=set(('dos', 'unix')))
 		self.config['Notebook'].setdefault('disable_trash', False)
+		self.config['Notebook'].setdefault('profile', '', check=basestring)
 
 		self.do_properties_changed()
 
@@ -834,6 +842,11 @@
 
 		return NotebookInfo(uri, **self.config['Notebook'])
 
+	@property
+	def profile(self):
+		'''The 'profile' property for this notebook'''
+		return self.config['Notebook'].get('profile', '')
+
 	def _cache_dir(self, dir):
 		from zim.config import XDG_CACHE_HOME
 		if os.name == 'nt':
@@ -874,6 +887,11 @@
 		if 'home' in properties and isinstance(properties['home'], Path):
 			properties['home'] = properties['home'].name
 
+		# When handling properties-changed later, we'll need to know
+		# which is the current profile, to detect if it's changed
+		if 'profile' in properties and properties['profile'] != self.profile:
+			self.profile_changed = True
+
 		self.config['Notebook'].update(properties)
 		self.config.write()
 		self.emit('properties-changed')

=== modified file 'zim/plugins/__init__.py'
--- zim/plugins/__init__.py	2011-08-06 17:18:57 +0000
+++ zim/plugins/__init__.py	2012-03-18 15:46:18 +0000
@@ -246,7 +246,8 @@
 	will be initialized when the plugin is loaded.
 
 	Plugin classes should define two class attributes: L{plugin_info} and
-	L{plugin_preferences}.
+	L{plugin_preferences}. Optionally, they can also define the class
+	attribute L{is_profile_independent}.
 
 	@cvar plugin_info: A dict with basic information about the plugin,
 	it should contain at least the following keys:
@@ -275,6 +276,12 @@
 	Changes to these preferences will be stored in a config file so
 	they are persistent.
 
+	@cvar is_profile_independent: A boolean indicating that the plugin
+	configuration is global and not meant to change between notebooks.
+	The default value (if undefined) is False. Plugins that set
+	L{is_profile_independent} to True will be initialized before
+	opening the notebook.
+
 	@ivar ui: the main application object, e.g. an instance of
 	L{zim.gui.GtkInterface} or L{zim.www.WWWInterface}
 	@ivar preferences: a C{ListDict()} with plugin preferences
@@ -304,6 +311,8 @@
 
 	plugin_preferences = ()
 
+	is_profile_independent = False
+
 	@classmethod
 	def check_dependencies_ok(klass):
 		'''Checks minimum dependencies are met

=== modified file 'zim/plugins/automount.py'
--- zim/plugins/automount.py	2011-12-11 18:35:35 +0000
+++ zim/plugins/automount.py	2012-03-18 15:46:18 +0000
@@ -26,6 +26,9 @@
 		'help': 'Plugins:Automount',
 	}
 
+	# this plugin is profile independent
+	is_profile_independent = True
+
 	def get_config(self, uri):
 		'''Return the automount config for a specific notebook uri or C{None}
 		@param uri: a notebook uri