Merge lp:~plprgt/zim/bookmarksbar-update into lp:~jaap.karssenberg/zim/pyzim

[Pl]

A small update to the BookmarksBar plugin.
The main changes:
- A new option to change maximum number of bookmarks is available from the plugin settings.
- If a bookmark has a special name it will not be changed after setting this bookmark to another page.
- If an open page has a corresponding bookmark it will be selected in the bar.
- Tests for the plugin are updated.

=== modified file 'data/manual/Plugins/BookmarksBar.txt'
--- data/manual/Plugins/BookmarksBar.txt	2015-09-24 09:50:39 +0000
+++ data/manual/Plugins/BookmarksBar.txt	2016-09-28 12:26:36 +0000
@@ -11,6 +11,7 @@
 ===== Plugin options =====
 The option **Save bookmarks** allows to save and load bookmarks and their names between different sessions. If it is unchecked all bookmarks will be automatically deleted after closing the program.
 The option **Add new bookmarks to the beginning of the bar** allows to choose the place where new bookmarks will be added. If checked all new bookmarks will be added to the beginning of the bar, if unchecked bookmarks will be added to the end of the bar. 
+It is possible to set the maximum number of bookmarks in the interval from 5 to 20.
 
 ===== Basic operations =====
 To show/hide the bar with bookmarks press **Bookmarks** button in the toolbar or press **<F4>** on keyboard.
@@ -24,7 +25,7 @@
 **Remove All** to delete all bookmarks from the bar,
 **Open in New Window** to open the bookmark in a new window,
 **Copy** to mark the bookmark for following "Paste",
-**Paste** to transfer the marked bookmark to the new position,
+**Paste** to transfer the marked bookmark to the new position. The position will be determined by coordinates of the mouse click which was made to invoke the popup menu,
 **Set New Name** to set a new name to the bookmark. The name is taken from the clipboard (if the name is too long, the plugin will take only first 25 symbols),
 **Back to Original Name** to return the bookmark to its default name. This option will appear only if the bookmark is renamed,
 **Set to Current Page** to change the bookmark into a bookmark of the currently opened page.
@@ -36,6 +37,6 @@
 ===== Restrictions =====
 Only existing pages (which have content or have sub-pages) can be added as bookmarks. If a page is deleted from the notebook its bookmark also will be deleted.
 No duplicate bookmarks are allowed in the bar, though there can be different bookmarks with identical names.
-The number of bookmarks is limited to 15.
+
 
 
 
=== modified file 'tests/bookmarksbar.py'
--- tests/bookmarksbar.py	2015-09-24 12:33:11 +0000
+++ tests/bookmarksbar.py	2016-09-28 12:26:36 +0000
@@ -1,225 +1,287 @@
-# -*- coding: utf-8 -*-
-
-# Copyright 2015 Pavel_M <[e-mail]>.
-# This is the test for BookmarksBar plugin.
-# BookmarksBar is the plugin for Zim program
-# by Jaap Karssenberg <[e-mail]>.
-
-
-import tests
-import gtk
-
-from zim.notebook import Path
-from zim.plugins.bookmarksbar import *
-from zim.config import ConfigDict
-from zim.gui.clipboard import Clipboard
-
-import logging
-logger = logging.getLogger('zim.plugins.bookmarksbar')
-
-
-class TestBookmarksBar(tests.TestCase):
-
-	def setUp(self):
-		self.notebook = tests.new_notebook()
-		self.index = self.notebook.index
-
-	def runTest(self):
-		'''There is one long test.'''
-
-		ui = MockUI()
-		ui.notebook = self.notebook
-		ui.page = Path('Test:foo')
-		uistate = ConfigDict()
-		self.assertTrue(self.notebook.get_page(ui.page).exists())
-
-		PATHS = ('Parent:Daughter:Granddaughter',
-				 'Test:tags', 'Test:foo', 'Books')
-		LEN_PATHS = len(PATHS)
-		PATHS_NAMES = {PATHS[0]:'name 1', PATHS[1]:'name 2', PATHS[2]:'name 3'}
-
-		# Check correctness of reading uistate.
-		uistate.setdefault('bookmarks', [])
-		uistate.setdefault('bookmarks_names', {})
-
-		uistate['bookmarks'] = list(PATHS)
-		uistate['bookmarks_names'] = dict(PATHS_NAMES)
-		Bar = BookmarkBar(ui, uistate, get_page_func = lambda: '')
-		self.assertTrue(Bar.paths == list(PATHS))
-		self.assertTrue(Bar.paths_names == PATHS_NAMES)
-
-		uistate['bookmarks'] = []
-		uistate['bookmarks_names'] = {}
-		Bar = BookmarkBar(ui, uistate, get_page_func = lambda: '')
-		self.assertTrue(Bar.paths == [])
-		self.assertTrue(Bar.paths_names == {})
-
-		# Add paths to the beginning of the bar.
-		for i, path in enumerate(PATHS):
-			Bar._add_new(path, add_bookmarks_to_beginning = True)
-			self.assertTrue(len(Bar.paths) == i + 1)
-		self.assertTrue(Bar.paths == list(reversed(PATHS)))
-
-		# Add paths to the end of the bar.
-		Bar.paths = []
-		for i, path in enumerate(PATHS):
-			Bar._add_new(path, add_bookmarks_to_beginning = False)
-			self.assertTrue(len(Bar.paths) == i + 1)
-		self.assertTrue(Bar.paths == list(PATHS))
-
-		# Check that the same path can't be added to the bar.
-		Bar._add_new(PATHS[0])
-		Bar._add_new(PATHS[1])
-		self.assertTrue(Bar.paths == list(PATHS))
-
-		# Delete paths from the bar.
-		for i, button in enumerate(Bar.container.get_children()[2:]):
-			path = button.zim_path
-			self.assertTrue(path in Bar.paths)
-			Bar.delete(button.zim_path)
-			self.assertTrue(len(Bar.paths) == LEN_PATHS - i - 1)
-			self.assertTrue(path not in Bar.paths)
-		self.assertTrue(Bar.paths == [])
-
-		# Check short page names.
-		uistate['show_full_page_name'] = False
-		for path in PATHS:
-			Bar._add_new(path)
-		self.assertTrue(Bar.paths == list(PATHS))
-		for i, button in enumerate(Bar.container.get_children()[2:]):
-			self.assertTrue(PATHS[i] == button.zim_path)
-			self.assertTrue(Path(PATHS[i]).basename == button.get_label())
-		uistate['show_full_page_name'] = True
-
-		# Delete all bookmarks from the bar.
-		Bar.delete_all()
-		self.assertTrue(Bar.paths == [])
-
-		# Check restriction of max bookmarks in the bar.
-		pagelist = set(self.index.list_pages(None))
-		_enhanced_pagelist = set()
-		for page in pagelist:
-			_enhanced_pagelist.update( set(self.index.list_pages(page)) )
-			if len(_enhanced_pagelist) > MAX_BOOKMARKS:
-				break
-		pagelist.update(_enhanced_pagelist)
-		self.assertTrue(len(pagelist) > MAX_BOOKMARKS)
-		pagelist = list(pagelist)
-		for page in pagelist:
-			Bar._add_new(page.name)
-		self.assertTrue(len(Bar.paths) == MAX_BOOKMARKS)
-		self.assertTrue(Bar.paths == [a.name for a in pagelist[:MAX_BOOKMARKS]])
-		Bar.delete_all()
-
-		# Check 'save' option in preferences.
-		for i, path in enumerate(PATHS):
-			Bar.on_preferences_changed({'save':False, 'add_bookmarks_to_beginning':False})
-			Bar._add_new(path)
-			self.assertTrue(uistate['bookmarks'] == [])
-			Bar.on_preferences_changed({'save':True, 'add_bookmarks_to_beginning':False})
-			self.assertTrue(uistate['bookmarks'] == list(PATHS[:i+1]))
-		self.assertTrue(uistate['bookmarks'] == list(PATHS))
-
-		# Check changing a bookmark.
-		self.assertTrue('Test' not in Bar.paths)
-		self.assertTrue('Books' in Bar.paths)
-		Bar.change_bookmark('Books', 'Books')
-		self.assertTrue(Bar.paths == list(PATHS))
-		_b_paths = [a for a in Bar.paths if a != 'Books']
-		Bar.change_bookmark('Books', 'Test')
-		self.assertTrue('Test' in Bar.paths)
-		self.assertTrue('Books' not in Bar.paths)
-		_e_paths = [a for a in Bar.paths if a != 'Test']
-		self.assertTrue(_b_paths == _e_paths)
-
-		Bar.change_bookmark('Test', 'Books')
-		self.assertTrue(Bar.paths == list(PATHS))
-
-		# Check deleting a bookmark after deleting a page in the notebook.
-		self.assertTrue(len(Bar.paths) == LEN_PATHS)
-		for i, path in enumerate(PATHS):
-			self.assertTrue(path in Bar.paths)
-			self.notebook.delete_page(Path(path))
-			self.assertTrue(path not in Bar.paths)
-			self.assertTrue(len(Bar.paths) == LEN_PATHS - i - 1)
-		self.assertTrue(Bar.paths == [])
-
-		# Check reordering bookmarks.
-		PATHS_2 = ('1','2','3','4','5')
-		PATHS_NAMES_2 = {PATHS_2[0]:'11', PATHS_2[1]:'22', PATHS_2[2]:'33'}
-
-		Bar.paths = list(PATHS_2)
-		Bar.move_bookmark(PATHS_2[2], PATHS_2[2], 'left')
-		self.assertTrue(Bar.paths == list(PATHS_2))
-		Bar.move_bookmark(PATHS_2[3], PATHS_2[3], 'right')
-		self.assertTrue(Bar.paths == list(PATHS_2))
-		Bar.move_bookmark('3', '1', 'left')
-		self.assertTrue(Bar.paths == ['3','1','2','4','5'])
-		Bar.move_bookmark('5', '1', 'left')
-		self.assertTrue(Bar.paths == ['3','5','1','2','4'])
-		Bar.move_bookmark('5', '1', 'right')
-		self.assertTrue(Bar.paths == ['3','1','5','2','4'])
-		Bar.move_bookmark('3', '4', 'right')
-		self.assertTrue(Bar.paths == ['1','5','2','4','3'])
-		Bar.move_bookmark('5', '4', '-')
-		self.assertTrue(Bar.paths == ['1','5','2','4','3'])
-
-		# CHECK RENAMING
-		# Check rename_bookmark and save options.
-		Bar.paths = list(PATHS_2)
-		button = gtk.Button(label = PATHS_2[0], use_underline = False)
-		button.zim_path = PATHS_2[0]
-		Bar.on_preferences_changed({'save':True, 'add_bookmarks_to_beginning':False})
-		Bar._reload_bar()
-
-		def rename_check(label, path, paths_names, path_names_uistate):
-			self.assertTrue(button.get_label() == label)
-			self.assertTrue(button.zim_path == path)
-			self.assertTrue(Bar.paths_names == paths_names)
-			self.assertTrue(uistate['bookmarks_names'] == path_names_uistate)
-
-		rename_check(PATHS_2[0], PATHS_2[0], {}, {})
-		Clipboard.set_text('new name')
-		Bar.rename_bookmark(button)
-		rename_check('new name', PATHS_2[0], {PATHS_2[0]:'new name'}, {PATHS_2[0]:'new name'})
-		Bar.on_preferences_changed({'save':False, 'add_bookmarks_to_beginning':False})
-		rename_check('new name', PATHS_2[0], {PATHS_2[0]:'new name'}, {})
-		Bar.on_preferences_changed({'save':True, 'add_bookmarks_to_beginning':False})
-		rename_check('new name', PATHS_2[0], {PATHS_2[0]:'new name'}, {PATHS_2[0]:'new name'})
-		Bar.rename_bookmark(button)
-		rename_check(PATHS_2[0], PATHS_2[0], {}, {})
-
-		# Check delete with renaming.
-		Bar.on_preferences_changed({'save':True, 'add_bookmarks_to_beginning':False})
-		paths_names_copy = dict(PATHS_NAMES_2)
-		Bar.paths_names = dict(PATHS_NAMES_2)
-		for key in PATHS_NAMES_2:
-			Bar.delete(key)
-			del paths_names_copy[key]
-			self.assertTrue(Bar.paths_names == paths_names_copy)
-			self.assertTrue(uistate['bookmarks_names'] == Bar.paths_names)
-
-		# Check delete all with renaming.
-		Bar.paths_names = dict(PATHS_NAMES_2)
-		Bar.delete_all()
-		self.assertTrue(Bar.paths_names == {})
-		self.assertTrue(uistate['bookmarks_names'] == {})
-
-		# Check change bookmark with renaming.
-		Bar.paths = list(PATHS_2)
-		Bar.paths_names = dict(PATHS_NAMES_2)
-		paths_names_copy = dict(PATHS_NAMES_2)
-		paths_names_copy.pop(PATHS_2[0], None)
-		Bar.change_bookmark(PATHS_2[0], 'new path')
-		self.assertTrue(Bar.paths_names == paths_names_copy)
-		self.assertTrue(Bar.paths == ['new path'] + list(PATHS_2[1:]))
-
-		# Check that paths and paths_names didn't change in the process.
-		self.assertTrue(PATHS_2 == ('1','2','3','4','5'))
-		self.assertTrue(PATHS_NAMES_2 == {PATHS_2[0]:'11', PATHS_2[1]:'22', PATHS_2[2]:'33'})
-
-
-class MockUI(tests.MockObject):
-	page = None
-	notebook = None
-
+# -*- coding: utf-8 -*-
+
+# Copyright 2015-2016 Pavel_M <[e-mail]>,
+# released under the GNU GPL version 3.
+
+# This is the test for BookmarksBar plugin.
+# BookmarksBar is the plugin for Zim program
+# by Jaap Karssenberg <[e-mail]>.
+
+
+import tests
+import gtk
+
+from zim.notebook import Path
+from zim.plugins.bookmarksbar import *
+from zim.config import ConfigDict
+from zim.gui.clipboard import Clipboard
+
+import logging
+logger = logging.getLogger('zim.plugins.bookmarksbar')
+
+
+class TestBookmarksBar(tests.TestCase):
+
+	@classmethod
+	def setUpClass(cls):
+		cls.notebook = tests.new_notebook()
+		cls.index = cls.notebook.index
+		cls.ui = MockUI()
+		cls.ui.notebook = cls.notebook
+		cls.ui.page = Path('Test:foo')
+
+
+	def setUp(self):
+		self.PATHS = ('Parent:Daughter:Granddaughter',
+				 'Test:tags', 'Test:foo', 'Books')
+		self.LEN_PATHS = len(self.PATHS)
+		self.PATHS_NAMES = {self.PATHS[0]:'name 1', self.PATHS[1]:'name 2', self.PATHS[2]:'name 3'}
+
+		self.uistate = ConfigDict()
+		self.uistate.setdefault('bookmarks', [])
+		self.uistate.setdefault('bookmarks_names', {})
+		self.uistate.setdefault('show_full_page_name', True)
+
+
+	def testGeneral(self):
+		'''Test general functions: add, delete bookmarks.'''
+
+		self.assertTrue(self.notebook.get_page(self.ui.page).exists())
+
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		Bar.max_bookmarks = 15 # set maximum number of bookmarks
+
+		# Add paths to the beginning of the bar.
+		for i, path in enumerate(self.PATHS):
+			Bar._add_new(path, add_bookmarks_to_beginning = True)
+			self.assertEqual(len(Bar.paths), i + 1)
+		self.assertTrue(Bar.paths == list(reversed(self.PATHS)))
+
+		# Add paths to the end of the bar.
+		Bar.paths = []
+		for i, path in enumerate(self.PATHS):
+			Bar._add_new(path, add_bookmarks_to_beginning = False)
+			self.assertEqual(len(Bar.paths), i + 1)
+		self.assertEqual(Bar.paths, list(self.PATHS))
+
+		# Check that the same path can't be added to the bar.
+		Bar._add_new(self.PATHS[0])
+		Bar._add_new(self.PATHS[1])
+		self.assertEqual(Bar.paths, list(self.PATHS))
+
+		# Delete paths from the bar.
+		for i, button in enumerate(Bar.container.get_children()[2:]):
+			path = button.zim_path
+			self.assertTrue(path in Bar.paths)
+			Bar.delete(button.zim_path)
+			self.assertEqual(len(Bar.paths), self.LEN_PATHS - i - 1)
+			self.assertTrue(path not in Bar.paths)
+		self.assertEqual(Bar.paths, [])
+
+		# Delete all bookmarks from the bar.
+		Bar.delete_all()
+		self.assertEqual(Bar.paths, [])
+
+
+	def testDeletePages(self):
+		'''Check deleting a bookmark after deleting a page in the notebook.'''
+
+		notebook = tests.new_notebook()
+		ui = MockUI()
+		ui.notebook = notebook
+		self.uistate['bookmarks'] = list(self.PATHS)
+
+		Bar = BookmarkBar(ui, self.uistate, get_page_func = lambda: '')
+		for i, path in enumerate(self.PATHS):
+			self.assertTrue(path in Bar.paths)
+			notebook.delete_page(Path(path))
+			self.assertTrue(path not in Bar.paths)
+			self.assertEqual(len(Bar.paths), self.LEN_PATHS - i - 1)
+		self.assertEqual(Bar.paths, [])
+
+
+	def testFunctions(self):
+		'''Test bookmark functions: changing, reordering, ranaming.'''
+
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		Bar.max_bookmarks = 15 # set maximum number of bookmarks
+
+		# Check changing a bookmark.
+		for i, path in enumerate(self.PATHS):
+			Bar._add_new(path, add_bookmarks_to_beginning = False)
+
+		self.assertTrue('Test' not in Bar.paths)
+		self.assertTrue('Books' in Bar.paths)
+		Bar.change_bookmark('Books', 'Books')
+		self.assertEqual(Bar.paths, list(self.PATHS))
+		Bar.change_bookmark('Books', 'Test')
+		self.assertTrue('Test' in Bar.paths)
+		self.assertTrue('Books' not in Bar.paths)
+		_result = [a if a != 'Books' else 'Test' for a in self.PATHS]
+		self.assertEqual(Bar.paths, _result)
+
+		Bar.change_bookmark('Test', 'Books')
+		self.assertEqual(Bar.paths, list(self.PATHS))
+
+		# Check reordering bookmarks.
+		new_paths = ('1','2','3','4','5')
+
+		Bar.paths = list(new_paths)
+		Bar.move_bookmark(new_paths[2], new_paths[2], 'left')
+		self.assertEqual(Bar.paths, list(new_paths))
+		Bar.move_bookmark(new_paths[3], new_paths[3], 'right')
+		self.assertEqual(Bar.paths, list(new_paths))
+		Bar.move_bookmark('3', '1', 'left')
+		self.assertEqual(Bar.paths, ['3','1','2','4','5'])
+		Bar.move_bookmark('5', '1', 'left')
+		self.assertEqual(Bar.paths, ['3','5','1','2','4'])
+		Bar.move_bookmark('5', '1', 'right')
+		self.assertEqual(Bar.paths, ['3','1','5','2','4'])
+		Bar.move_bookmark('3', '4', 'right')
+		self.assertEqual(Bar.paths, ['1','5','2','4','3'])
+		Bar.move_bookmark('5', '4', '-')
+		self.assertEqual(Bar.paths, ['1','5','2','4','3'])
+
+		# Check rename_bookmark and save options.
+		preferences_changed = lambda save: Bar.on_preferences_changed({'save': save,
+				'add_bookmarks_to_beginning': False,
+				'max_bookmarks': 15})
+
+		new_path_names = {new_paths[0]:'11', new_paths[1]:'22', new_paths[2]:'33'}
+		Bar.paths = list(new_paths)
+		preferences_changed(True)
+		Bar._reload_bar()
+
+		def rename_check(label, path, paths_names, path_names_uistate):
+			self.assertEqual(button.get_label(), label)
+			self.assertEqual(button.zim_path, path)
+			self.assertEqual(Bar.paths_names, paths_names)
+			self.assertEqual(self.uistate['bookmarks_names'], path_names_uistate)
+
+		button = gtk.Button(label = new_paths[0], use_underline = False)
+		button.zim_path = new_paths[0]
+		rename_check(new_paths[0], new_paths[0], {}, {})
+
+		Clipboard.set_text('new name')
+		Bar.rename_bookmark(button)
+		rename_check('new name', new_paths[0], {new_paths[0]:'new name'}, {new_paths[0]:'new name'})
+		preferences_changed(False)
+		rename_check('new name', new_paths[0], {new_paths[0]:'new name'}, {})
+		preferences_changed(True)
+		rename_check('new name', new_paths[0], {new_paths[0]:'new name'}, {new_paths[0]:'new name'})
+		Bar.rename_bookmark(button)
+		rename_check(new_paths[0], new_paths[0], {}, {})
+
+		# Check delete with renaming.
+		preferences_changed(True)
+		paths_names_copy = dict(new_path_names)
+		Bar.paths_names = dict(new_path_names)
+		for key in new_path_names:
+			Bar.delete(key)
+			del paths_names_copy[key]
+			self.assertEqual(Bar.paths_names, paths_names_copy)
+			self.assertEqual(self.uistate['bookmarks_names'], Bar.paths_names)
+
+		# Check delete all with renaming.
+		Bar.paths_names = dict(new_path_names)
+		Bar.delete_all()
+		self.assertEqual(Bar.paths_names, {})
+		self.assertEqual(self.uistate['bookmarks_names'], {})
+
+		# Check change bookmark with renaming.
+		new_path_names = {new_paths[0]:'11', new_paths[1]:'22', new_paths[2]:'33'}
+
+		Bar.paths = list(new_paths)
+		Bar.paths_names = dict(new_path_names)
+		paths_names_copy = dict(new_path_names)
+		_name = paths_names_copy.pop(new_paths[0])
+		paths_names_copy['new path'] = _name
+		Bar.change_bookmark(new_paths[0], 'new path')
+		self.assertEqual(Bar.paths_names, paths_names_copy)
+		self.assertEqual(Bar.paths, ['new path'] + list(new_paths[1:]))
+
+
+	def testPreferences(self):
+		'''Check preferences: full/short page names, save option, 
+		max number of bookmarks.'''
+
+		# Check short page names.
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		self.uistate['show_full_page_name'] = False
+		for path in self.PATHS:
+			Bar._add_new(path)
+		self.assertEqual(Bar.paths, list(self.PATHS))
+		for i, button in enumerate(Bar.container.get_children()[2:]):
+			self.assertEqual(self.PATHS[i], button.zim_path)
+			self.assertEqual(Path(self.PATHS[i]).basename, button.get_label())
+
+		# Show full page names.
+		Bar.toggle_show_full_page_name()
+		self.assertEqual(Bar.paths, list(self.PATHS))
+		for i, button in enumerate(Bar.container.get_children()[2:]):
+			self.assertEqual(self.PATHS[i], button.zim_path)
+			self.assertEqual(self.PATHS[i], button.get_label())
+
+		# Check save option.
+		self.uistate['bookmarks'] = list(self.PATHS)
+		self.uistate['bookmarks_names'] = dict(self.PATHS_NAMES)
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		self.assertEqual(Bar.paths, list(self.PATHS))
+		self.assertEqual(Bar.paths_names, self.PATHS_NAMES)
+
+		self.uistate['bookmarks'] = []
+		self.uistate['bookmarks_names'] = {}
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		self.assertEqual(Bar.paths, [])
+		self.assertEqual(Bar.paths_names, {})
+
+		# Get pages to check max number of bookmarks.
+		pagelist = set(self.index.list_pages(None))
+		_enhanced_pagelist = set()
+		for page in pagelist:
+			_enhanced_pagelist.update( set(self.index.list_pages(page)) )
+			if len(_enhanced_pagelist) > 20:
+				break
+		pagelist.update(_enhanced_pagelist)
+		pagelist = [a.name for a in pagelist if a.exists()]
+		self.assertTrue(len(pagelist) > 20)
+
+		def preferences_changed(save, max_b):
+			Bar.on_preferences_changed({
+				'save': save,
+				'add_bookmarks_to_beginning': False,
+				'max_bookmarks': max_b})
+
+		# Check that more than max bookmarks can be loaded at start.
+		self.uistate['bookmarks'] = pagelist
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		self.assertEqual(pagelist, Bar.paths)
+		preferences_changed(True, 5)
+		self.assertEqual(pagelist, Bar.paths)
+		self.assertEqual(pagelist, self.uistate['bookmarks'])
+
+		# Set maximum number of bookmarks.
+		self.uistate['bookmarks'] = []
+		Bar = BookmarkBar(self.ui, self.uistate, get_page_func = lambda: '')
+		for max_bookmarks in (5, 10, 15, 20):
+			preferences_changed(False, max_bookmarks)
+			for page in pagelist:
+				Bar._add_new(page)
+			self.assertEqual(len(Bar.paths), max_bookmarks)
+			self.assertEqual(Bar.paths, pagelist[:max_bookmarks])
+			Bar.delete_all()
+
+		# Check 'save' option in preferences.
+		for i, path in enumerate(self.PATHS):
+			preferences_changed(False, 15)
+			Bar._add_new(path)
+			self.assertEqual(self.uistate['bookmarks'], [])
+			preferences_changed(True, 15)
+			self.assertEqual(self.uistate['bookmarks'], list(self.PATHS[:i+1]))
+		self.assertEqual(self.uistate['bookmarks'], list(self.PATHS))
+
+
+class MockUI(tests.MockObject):
+	page = None
+	notebook = None
+
 
=== modified file 'zim/plugins/bookmarksbar.py'
--- zim/plugins/bookmarksbar.py	2015-10-08 18:31:40 +0000
+++ zim/plugins/bookmarksbar.py	2016-09-28 12:26:36 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
-# Copyright 2015 Pavel_M <[e-mail]>.
+# Copyright 2015-2016 Pavel_M <[e-mail]>,
+# released under the GNU GPL version 3.
 # This plugin is for Zim program by Jaap Karssenberg <[e-mail]>.
 #
 # This plugin uses an icon from Tango Desktop Project (http://tango.freedesktop.org/)
@@ -21,9 +22,6 @@
 import logging
 logger = logging.getLogger('zim.plugins.bookmarksbar')
 
-# Constant for max number of bookmarks in the bar.
-MAX_BOOKMARKS = 15
-
 # Keyboard shortcut constants.
 BM_TOGGLE_BAR_KEY ='F4'
 BM_ADD_BOOKMARK_KEY ='<alt>1'
@@ -40,6 +38,7 @@
 
 	plugin_preferences = (
 		# key, type, label, default
+		('max_bookmarks', 'int', _('Maximum number of bookmarks'), 15, (5, 20)), # T: plugin preference
 		('save', 'bool', _('Save bookmarks'), True), # T: preferences option
 		('add_bookmarks_to_beginning', 'bool', _('Add new bookmarks to the beginning of the bar'), False), # T: preferences option
 	)
@@ -70,7 +69,7 @@
 	def __init__(self, plugin, window):
 		WindowExtension.__init__(self, plugin, window)
 		self.widget = BookmarkBar(self.window.ui, self.uistate,
-								  self.window.pageview.get_page)
+					  self.window.pageview.get_page)
 		self.widget.show_all()
 
 		# Add a new option to the Index popup menu.
@@ -149,10 +148,12 @@
 		self.uistate = uistate
 		self.save_flag = False # if True save bookmarks in config
 		self.add_bookmarks_to_beginning = False # add new bookmarks to the end of the bar
+		self.max_bookmarks = False # maximum number of bookmarks
 		self._get_page = get_page_func # function to get current page
 
 		# Create button to add new bookmarks.
 		self.plus_button = IconsButton(gtk.STOCK_ADD, gtk.STOCK_REMOVE, relief = False)
+		self.plus_button.set_tooltip_text(_('Add bookmark/Show settings'))
 		self.plus_button.connect('clicked', lambda o: self.add_new_page())
 		self.plus_button.connect('button-release-event', self.do_plus_button_popup_menu)
 		self.pack_start(self.plus_button, expand = False)
@@ -164,7 +165,7 @@
 		# Toggle between full/short page names.
 		self.uistate.setdefault('show_full_page_name', False)
 
-		# Save path to use later in Cut/Paste menu.
+		# Save path to use later in Copy/Paste menu.
 		self._saved_bookmark = None
 
 		self.paths = [] # list of bookmarks as string objects
@@ -173,7 +174,8 @@
 		# Add pages from config to the bar.
 		for path in self.uistate['bookmarks']:
 			page = self.ui.notebook.get_page(Path(path))
-			self.add_new_page(page, reload_bar = False)
+			if page.exists() and (page.name not in self.paths):
+				self.paths.append(page.name)
 
 		self.paths_names = {} # dict of changed names of bookmarks
 		self.uistate.setdefault('bookmarks_names', {})
@@ -189,46 +191,46 @@
 				except:
 					logger.error('BookmarksBar: Error while loading path_names.')
 
-		self._reload_bar()
+		# Look for new pages to mark corresponding bookmarks in the bar.
+		self.connectto(self.ui, 'open-page', self.on_open_page)
 
 		# Delete a bookmark if a page is deleted.
 		self.connectto(self.ui.notebook.index, 'page-deleted',
 					   lambda obj, path: self.delete(path.name))
 
-	def add_new_page(self, page = None, reload_bar = True):
+	def on_open_page(self, ui, page, path):
+		'''If a page is present as a bookmark than select it.'''
+		pagename = page.name
+		for button in self.container.get_children()[2:]:
+			if button.zim_path == pagename:
+				button.set_active(True)
+			else:
+				button.set_active(False)
+	
+	def add_new_page(self, page = None):
 		'''
 		Add new page as bookmark to the bar.
 		:param page: L{Page}, if None takes currently opened page,
-		:reload_bar: if True reload the bar.
 		'''
 		if not page:
 			page = self._get_page()
 
 		if page.exists():
-			return self._add_new(page.name, self.add_bookmarks_to_beginning, reload_bar)
-
-	def _add_new(self, path, add_bookmarks_to_beginning = False, reload_bar = True):
+			return self._add_new(page.name, self.add_bookmarks_to_beginning)
+		
+	def _add_new(self, path, add_bookmarks_to_beginning = False):
 		'''Add bookmark to the bar.
 		:param path: path as a string object
 		:param add_bookmarks_to_beginning: bool,
 		add new bookmarks to the beginning of the bar,
-		:reload_bar: if True reload the bar.
 		'''
 		if path in self.paths:
 			logger.debug('BookmarksBar: path is already in the bar.')
-
-			# Temporary change icon for plus_button to show
-			# that bookmark is already in the bar.
-			def _change_icon():
-				'''Function to be called only once.'''
-				self.plus_button.change_state()
-				return False
-			self.plus_button.change_state()
-			gobject.timeout_add(300, _change_icon)
+			self.plus_button.blink()
 			return False
 
 		# Limit max number of bookmarks.
-		if len(self.paths) >= MAX_BOOKMARKS:
+		if self.max_bookmarks and (len(self.paths) >= self.max_bookmarks):
 			logger.debug('BookmarksBar: max number of bookmarks is achieved.')
 			return False
 
@@ -238,7 +240,7 @@
 		else:
 			self.paths.append(path)
 
-		if reload_bar: self._reload_bar()
+		self._reload_bar()
 
 	def delete(self, path):
 		'''
@@ -284,8 +286,13 @@
 
 		if new_path and (new_path not in self.paths) and (new_path != old_path):
 			self.paths[self.paths.index(old_path)] = new_path
-			self.paths_names.pop(old_path, None)
+			name = self.paths_names.pop(old_path, None)
+			if name:
+				self.paths_names[new_path] = name
+
 			self._reload_bar()
+		else:
+			self.plus_button.blink()
 
 	def move_bookmark(self, first, second, direction):
 		'''
@@ -350,7 +357,7 @@
 	def do_bookmarks_popup_menu(self, button, event):
 		'''Handler for button-release-event, triggers popup menu for bookmarks.'''
 		if event.button != 3:
-                        return False
+			return False
 
 		path = button.zim_path
 
@@ -371,13 +378,12 @@
 					(_('Remove'), lambda o: self.delete(path)),			# T: menu item
 				    (_('Remove All'), lambda o: self.delete_all(True)),	# T: menu item
 				    ('separator', ''),
-				    (_('Open in New Window'), lambda o: self.ui.open_new_window(Path(path))), # T: menu item
-				    ('separator', ''),
 				    ('gtk-copy', lambda o: set_save_bookmark(path)),
 				    ('gtk-paste', lambda o: self.move_bookmark(self._saved_bookmark, path, direction)),
 				    ('separator', ''),
+				    (_('Open in New Window'), lambda o: self.ui.open_new_window(Path(path))), # T: menu item
+				    ('separator', ''),
 				    (rename_button_text, lambda o: self.rename_bookmark(button)),
-				    ('separator', ''),
 				    (_('Set to Current Page'), lambda o: self.change_bookmark(path)) ) # T: menu item
 
 		for name, func in main_menu_items:
@@ -412,6 +418,10 @@
 			self.uistate['bookmarks'] = []
 			self.uistate['bookmarks_names'] = {}
 
+		if self.max_bookmarks != preferences['max_bookmarks']:
+			self.max_bookmarks = preferences['max_bookmarks']
+			self._reload_bar() # to update plus_button
+
 	def _get_short_page_name(self, name):
 		'''
 		Function to return short name for the page.
@@ -430,6 +440,12 @@
 		for button in self.container.get_children()[2:]:
 			self.container.remove(button)
 
+		page = self._get_page()
+		if page:
+			pagename = page.name
+		else:
+			pagename = None
+
 		for path in self.paths:
 			if path in self.paths_names:
 				name = self.paths_names[path]
@@ -437,16 +453,19 @@
 				name = self._get_short_page_name(path)
 			else:
 				name = path
-			button = gtk.Button(label = name, use_underline = False)
+			button = gtk.ToggleButton(label = name, use_underline = False)
 			button.set_tooltip_text(path)
 			button.zim_path = path
+			if path == pagename:
+				button.set_active(True)
+
 			button.connect('clicked', self.on_bookmark_clicked)
 			button.connect('button-release-event', self.do_bookmarks_popup_menu)
 			button.show()
 			self.container.add(button)
 
 		# 'Disable' plus_button if max bookmarks is reached.
-		if len(self.paths) >= MAX_BOOKMARKS:
+		if self.max_bookmarks and (len(self.paths) >= self.max_bookmarks):
 			self.plus_button.change_state(False)
 		else:
 			self.plus_button.change_state(True)
@@ -501,3 +520,13 @@
 			self._enabled_state = not self._enabled_state
 			self.show_all()
 
+	def blink(self):
+		'''Quickly change an icon to show
+		that bookmark can't be added/changed.'''
+
+		def change_icon():
+			'''Function to be called only once.'''
+			self.change_state()
+			return False
+		self.change_state()
+		gobject.timeout_add(300, change_icon)