Pull from trunk

src/calibre/ebooks/conversion/preprocess.py

@@ -166,6 +166,17 @@ class HTMLPreProcessor(object):
                   (re.compile(u'`\s*(<br.*?>)*\s*O', re.UNICODE), lambda match: u'Ò'),
                   (re.compile(u'`\s*(<br.*?>)*\s*u', re.UNICODE), lambda match: u'ù'),
                   (re.compile(u'`\s*(<br.*?>)*\s*U', re.UNICODE), lambda match: u'Ù'),
+                  # ` with letter before
+                  (re.compile(u'a\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'à'),
+                  (re.compile(u'A\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'À'),
+                  (re.compile(u'e\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'è'),
+                  (re.compile(u'E\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'È'),
+                  (re.compile(u'i\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'ì'),
+                  (re.compile(u'I\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'Ì'),
+                  (re.compile(u'o\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'ò'),
+                  (re.compile(u'O\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'Ò'),
+                  (re.compile(u'u\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'ù'),
+                  (re.compile(u'U\s*(<br.*?>)*\s*`', re.UNICODE), lambda match: u'Ù'),
 
                   # ´
                   (re.compile(u'´\s*(<br.*?>)*\s*a', re.UNICODE), lambda match: u'á'),

src/calibre/ebooks/pml/pmlconverter.py

@@ -207,6 +207,7 @@ class PML_HTMLizer(object):
         while html != old:
             old = html
             html = self.cleanup_html_remove_redundant(html)
+        html = re.sub(r'(?imu)^\s*', '', html)
         return html
 
     def cleanup_html_remove_redundant(self, html):
@@ -216,7 +217,7 @@ class PML_HTMLizer(object):
                 html = re.sub(r'(?u)%s\s*%s' % (open % '.*?', close), '', html)
             else:
                 html = re.sub(r'(?u)%s\s*%s' % (open, close), '', html)
-        html = re.sub(r'<p>\s*</p>', '', html)
+        html = re.sub(r'(?imu)<p>\s*</p>', '', html)
         return html
 
     def start_line(self):
@@ -556,7 +557,7 @@ class PML_HTMLizer(object):
                             text = t
                         else:
                             self.toc.add_item(os.path.basename(self.file_name), id, value)
-                            text = '<span id="%s"></span>%s' % (id, t)
+                            text = '%s<span id="%s"></span>' % (t, id)
                     elif c == 'm':
                         empty = False
                         src = self.code_value(line)

src/calibre/ebooks/txt/processor.py

@@ -77,7 +77,7 @@ def separate_paragraphs_print_formatted(txt):
 
 def preserve_spaces(txt):
     txt = txt.replace(' ', ' ')
-    txt = txt.replace('\t', '	')
+    txt = txt.replace('\t', '    ')
     return txt
 
 def opf_writer(path, opf_name, manifest, spine, mi):

src/calibre/gui2/library/models.py

@@ -121,10 +121,8 @@ class BooksModel(QAbstractTableModel): # {{{
     def set_device_connected(self, is_connected):
         self.device_connected = is_connected
         self.db.refresh_ondevice()
-        self.refresh()
+        self.refresh() # does a resort()
         self.research()
-        if is_connected and self.sorted_on[0] == 'ondevice':
-            self.resort()
 
     def set_book_on_device_func(self, func):
         self.book_on_device = func
@@ -249,7 +247,7 @@ class BooksModel(QAbstractTableModel): # {{{
             # the search and count records for restrictions
             self.searched.emit(True)
 
-    def sort(self, col, order, reset=True):
+    def sort(self, col, order, reset=True, update_history=True):
         if not self.db:
             return
         self.about_to_be_sorted.emit(self.db.id)
@@ -260,23 +258,23 @@ class BooksModel(QAbstractTableModel): # {{{
             self.clear_caches()
             self.reset()
         self.sorted_on = (label, order)
+        if update_history:
             self.sort_history.insert(0, self.sorted_on)
         self.sorting_done.emit(self.db.index)
 
     def refresh(self, reset=True):
-        try:
-            col = self.column_map.index(self.sorted_on[0])
-        except:
-            col = 0
         self.db.refresh(field=None)
-        self.sort(col, self.sorted_on[1], reset=reset)
+        self.resort(reset=reset)
 
-    def resort(self, reset=True):
+    def resort(self, reset=True, history=5): # Bug report needed history=4 :)
+        for col,ord in reversed(self.sort_history[:history]):
             try:
-            col = self.column_map.index(self.sorted_on[0])
+                col = self.column_map.index(col)
             except ValueError:
                 col = 0
-        self.sort(col, self.sorted_on[1], reset=reset)
+            self.sort(col, ord, reset=False, update_history=False)
+        if reset:
+            self.reset()
 
     def research(self, reset=True):
         self.search(self.last_search, reset=reset)

src/calibre/gui2/tag_view.py

@@ -512,7 +512,8 @@ class TagsModel(QAbstractItemModel): # {{{
                     _('The saved search name %s is already used.')%val).exec_()
                 return False
             saved_searches().rename(unicode(item.data(role).toString()), val)
-            self.tags_view.search_item_renamed.emit()
+            item.tag.name = val
+            self.tags_view.search_item_renamed.emit() # Does a refresh
         else:
             if key == 'series':
                 self.db.rename_series(item.tag.id, val)
@@ -669,7 +670,7 @@ class TagBrowserMixin(object): # {{{
         self.tags_view.saved_search_edit.connect(self.do_saved_search_edit)
         self.tags_view.author_sort_edit.connect(self.do_author_sort_edit)
         self.tags_view.tag_item_renamed.connect(self.do_tag_item_renamed)
-        self.tags_view.search_item_renamed.connect(self.saved_search.clear_to_help)
+        self.tags_view.search_item_renamed.connect(self.saved_searches_changed)
         self.edit_categories.clicked.connect(lambda x:
                 self.do_user_categories_edit())
 

src/calibre/library/caches.py

@@ -141,6 +141,8 @@ class ResultCache(SearchQueryParser):
         for x in self.iterall():
             yield x[idx]
 
+    # Search functions {{{
+
     def universal_set(self):
         return set([i[0] for i in self._data if i is not None])
 
@@ -462,6 +464,30 @@ class ResultCache(SearchQueryParser):
                             continue
         return matches
 
+    def search(self, query, return_matches=False):
+        ans = self.search_getting_ids(query, self.search_restriction)
+        if return_matches:
+            return ans
+        self._map_filtered = ans
+
+    def search_getting_ids(self, query, search_restriction):
+        q = ''
+        if not query or not query.strip():
+            q = search_restriction
+        else:
+            q = query
+            if search_restriction:
+                q = u'%s (%s)' % (search_restriction, query)
+        if not q:
+            return list(self._map)
+        matches = sorted(self.parse(q))
+        return [id for id in self._map if id in matches]
+
+    def set_search_restriction(self, s):
+        self.search_restriction = s
+
+    # }}}
+
     def remove(self, id):
         self._data[id] = None
         if id in self._map:
@@ -549,7 +575,9 @@ class ResultCache(SearchQueryParser):
             self.sort(field, ascending)
         self._map_filtered = list(self._map)
         if self.search_restriction:
-            self.search('', return_matches=False, ignore_search_restriction=False)
+            self.search('', return_matches=False)
+
+    # Sorting functions {{{
 
     def seriescmp(self, sidx, siidx, x, y, library_order=None):
         try:
@@ -615,24 +643,6 @@ class ResultCache(SearchQueryParser):
         self._map.sort(cmp=fcmp, reverse=not ascending)
         self._map_filtered = [id for id in self._map if id in self._map_filtered]
 
-    def search(self, query, return_matches=False):
+    # }}}
-        ans = self.search_getting_ids(query, self.search_restriction)
-        if return_matches:
-            return ans
-        self._map_filtered = ans
 
-    def search_getting_ids(self, query, search_restriction):
-        q = ''
-        if not query or not query.strip():
-            q = search_restriction
-        else:
-            q = query
-            if search_restriction:
-                q = u'%s (%s)' % (search_restriction, query)
-        if not q:
-            return list(self._map)
-        matches = sorted(self.parse(q))
-        return [id for id in self._map if id in matches]
 
-    def set_search_restriction(self, s):
-        self.search_restriction = s

src/calibre/library/field_metadata.py

@@ -69,6 +69,8 @@ class FieldMetadata(dict):
     VALID_DATA_TYPES = frozenset([None, 'rating', 'text', 'comments', 'datetime',
                                   'int', 'float', 'bool', 'series'])
 
+    # Builtin metadata {{{
+
     _field_metadata = [
             ('authors',   {'table':'authors',
                            'column':'name',
@@ -288,6 +290,7 @@ class FieldMetadata(dict):
                            'is_custom':False,
                            'is_category':False}),
         ]
+    # }}}
 
     # search labels that are not db columns
     search_items = [    'all',

src/calibre/utils/filenames.py

@@ -54,10 +54,8 @@ def shorten_components_to(length, components):
             r = x[0] if x is components[-1] else ''
         else:
             if x is components[-1]:
-                b, _, e = x.rpartition('.')
+                b, e = os.path.splitext(x)
-                if not b and e:
+                if e == '.': e = ''
-                    b = e
-                    e = ''
                 r = b[:-delta]+e
                 if r.startswith('.'): r = x[0]+r
             else: