From 129676d9ba2aa687ea11f5f81f671785758c72f8 Mon Sep 17 00:00:00 2001
From: Hydrus Network Developer <hydrus.admin@gmail.com>
Date: Wed, 4 Dec 2019 23:29:32 -0600
Subject: [PATCH] Version 376

---
 help/changelog.html                           |   46 +
 help/contact.html                             |    4 +-
 help/getting_started_files.html               |    2 +-
 include/ClientCaches.py                       | 1358 +----------------
 include/ClientConstants.py                    |    2 +-
 include/ClientController.py                   |   85 +-
 include/ClientDB.py                           |   32 +
 include/ClientDaemons.py                      |  164 --
 include/ClientDefaults.py                     |    1 -
 include/ClientDragDrop.py                     |  147 +-
 include/ClientExporting.py                    |    6 +
 include/ClientGUI.py                          |   95 +-
 include/ClientGUIACDropdown.py                |    5 +-
 include/ClientGUIAsync.py                     |    7 +-
 include/ClientGUICanvas.py                    |  249 +--
 include/ClientGUICommon.py                    |    1 +
 include/ClientGUIControls.py                  |   51 +-
 include/ClientGUIDialogs.py                   |   69 +-
 include/ClientGUIDialogsManage.py             |   10 +-
 include/ClientGUIDialogsQuick.py              |    8 +-
 include/ClientGUIExport.py                    |    2 +-
 include/ClientGUIFrames.py                    |    8 +-
 include/ClientGUIFunctions.py                 |    4 +-
 include/ClientGUIHoverFrames.py               |   13 +-
 include/ClientGUIListBoxes.py                 |    6 +-
 include/ClientGUIListCtrl.py                  |   26 +-
 include/ClientGUIPages.py                     |   14 +-
 include/ClientGUIPanels.py                    |   52 +-
 include/ClientGUIParsing.py                   |   76 +-
 include/ClientGUIPopupMessages.py             |   35 +-
 include/ClientGUIPredicates.py                |   13 +
 .../ClientGUIScrolledPanelsButtonQuestions.py |    1 +
 include/ClientGUIScrolledPanelsEdit.py        |    4 +-
 include/ClientGUIScrolledPanelsManagement.py  |  110 +-
 include/ClientGUIScrolledPanelsReview.py      |   39 +-
 include/ClientGUIStyle.py                     |   90 ++
 include/ClientGUITags.py                      |   11 +-
 include/ClientGUITopLevelWindows.py           |   60 +-
 include/ClientImportGallery.py                |   10 +-
 include/ClientImportSimpleURLs.py             |    5 +-
 include/ClientImportSubscriptions.py          |  787 ++++++++--
 include/ClientImportWatchers.py               |   15 +-
 include/ClientImporting.py                    |   10 +-
 include/ClientManagers.py                     | 1340 ++++++++++++++++
 include/ClientMedia.py                        |  357 ++---
 include/ClientOptions.py                      |    2 +
 include/ClientParsing.py                      |   38 +-
 include/HydrusConstants.py                    |    2 +-
 include/HydrusGlobals.py                      |    1 -
 include/HydrusPaths.py                        |    2 +-
 include/QtPorting.py                          |  115 +-
 include/TestClientAPI.py                      |    7 +-
 include/TestClientConstants.py                |    5 +-
 include/TestClientMigration.py                |    3 +-
 include/TestClientTags.py                     |    5 +-
 include/TestController.py                     |   11 +-
 static/8chan.png                              |  Bin 264 -> 0 bytes
 static/8kun.png                               |  Bin 0 -> 3464 bytes
 static/default/gugs/pixiv tag search.png      |  Bin 2407 -> 1645 bytes
 .../default/gugs/twitter username lookup.png  |  Bin 2498 -> 1758 bytes
 .../parsers/pixiv tag search api parser.png   |  Bin 0 -> 1929 bytes
 .../twitter media tweets api parser.png       |  Bin 0 -> 2335 bytes
 ... tweet parser (video from koto.reisen).png |  Bin 0 -> 2729 bytes
 .../default/url_classes/pixiv search api.png  |  Bin 0 -> 1664 bytes
 .../twitter tweets api - media only.png       |  Bin 0 -> 1959 bytes
 static/qss/readme.txt                         |    7 +
 66 files changed, 3244 insertions(+), 2384 deletions(-)
 create mode 100644 include/ClientGUIStyle.py
 create mode 100644 include/ClientManagers.py
 delete mode 100644 static/8chan.png
 create mode 100644 static/8kun.png
 create mode 100644 static/default/parsers/pixiv tag search api parser.png
 create mode 100644 static/default/parsers/twitter media tweets api parser.png
 create mode 100644 static/default/parsers/twitter tweet parser (video from koto.reisen).png
 create mode 100644 static/default/url_classes/pixiv search api.png
 create mode 100644 static/default/url_classes/twitter tweets api - media only.png
 create mode 100644 static/qss/readme.txt

diff --git a/help/changelog.html b/help/changelog.html
index 6a401bbd..39bd8a56 100755
--- a/help/changelog.html
+++ b/help/changelog.html
@@ -8,6 +8,52 @@
 		<div class="content">
 			<h3>changelog</h3>
 			<ul>
+				<li><h3>version 376</h3></li>
+				<ul>
+					<li>subscriptions:</li>
+					<li>wrote a new subscription manager to better look after subscription scheduling</li>
+					<li>rather than checking every four hours or after manage subs dialog close, subscriptions now record an indication of when they are next due for work, whether that is the estimated next check time or when bandwidth is free on remaining file downloads, and launch in a fifteen-minute window around that time. delays due to previous errors or user cancels are also taken into account. this reduces background cpu and i/o greatly for clients with large subs</li>
+					<li>if a sub is paused, or all its queries are paused, it will now never be reloaded after first load until a change via the manage subs dialog</li>
+					<li>furthermore, if a single sub takes a very long time to work, the whole sublist can re-cycle if they come up due for more work before it is finished</li>
+					<li>if a sub query is DEAD but still has outstanding files to download, it will no longer automatically pause</li>
+					<li>subs now clean up more tidily if they are running on a program exit</li>
+					<li>the subscription popup now shows check/file progress based on the number of queries that appear to have pending work. instead of 'query 300/450' with 420 that aren't due, you'll get 'query 12/30'. if a query becomes due during a round of checking, another round of checking will run</li>
+					<li>if a subscription fails to load from the db, the error is handled better and no more subs will run in that boot</li>
+					<li>improved subscription startup checking logic, tightening up various paused/dead/cansync tests</li>
+					<li>improved subscription interrupt checking logic, tightening checks on global network pause and various shutdown scenarios</li>
+					<li>cleaned up some more subscription code in prep for data storage breakup</li>
+					<li>.</li>
+					<li>qt:</li>
+					<li>added experimental Qt style settings to the new options->style page! all users should now be able to set Fusion style, and perhaps some alternate OS styles. advanced users are invited to play around with QSS stylesheets (although be warned that some of hydrus's custom colour system overrides QSS, so more work is needed here), which will be extended and made user-friendly in coming weeks</li>
+					<li>fixed tab position calculations for all tab/media drag and drops for tab bars that are centered or otherwise positioned far off top-left alignment</li>
+					<li>fixed tab drag and drop event object handling for macOS. tab and media DnD is now enabled for macOS</li>
+					<li>the popup toaster can now unhide if an on-top-of-parent non-modal frame (like review services) is focused (so hitting 'process now' should show you the work)</li>
+					<li>fixed a variety of old hacky wx close-window veto tests. the 'close client?' confirmation dialog will now reliably veto a close requent on 'no'/cancel, dialog close events that are vetoed (such as closing the manage tags dialog with pending tags) will now veto more than just the first time, and several bad media viewer archive/dupe filtering cancel and end-of-window events should now work more cleanly and correctly. users who had crashes at the end of filtering may find they are stable again</li>
+					<li>as a quick patch against some multiline notes and statuses, list controls now force single-line text in all cells</li>
+					<li>list controls now tooltip all cells</li>
+					<li>fixed the shutdown splash not updating after the daemons shut down (lmao)</li>
+					<li>'modal' message dialogs, which are created by blocking maintenance tasks such as vacuum, will no longer raise the program to the foreground on creation</li>
+					<li>should have fixed the taglist vertical positioning jank that could occur in the row after a tag with a tall emoji unicode character (and also sometimes kanji/hangul)</li>
+					<li>fixed a typo bug that was throwing an error for the upnp port widget in the local client server management panel when 'allow non local connections' was checked</li>
+					<li>improved stability of bandwidth review panel bandwidth rules refresh</li>
+					<li>improved stability of review services bandwidth rules refresh</li>
+					<li>improved some dialog cleanup code</li>
+					<li>reverted a bad environment-setting change put in last week that was causing some running-from-source users trouble</li>
+					<li>misc qt code cleanup</li>
+					<li>.</li>
+					<li>the rest:</li>
+					<li>updated the default pixiv tag search downloader to one submitted by a user. it now uses their api</li>
+					<li>updated the default twitter username lookup to a downloader submitted by a user. it fetches just the media tweet feed, making it more efficient. also added (but not linked by default) is a new tweet parser that can fetch most videos using a third-party site, advanced users may wish to play with this</li>
+					<li>added a &#123;file_id&#125; term for file export phrases that substitutes a unique and permanent numerical file identifier</li>
+					<li>fixed an issue where idle maintenance jobs could sometimes sneak in a few milliseconds of work during certain long shut down pauses, such as while waiting for a 'should I do shutdown work?' dialog to return. program shutdown should be snappier for many users as forced startup delays in these calls will no longer trigger</li>
+					<li>added a date 'encode' string transformation rule, which takes an integer timestamp and converts it to a pretty date string. the date rules are now renamed to the clearer 'datestring to timestamp' and vice versa</li>
+					<li>fixed page parser edit panel's 'test parse' when string transformations perform pre-parsing conversion. the handling and passing of test data for all the panels here is cleaned up throughout</li>
+					<li>system:limit predicate edit panel now has a small label describing its sampling behaviour</li>
+					<li>updated the various 8chan links in the client and help to 8kun, let me know if I missed any, and added Endchan bunker link to help menu</li>
+					<li>improved some misc status text handling across the program</li>
+					<li>refactored cache and manager code into different, simpler files</li>
+					<li>updated sqlite on windows build to 3.30.1</li>
+				</ul>
 				<li><h3>version 375</h3></li>
 				<ul>
 					<li>qt:</li>
diff --git a/help/contact.html b/help/contact.html
index ab4652ca..f2fafbd8 100755
--- a/help/contact.html
+++ b/help/contact.html
@@ -8,14 +8,14 @@
 		<div class="content">
 			<h3>contact and links</h3>
 			<p>Please send me all your bug reports, questions, ideas, and comments. It is always interesting to see how other people are using my software and what they generally think of it. Most of the changes every week are suggested by users.</p>
-			<p>You can contact me by email, twitter, tumblr, discord, or the 8chan board--I do not mind which. I'm not active on github (I use it mostly as a mirror of my home dev environment) and do not check its messages or issues. I often like to spend a day or so to think before replying to non-urgent messages, but I do try to reply to everything.</p>
+			<p>You can contact me by email, twitter, tumblr, discord, or the 8kun/Endchan boards--I do not mind which. I'm not active on github (I use it mostly as a mirror of my home dev environment) and do not check its messages or issues. I often like to spend a day or so to think before replying to non-urgent messages, but I do try to reply to everything.</p>
 			<p>I am on the discord on Saturday afternoon, USA time, and Wednesday after I put the release out. If that is not a good time for you, feel free to leave me a DM and I will get to you when I can. There are also plenty of other hydrus users who idle who would be happy to help with any sort of support question.</p>
 			<p>I delete all tweets and resolved email conversations after three months. So, if you think you are waiting for a reply, or I said I was going to work on something you care about and seem to have forgotten, please do nudge me.</p>
 			<p>If you have a problem with something on someone else's server, please, <span class="warning">do not come to me</span>, as I cannot help. If your ex-gf's nudes have leaked onto the internet or you just find something terribly offensive, I cannot help you at all.</p>
 			<p>Anyway:</p>
 			<ul>
 				<li><a href="https://hydrusnetwork.github.io/hydrus/">homepage</a></li>
-				<li><a href="https://8ch.net/hydrus/index.html">8chan board</a> (<a href="https://endchan.net/hydrus/">endchan bunker</a>)</li>
+				<li><a href="https://8kun.top/hydrus/index.html">8kun board</a> (<a href="https://endchan.net/hydrus/">endchan bunker</a>)</li>
 				<li><a href="http://hydrus.tumblr.com">tumblr</a> (<a href="http://hydrus.tumblr.com/rss">rss</a>)</li>
 				<li><a href="https://github.com/hydrusnetwork/hydrus/releases">new downloads</a></li>
 				<li><a href="https://www.mediafire.com/hydrus">old downloads</a></li>
diff --git a/help/getting_started_files.html b/help/getting_started_files.html
index 41aeb61e..6f2a6ec2 100755
--- a/help/getting_started_files.html
+++ b/help/getting_started_files.html
@@ -76,7 +76,7 @@
 				<li><b>application/x-7z-compressed</b> (.7z)</li>
 			</ul>
 			<p>Although some support is imperfect for the complicated filetypes. Most videos will not play audio yet, some animated gifs with unusual transparency will render like static, and flash cannot embed into Linux or macOS. When something does not render how you want, right-clicking on its thumbnail presents the option 'open externally', which will open the file in the appropriate default program (e.g. ACDSee, VLC).</p>
-			<p>The client can also download files from several websites, including 4chan and 8chan, many boorus, and gallery sites like deviant art and hentai foundry. You will learn more about this later.</p>
+			<p>The client can also download files from several websites, including 4chan and other imageboards, many boorus, and gallery sites like deviant art and hentai foundry. You will learn more about this later.</p>
 			<h3>inbox and archiving</h3>
 			<p>The client sends newly imported files to an <b>inbox</b>, just like your email. Inbox acts like a tag, matched by 'system:inbox'. A small envelope icon is drawn in the top corner of all inbox files:</p>
 			<p><img src="fresh_imports.png" /></p>
diff --git a/include/ClientCaches.py b/include/ClientCaches.py
index 7b68cbbf..5c8931c5 100644
--- a/include/ClientCaches.py
+++ b/include/ClientCaches.py
@@ -1,349 +1,22 @@
 from . import ClientFiles
 from . import ClientImageHandling
 from . import ClientParsing
-from . import ClientPaths
 from . import ClientRendering
-from . import ClientSearch
-from . import ClientServices
-from . import ClientThreading
 from . import HydrusConstants as HC
 from . import HydrusExceptions
-from . import HydrusFileHandling
 from . import HydrusImageHandling
-from . import HydrusPaths
-from . import HydrusSerialisable
 from . import HydrusThreading
 import json
 import os
-import random
 import threading
 import time
 from . import HydrusData
-from . import ClientData
 from . import ClientConstants as CC
 from . import HydrusGlobals as HG
 import collections
-from . import HydrusTags
 import traceback
 import weakref
-from qtpy import QtCore as QC
-from qtpy import QtWidgets as QW
-from qtpy import QtGui as QG
-from . import QtPorting as QP
 
-# now let's fill out grandparents
-def BuildServiceKeysToChildrenToParents( service_keys_to_simple_children_to_parents ):
-    
-    # important thing here, and reason why it is recursive, is because we want to preserve the parent-grandparent interleaving in list order
-    def AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, parents ):
-        
-        for parent in parents:
-            
-            if parent not in this_childs_parents:
-                
-                this_childs_parents.append( parent )
-                
-            
-            # this parent has its own parents, so the child should get those as well
-            if parent in simple_children_to_parents:
-                
-                grandparents = simple_children_to_parents[ parent ]
-                
-                AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, grandparents )
-                
-            
-        
-    
-    service_keys_to_children_to_parents = collections.defaultdict( HydrusData.default_dict_list )
-    
-    for ( service_key, simple_children_to_parents ) in service_keys_to_simple_children_to_parents.items():
-        
-        children_to_parents = service_keys_to_children_to_parents[ service_key ]
-        
-        for ( child, parents ) in list( simple_children_to_parents.items() ):
-            
-            this_childs_parents = children_to_parents[ child ]
-            
-            AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, parents )
-            
-        
-    
-    return service_keys_to_children_to_parents
-    
-def BuildServiceKeysToSimpleChildrenToParents( service_keys_to_pairs_flat ):
-    
-    service_keys_to_simple_children_to_parents = collections.defaultdict( HydrusData.default_dict_set )
-    
-    for ( service_key, pairs ) in service_keys_to_pairs_flat.items():
-        
-        service_keys_to_simple_children_to_parents[ service_key ] = BuildSimpleChildrenToParents( pairs )
-        
-    
-    return service_keys_to_simple_children_to_parents
-    
-# take pairs, make dict of child -> parents while excluding loops
-# no grandparents here
-def BuildSimpleChildrenToParents( pairs ):
-    
-    simple_children_to_parents = HydrusData.default_dict_set()
-    
-    for ( child, parent ) in pairs:
-        
-        if child == parent:
-            
-            continue
-            
-        
-        if parent in simple_children_to_parents and LoopInSimpleChildrenToParents( simple_children_to_parents, child, parent ):
-            
-            continue
-            
-        
-        simple_children_to_parents[ child ].add( parent )
-        
-    
-    return simple_children_to_parents
-    
-def CollapseTagSiblingPairs( groups_of_pairs ):
-    
-    # This now takes 'groups' of pairs in descending order of precedence
-    
-    # This allows us to mandate that local tags take precedence
-    
-    # a pair is invalid if:
-    # it causes a loop (a->b, b->c, c->a)
-    # there is already a relationship for the 'bad' sibling (a->b, a->c)
-    
-    valid_chains = {}
-    
-    for pairs in groups_of_pairs:
-        
-        pairs = list( pairs )
-        
-        pairs.sort()
-        
-        for ( bad, good ) in pairs:
-            
-            if bad == good:
-                
-                # a->a is a loop!
-                
-                continue
-                
-            
-            if bad not in valid_chains:
-                
-                we_have_a_loop = False
-                
-                current_best = good
-                
-                while current_best in valid_chains:
-                    
-                    current_best = valid_chains[ current_best ]
-                    
-                    if current_best == bad:
-                        
-                        we_have_a_loop = True
-                        
-                        break
-                        
-                    
-                
-                if not we_have_a_loop:
-                    
-                    valid_chains[ bad ] = good
-                    
-                
-            
-        
-    
-    # now we collapse the chains, turning:
-    # a->b, b->c ... e->f
-    # into
-    # a->f, b->f ... e->f
-    
-    siblings = {}
-    
-    for ( bad, good ) in list( valid_chains.items() ):
-        
-        # given a->b, want to find f
-        
-        if good in siblings:
-            
-            # f already calculated and added
-            
-            best = siblings[ good ]
-            
-        else:
-            
-            # we don't know f for this chain, so let's figure it out
-            
-            current_best = good
-            
-            while current_best in valid_chains:
-                
-                current_best = valid_chains[ current_best ] # pursue endpoint f
-                
-            
-            best = current_best
-            
-        
-        # add a->f
-        siblings[ bad ] = best
-        
-    
-    return siblings
-    
-def DeLoopTagSiblingPairs( groups_of_pairs ):
-    
-    pass
-    
-def LoopInSimpleChildrenToParents( simple_children_to_parents, child, parent ):
-    
-    potential_loop_paths = { parent }
-    
-    while True:
-        
-        new_potential_loop_paths = set()
-        
-        for potential_loop_path in potential_loop_paths:
-            
-            if potential_loop_path in simple_children_to_parents:
-                
-                new_potential_loop_paths.update( simple_children_to_parents[ potential_loop_path ] )
-                
-            
-        
-        potential_loop_paths = new_potential_loop_paths
-        
-        if child in potential_loop_paths:
-            
-            return True
-            
-        elif len( potential_loop_paths ) == 0:
-            
-            return False
-            
-        
-    
-class BitmapManager( object ):
-    
-    MAX_MEMORY_ALLOWANCE = 512 * 1024 * 1024
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._media_background_pixmap_path = None
-        self._media_background_pixmap = None
-        
-    
-    def _GetQtImageFormat( self, depth ):
-        
-        if depth == 24:
-            
-            return QG.QImage.Format_RGB888
-            
-        elif depth == 32:
-
-            return QG.QImage.Format_RGBA8888
-            
-        
-    
-    def GetQtImage( self, width, height, depth = 24 ):
-        
-        if width < 0:
-            
-            width = 20
-            
-        
-        if height < 0:
-            
-            height = 20
-            
-        
-        qt_image_format = self._GetQtImageFormat( depth )
-        
-        return QG.QImage( width, height, qt_image_format )
-        
-    
-    def GetQtPixmap( self, width, height ):
-        
-        if width < 0:
-            
-            width = 20
-            
-        
-        if height < 0:
-            
-            height = 20
-            
-        
-        key = ( width, height )
-        
-        return QG.QPixmap( width, height )
-        
-    
-    def GetQtImageFromBuffer( self, width, height, depth, data ):
-        
-        qt_image_format = self._GetQtImageFormat( depth )
-        
-        bytes_per_line = ( depth / 8 ) * width
-        
-        # no copy here
-        qt_image = QG.QImage( data, width, height, bytes_per_line, qt_image_format )
-        
-        # cheeky solution here
-        # the QImage init does not take python ownership of the data, so if it gets garbage collected, we crash
-        # so, add a beardy python ref to it, no problem :^)
-        # other anwser here is to do a .copy, but this can be a _little_ expensive and eats memory
-        qt_image.python_data_reference = data
-        
-        return qt_image
-        
-    
-    def GetQtPixmapFromBuffer( self, width, height, depth, data ):
-        
-        qt_image_format = self._GetQtImageFormat( depth )
-        
-        bytes_per_line = ( depth / 8 ) * width
-        
-        # no copy, no new data allocated
-        qt_image = QG.QImage( data, width, height, bytes_per_line, qt_image_format )
-        
-        # _should_ be a safe copy of the hot data
-        pixmap = QG.QPixmap.fromImage( qt_image )
-        
-        return pixmap
-        
-    
-    def GetMediaBackgroundPixmap( self ):
-        
-        pixmap_path = self._controller.new_options.GetNoneableString( 'media_background_bmp_path' )
-        
-        if pixmap_path != self._media_background_pixmap_path:
-            
-            self._media_background_pixmap_path = pixmap_path
-            
-            try:
-                
-                self._media_background_pixmap = QG.QPixmap( self._media_background_pixmap_path )
-                
-            except Exception as e:
-                
-                self._media_background_pixmap = None
-                
-                HydrusData.ShowText( 'Loading a bmp caused an error!' )
-                
-                HydrusData.ShowException( e )
-                
-                return None
-                
-            
-        
-        return self._media_background_pixmap
-        
-    
 class DataCache( object ):
     
     def __init__( self, controller, cache_size, timeout = 1200 ):
@@ -505,150 +178,6 @@ class DataCache( object ):
             
         
     
-class FileViewingStatsManager( object ):
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._lock = threading.Lock()
-        
-        self._pending_updates = {}
-        
-        self._last_update = HydrusData.GetNow()
-        
-        self._my_flush_job = self._controller.CallRepeating( 5, 60, self.REPEATINGFlush )
-        
-    
-    def _GenerateViewsRow( self, viewtype, viewtime_delta ):
-        
-        new_options = HG.client_controller.new_options
-        
-        preview_views_delta = 0
-        preview_viewtime_delta = 0
-        media_views_delta = 0
-        media_viewtime_delta = 0
-        
-        if viewtype == 'preview':
-            
-            preview_min = new_options.GetNoneableInteger( 'file_viewing_statistics_preview_min_time' )
-            preview_max = new_options.GetNoneableInteger( 'file_viewing_statistics_preview_max_time' )
-            
-            if preview_max is not None:
-                
-                viewtime_delta = min( viewtime_delta, preview_max )
-                
-            
-            if preview_min is None or viewtime_delta >= preview_min:
-                
-                preview_views_delta = 1
-                preview_viewtime_delta = viewtime_delta
-                
-            
-        elif viewtype in ( 'media', 'media_duplicates_filter' ):
-            
-            do_it = True
-            
-            if viewtime_delta == 'media_duplicates_filter' and not new_options.GetBoolean( 'file_viewing_statistics_active_on_dupe_filter' ):
-                
-                do_it = False
-                
-            
-            if do_it:
-                
-                media_min = new_options.GetNoneableInteger( 'file_viewing_statistics_media_min_time' )
-                media_max = new_options.GetNoneableInteger( 'file_viewing_statistics_media_max_time' )
-                
-                if media_max is not None:
-                    
-                    viewtime_delta = min( viewtime_delta, media_max )
-                    
-                
-                if media_min is None or viewtime_delta >= media_min:
-                    
-                    media_views_delta = 1
-                    media_viewtime_delta = viewtime_delta
-                    
-                
-            
-        
-        return ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
-        
-    
-    def _PubSubRow( self, hash, row ):
-        
-        ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) = row
-        
-        pubsub_row = ( hash, preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
-        
-        content_update = HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILE_VIEWING_STATS, HC.CONTENT_UPDATE_ADD, pubsub_row )
-        
-        service_keys_to_content_updates = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ content_update ] }
-        
-        HG.client_controller.pub( 'content_updates_data', service_keys_to_content_updates )
-        HG.client_controller.pub( 'content_updates_gui', service_keys_to_content_updates )
-        
-    
-    def REPEATINGFlush( self ):
-        
-        self.Flush()
-        
-    
-    def Flush( self ):
-        
-        with self._lock:
-            
-            if len( self._pending_updates ) > 0:
-                
-                content_updates = []
-                
-                for ( hash, ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) ) in self._pending_updates.items():
-                    
-                    row = ( hash, preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
-                    
-                    content_update = HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILE_VIEWING_STATS, HC.CONTENT_UPDATE_ADD, row )
-                    
-                    content_updates.append( content_update )
-                    
-                
-                service_keys_to_content_updates = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : content_updates }
-                
-                # non-synchronous
-                self._controller.Write( 'content_updates', service_keys_to_content_updates, do_pubsubs = False )
-                
-                self._pending_updates = {}
-                
-            
-        
-    
-    def FinishViewing( self, viewtype, hash, viewtime_delta ):
-        
-        if not HG.client_controller.new_options.GetBoolean( 'file_viewing_statistics_active' ):
-            
-            return
-            
-        
-        with self._lock:
-            
-            row = self._GenerateViewsRow( viewtype, viewtime_delta )
-            
-            if hash not in self._pending_updates:
-                
-                self._pending_updates[ hash ] = row
-                
-            else:
-                
-                ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) = row
-                
-                ( existing_preview_views_delta, existing_preview_viewtime_delta, existing_media_views_delta, existing_media_viewtime_delta ) = self._pending_updates[ hash ]
-                
-                self._pending_updates[ hash ] = ( existing_preview_views_delta + preview_views_delta, existing_preview_viewtime_delta + preview_viewtime_delta, existing_media_views_delta + media_views_delta, existing_media_viewtime_delta + media_viewtime_delta )
-                
-            
-        
-        self._PubSubRow( hash, row )
-        
-
 class LocalBooruCache( object ):
     
     def __init__( self, controller ):
@@ -1124,668 +653,6 @@ class RenderedImageCache( object ):
         return self._data_cache.HasData( key )
         
     
-class ServicesManager( object ):
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._lock = threading.Lock()
-        self._keys_to_services = {}
-        self._services_sorted = []
-        
-        self.RefreshServices()
-        
-        self._controller.sub( self, 'RefreshServices', 'notify_new_services_data' )
-        
-    
-    def _GetService( self, service_key ):
-        
-        try:
-            
-            return self._keys_to_services[ service_key ]
-            
-        except KeyError:
-            
-            raise HydrusExceptions.DataMissing( 'That service was not found!' )
-            
-        
-    
-    def _SetServices( self, services ):
-        
-        self._keys_to_services = { service.GetServiceKey() : service for service in services }
-        
-        self._keys_to_services[ CC.TEST_SERVICE_KEY ] = ClientServices.GenerateService( CC.TEST_SERVICE_KEY, HC.TEST_SERVICE, 'test service' )
-        
-        key = lambda s: s.GetName()
-        
-        self._services_sorted = list( services )
-        self._services_sorted.sort( key = key )
-        
-    
-    def Filter( self, service_keys, desired_types ):
-        
-        with self._lock:
-            
-            def func( service_key ):
-                
-                return self._keys_to_services[ service_key ].GetServiceType() in desired_types
-                
-            
-            filtered_service_keys = list(filter( func, service_keys ))
-            
-            return filtered_service_keys
-            
-        
-    
-    def FilterValidServiceKeys( self, service_keys ):
-        
-        with self._lock:
-            
-            def func( service_key ):
-                
-                return service_key in self._keys_to_services
-                
-            
-            filtered_service_keys = list(filter( func, service_keys ))
-            
-            return filtered_service_keys
-            
-        
-    
-    def GetName( self, service_key ):
-        
-        with self._lock:
-            
-            service = self._GetService( service_key )
-            
-            return service.GetName()
-            
-        
-    
-    def GetService( self, service_key ):
-        
-        with self._lock:
-            
-            return self._GetService( service_key )
-            
-        
-    
-    def GetServiceType( self, service_key ):
-        
-        with self._lock:
-            
-            return self._GetService( service_key ).GetServiceType()
-            
-        
-    
-    def GetServiceKeyFromName( self, allowed_types, service_name ):
-        
-        with self._lock:
-            
-            for service in self._services_sorted:
-                
-                if service.GetServiceType() in allowed_types and service.GetName() == service_name:
-                    
-                    return service.GetServiceKey()
-                    
-                
-            
-            raise HydrusExceptions.DataMissing()
-            
-        
-    
-    def GetServiceKeys( self, desired_types = HC.ALL_SERVICES ):
-        
-        with self._lock:
-            
-            filtered_service_keys = [ service_key for ( service_key, service ) in self._keys_to_services.items() if service.GetServiceType() in desired_types ]
-            
-            return filtered_service_keys
-            
-        
-    
-    def GetServices( self, desired_types = HC.ALL_SERVICES, randomised = True ):
-        
-        with self._lock:
-            
-            def func( service ):
-                
-                return service.GetServiceType() in desired_types
-                
-            
-            services = list(filter( func, self._services_sorted ))
-            
-            if randomised:
-                
-                random.shuffle( services )
-                
-            
-            return services
-            
-        
-    
-    def RefreshServices( self ):
-        
-        with self._lock:
-            
-            services = self._controller.Read( 'services' )
-            
-            self._SetServices( services )
-            
-        
-    
-    def ServiceExists( self, service_key ):
-        
-        with self._lock:
-            
-            return service_key in self._keys_to_services
-            
-        
-    
-class TagParentsManager( object ):
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._dirty = False
-        self._refresh_job = None
-        
-        self._service_keys_to_children_to_parents = collections.defaultdict( HydrusData.default_dict_list )
-        
-        self._RefreshParents()
-        
-        self._lock = threading.Lock()
-        
-        self._controller.sub( self, 'NotifyNewParents', 'notify_new_parents' )
-        
-    
-    def _RefreshParents( self ):
-        
-        service_keys_to_statuses_to_pairs = self._controller.Read( 'tag_parents' )
-        
-        # first collapse siblings
-        
-        siblings_manager = self._controller.tag_siblings_manager
-        
-        collapsed_service_keys_to_statuses_to_pairs = collections.defaultdict( HydrusData.default_dict_set )
-        
-        for ( service_key, statuses_to_pairs ) in service_keys_to_statuses_to_pairs.items():
-            
-            if service_key == CC.COMBINED_TAG_SERVICE_KEY:
-                
-                continue
-                
-            
-            for ( status, pairs ) in statuses_to_pairs.items():
-                
-                pairs = siblings_manager.CollapsePairs( service_key, pairs )
-                
-                collapsed_service_keys_to_statuses_to_pairs[ service_key ][ status ] = pairs
-                
-            
-        
-        # now collapse current and pending
-        
-        service_keys_to_pairs_flat = HydrusData.default_dict_set()
-        
-        for ( service_key, statuses_to_pairs ) in collapsed_service_keys_to_statuses_to_pairs.items():
-            
-            pairs_flat = statuses_to_pairs[ HC.CONTENT_STATUS_CURRENT ].union( statuses_to_pairs[ HC.CONTENT_STATUS_PENDING ] )
-            
-            service_keys_to_pairs_flat[ service_key ] = pairs_flat
-            
-        
-        # now create the combined tag service
-        
-        combined_pairs_flat = set()
-        
-        for pairs_flat in service_keys_to_pairs_flat.values():
-            
-            combined_pairs_flat.update( pairs_flat )
-            
-        
-        service_keys_to_pairs_flat[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_pairs_flat
-        
-        #
-        
-        service_keys_to_simple_children_to_parents = BuildServiceKeysToSimpleChildrenToParents( service_keys_to_pairs_flat )
-        
-        self._service_keys_to_children_to_parents = BuildServiceKeysToChildrenToParents( service_keys_to_simple_children_to_parents )
-        
-    
-    def ExpandPredicates( self, service_key, predicates, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        results = []
-        
-        with self._lock:
-            
-            for predicate in predicates:
-                
-                results.append( predicate )
-                
-                if predicate.GetType() == HC.PREDICATE_TYPE_TAG:
-                    
-                    tag = predicate.GetValue()
-                    
-                    parents = self._service_keys_to_children_to_parents[ service_key ][ tag ]
-                    
-                    for parent in parents:
-                        
-                        parent_predicate = ClientSearch.Predicate( HC.PREDICATE_TYPE_PARENT, parent )
-                        
-                        results.append( parent_predicate )
-                        
-                    
-                
-            
-            return results
-            
-        
-    
-    def ExpandTags( self, service_key, tags, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            tags_results = set( tags )
-            
-            for tag in tags:
-                
-                tags_results.update( self._service_keys_to_children_to_parents[ service_key ][ tag ] )
-                
-            
-            return tags_results
-            
-        
-    
-    def GetParents( self, service_key, tag, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            return self._service_keys_to_children_to_parents[ service_key ][ tag ]
-            
-        
-    
-    def NotifyNewParents( self ):
-        
-        with self._lock:
-            
-            self._dirty = True
-            
-            if self._refresh_job is not None:
-                
-                self._refresh_job.Cancel()
-                
-            
-            self._refresh_job = self._controller.CallLater( 8.0, self.RefreshParentsIfDirty )
-            
-        
-    
-    def RefreshParentsIfDirty( self ):
-        
-        with self._lock:
-            
-            if self._dirty:
-                
-                self._RefreshParents()
-                
-                self._dirty = False
-                
-            
-        
-    
-class TagSiblingsManager( object ):
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._dirty = False
-        self._refresh_job = None
-        
-        self._service_keys_to_siblings = collections.defaultdict( dict )
-        self._service_keys_to_reverse_lookup = collections.defaultdict( dict )
-        
-        self._RefreshSiblings()
-        
-        self._lock = threading.Lock()
-        
-        self._controller.sub( self, 'NotifyNewSiblings', 'notify_new_siblings_data' )
-        
-    
-    def _CollapseTags( self, service_key, tags ):
-    
-        siblings = self._service_keys_to_siblings[ service_key ]
-        
-        return { siblings[ tag ] if tag in siblings else tag for tag in tags }
-        
-    
-    def _RefreshSiblings( self ):
-        
-        self._service_keys_to_siblings = collections.defaultdict( dict )
-        self._service_keys_to_reverse_lookup = collections.defaultdict( dict )
-        
-        local_tags_pairs = set()
-        
-        tag_repo_pairs = set()
-        
-        service_keys_to_statuses_to_pairs = self._controller.Read( 'tag_siblings' )
-        
-        for ( service_key, statuses_to_pairs ) in service_keys_to_statuses_to_pairs.items():
-            
-            all_pairs = statuses_to_pairs[ HC.CONTENT_STATUS_CURRENT ].union( statuses_to_pairs[ HC.CONTENT_STATUS_PENDING ] )
-            
-            service = self._controller.services_manager.GetService( service_key )
-            
-            if service.GetServiceType() == HC.LOCAL_TAG:
-                
-                local_tags_pairs = set( all_pairs )
-                
-            else:
-                
-                tag_repo_pairs.update( all_pairs )
-                
-            
-            siblings = CollapseTagSiblingPairs( [ all_pairs ] )
-            
-            self._service_keys_to_siblings[ service_key ] = siblings
-            
-            reverse_lookup = collections.defaultdict( list )
-            
-            for ( bad, good ) in siblings.items():
-                
-                reverse_lookup[ good ].append( bad )
-                
-            
-            self._service_keys_to_reverse_lookup[ service_key ] = reverse_lookup
-            
-        
-        combined_siblings = CollapseTagSiblingPairs( [ local_tags_pairs, tag_repo_pairs ] )
-        
-        self._service_keys_to_siblings[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_siblings
-        
-        combined_reverse_lookup = collections.defaultdict( list )
-        
-        for ( bad, good ) in combined_siblings.items():
-            
-            combined_reverse_lookup[ good ].append( bad )
-            
-        
-        self._service_keys_to_reverse_lookup[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_reverse_lookup
-        
-    
-    def CollapsePredicates( self, service_key, predicates, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            
-            results = [ predicate for predicate in predicates if predicate.GetType() != HC.PREDICATE_TYPE_TAG ]
-            
-            tag_predicates = [ predicate for predicate in predicates if predicate.GetType() == HC.PREDICATE_TYPE_TAG ]
-            
-            tags_to_predicates = {predicate.GetValue() : predicate for predicate in predicates if predicate.GetType() == HC.PREDICATE_TYPE_TAG}
-            
-            tags = list( tags_to_predicates.keys() )
-            
-            tags_to_include_in_results = set()
-            
-            for tag in tags:
-                
-                if tag in siblings:
-                    
-                    old_tag = tag
-                    old_predicate = tags_to_predicates[ old_tag ]
-                    
-                    new_tag = siblings[ old_tag ]
-                    
-                    if new_tag not in tags_to_predicates:
-                        
-                        ( old_pred_type, old_value, old_inclusive ) = old_predicate.GetInfo()
-                        
-                        new_predicate = ClientSearch.Predicate( old_pred_type, new_tag, old_inclusive )
-                        
-                        tags_to_predicates[ new_tag ] = new_predicate
-                        
-                        tags_to_include_in_results.add( new_tag )
-                        
-                    
-                    new_predicate = tags_to_predicates[ new_tag ]
-                    
-                    new_predicate.AddCounts( old_predicate )
-                    
-                else:
-                    
-                    tags_to_include_in_results.add( tag )
-                    
-                
-            
-            results.extend( [ tags_to_predicates[ tag ] for tag in tags_to_include_in_results ] )
-            
-            return results
-            
-        
-    
-    def CollapsePairs( self, service_key, pairs, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            
-            result = set()
-            
-            for ( a, b ) in pairs:
-                
-                if a in siblings:
-                    
-                    a = siblings[ a ]
-                    
-                
-                if b in siblings:
-                    
-                    b = siblings[ b ]
-                    
-                
-                result.add( ( a, b ) )
-                
-            
-            return result
-            
-        
-    
-    def CollapseStatusesToTags( self, service_key, statuses_to_tags, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            new_statuses_to_tags = HydrusData.default_dict_set()
-            
-            for ( status, tags ) in statuses_to_tags.items():
-                
-                new_statuses_to_tags[ status ] = self._CollapseTags( service_key, tags )
-                
-            
-            return new_statuses_to_tags
-            
-        
-    
-    def CollapseTag( self, service_key, tag, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            
-            if tag in siblings:
-                
-                return siblings[ tag ]
-                
-            else:
-                
-                return tag
-                
-            
-        
-    
-    def CollapseTags( self, service_key, tags, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            return self._CollapseTags( service_key, tags )
-            
-        
-    
-    def CollapseTagsToCount( self, service_key, tags_to_count, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            
-            results = collections.Counter()
-            
-            for ( tag, count ) in tags_to_count.items():
-                
-                if tag in siblings:
-                    
-                    tag = siblings[ tag ]
-                    
-                
-                results[ tag ] += count
-                
-            
-            return results
-            
-        
-    
-    def GetSibling( self, service_key, tag, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            
-            if tag in siblings:
-                
-                return siblings[ tag ]
-                
-            else:
-                
-                return None
-                
-            
-        
-    
-    def GetAllSiblings( self, service_key, tag, service_strict = False ):
-        
-        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
-            
-            service_key = CC.COMBINED_TAG_SERVICE_KEY
-            
-        
-        with self._lock:
-            
-            siblings = self._service_keys_to_siblings[ service_key ]
-            reverse_lookup = self._service_keys_to_reverse_lookup[ service_key ]
-            
-            if tag in siblings:
-                
-                best_tag = siblings[ tag ]
-                
-            elif tag in reverse_lookup:
-                
-                best_tag = tag
-                
-            else:
-                
-                return [ tag ]
-                
-            
-            all_siblings = list( reverse_lookup[ best_tag ] )
-            
-            all_siblings.append( best_tag )
-            
-            return all_siblings
-            
-        
-    
-    def NotifyNewSiblings( self ):
-        
-        with self._lock:
-            
-            self._dirty = True
-            
-            if self._refresh_job is not None:
-                
-                self._refresh_job.Cancel()
-                
-            
-            self._refresh_job = self._controller.CallLater( 8.0, self.RefreshSiblingsIfDirty )
-            
-        
-    
-    def RefreshSiblingsIfDirty( self ):
-        
-        with self._lock:
-            
-            if self._dirty:
-                
-                self._RefreshSiblings()
-                
-                self._dirty = False
-                
-                self._controller.pub( 'notify_new_tag_display_rules' )
-                
-            
-        
-    
 class ThumbnailCache( object ):
     
     def __init__( self, controller ):
@@ -1819,7 +686,7 @@ class ThumbnailCache( object ):
         
         self.Clear()
         
-        self._controller.CallToThreadLongRunning( self.DAEMONWaterfall )
+        self._controller.CallToThreadLongRunning( self.MainLoop )
         
         self._controller.sub( self, 'Clear', 'reset_thumbnail_cache' )
         self._controller.sub( self, 'ClearThumbnails', 'clear_thumbnails' )
@@ -2307,7 +1174,7 @@ class ThumbnailCache( object ):
         self._waterfall_event.set()
         
     
-    def DAEMONWaterfall( self ):
+    def MainLoop( self ):
         
         last_paused = HydrusData.GetNowPrecise()
         
@@ -2411,224 +1278,3 @@ class ThumbnailCache( object ):
             
         
     
-class UndoManager( object ):
-    
-    def __init__( self, controller ):
-        
-        self._controller = controller
-        
-        self._commands = []
-        self._inverted_commands = []
-        self._current_index = 0
-        
-        self._lock = threading.Lock()
-        
-        self._controller.sub( self, 'Undo', 'undo' )
-        self._controller.sub( self, 'Redo', 'redo' )
-        
-    
-    def _FilterServiceKeysToContentUpdates( self, service_keys_to_content_updates ):
-        
-        filtered_service_keys_to_content_updates = {}
-        
-        for ( service_key, content_updates ) in service_keys_to_content_updates.items():
-            
-            filtered_content_updates = []
-            
-            for content_update in content_updates:
-                
-                ( data_type, action, row ) = content_update.ToTuple()
-                
-                if data_type == HC.CONTENT_TYPE_FILES:
-                    
-                    if action in ( HC.CONTENT_UPDATE_ADD, HC.CONTENT_UPDATE_DELETE, HC.CONTENT_UPDATE_UNDELETE, HC.CONTENT_UPDATE_RESCIND_PETITION, HC.CONTENT_UPDATE_ADVANCED ):
-                        
-                        continue
-                        
-                    
-                elif data_type == HC.CONTENT_TYPE_MAPPINGS:
-                    
-                    if action in ( HC.CONTENT_UPDATE_RESCIND_PETITION, HC.CONTENT_UPDATE_ADVANCED ):
-                        
-                        continue
-                        
-                    
-                else:
-                    
-                    continue
-                    
-                
-                filtered_content_update = HydrusData.ContentUpdate( data_type, action, row )
-                
-                filtered_content_updates.append( filtered_content_update )
-                
-            
-            if len( filtered_content_updates ) > 0:
-                
-                filtered_service_keys_to_content_updates[ service_key ] = filtered_content_updates
-                
-            
-        
-        return filtered_service_keys_to_content_updates
-        
-    
-    def _InvertServiceKeysToContentUpdates( self, service_keys_to_content_updates ):
-        
-        inverted_service_keys_to_content_updates = {}
-        
-        for ( service_key, content_updates ) in service_keys_to_content_updates.items():
-            
-            inverted_content_updates = []
-            
-            for content_update in content_updates:
-                
-                ( data_type, action, row ) = content_update.ToTuple()
-                
-                inverted_row = row
-                
-                if data_type == HC.CONTENT_TYPE_FILES:
-                    
-                    if action == HC.CONTENT_UPDATE_ARCHIVE: inverted_action = HC.CONTENT_UPDATE_INBOX
-                    elif action == HC.CONTENT_UPDATE_INBOX: inverted_action = HC.CONTENT_UPDATE_ARCHIVE
-                    elif action == HC.CONTENT_UPDATE_PEND: inverted_action = HC.CONTENT_UPDATE_RESCIND_PEND
-                    elif action == HC.CONTENT_UPDATE_RESCIND_PEND: inverted_action = HC.CONTENT_UPDATE_PEND
-                    elif action == HC.CONTENT_UPDATE_PETITION: inverted_action = HC.CONTENT_UPDATE_RESCIND_PETITION
-                    
-                elif data_type == HC.CONTENT_TYPE_MAPPINGS:
-                    
-                    if action == HC.CONTENT_UPDATE_ADD: inverted_action = HC.CONTENT_UPDATE_DELETE
-                    elif action == HC.CONTENT_UPDATE_DELETE: inverted_action = HC.CONTENT_UPDATE_ADD
-                    elif action == HC.CONTENT_UPDATE_PEND: inverted_action = HC.CONTENT_UPDATE_RESCIND_PEND
-                    elif action == HC.CONTENT_UPDATE_RESCIND_PEND: inverted_action = HC.CONTENT_UPDATE_PEND
-                    elif action == HC.CONTENT_UPDATE_PETITION: inverted_action = HC.CONTENT_UPDATE_RESCIND_PETITION
-                    
-                
-                inverted_content_update = HydrusData.ContentUpdate( data_type, inverted_action, inverted_row )
-                
-                inverted_content_updates.append( inverted_content_update )
-                
-            
-            inverted_service_keys_to_content_updates[ service_key ] = inverted_content_updates
-            
-        
-        return inverted_service_keys_to_content_updates
-        
-    
-    def AddCommand( self, action, *args, **kwargs ):
-        
-        with self._lock:
-            
-            inverted_action = action
-            inverted_args = args
-            inverted_kwargs = kwargs
-            
-            if action == 'content_updates':
-                
-                ( service_keys_to_content_updates, ) = args
-                
-                service_keys_to_content_updates = self._FilterServiceKeysToContentUpdates( service_keys_to_content_updates )
-                
-                if len( service_keys_to_content_updates ) == 0: return
-                
-                inverted_service_keys_to_content_updates = self._InvertServiceKeysToContentUpdates( service_keys_to_content_updates )
-                
-                if len( inverted_service_keys_to_content_updates ) == 0: return
-                
-                inverted_args = ( inverted_service_keys_to_content_updates, )
-                
-            else: return
-            
-            self._commands = self._commands[ : self._current_index ]
-            self._inverted_commands = self._inverted_commands[ : self._current_index ]
-            
-            self._commands.append( ( action, args, kwargs ) )
-            
-            self._inverted_commands.append( ( inverted_action, inverted_args, inverted_kwargs ) )
-            
-            self._current_index += 1
-            
-            self._controller.pub( 'notify_new_undo' )
-            
-        
-    
-    def GetUndoRedoStrings( self ):
-        
-        with self._lock:
-            
-            ( undo_string, redo_string ) = ( None, None )
-            
-            if self._current_index > 0:
-                
-                undo_index = self._current_index - 1
-                
-                ( action, args, kwargs ) = self._commands[ undo_index ]
-                
-                if action == 'content_updates':
-                    
-                    ( service_keys_to_content_updates, ) = args
-                    
-                    undo_string = 'undo ' + ClientData.ConvertServiceKeysToContentUpdatesToPrettyString( service_keys_to_content_updates )
-                    
-                
-            
-            if len( self._commands ) > 0 and self._current_index < len( self._commands ):
-                
-                redo_index = self._current_index
-                
-                ( action, args, kwargs ) = self._commands[ redo_index ]
-                
-                if action == 'content_updates':
-                    
-                    ( service_keys_to_content_updates, ) = args
-                    
-                    redo_string = 'redo ' + ClientData.ConvertServiceKeysToContentUpdatesToPrettyString( service_keys_to_content_updates )
-                    
-                
-            
-            return ( undo_string, redo_string )
-            
-        
-    
-    def Undo( self ):
-        
-        action = None
-        
-        with self._lock:
-            
-            if self._current_index > 0:
-                
-                self._current_index -= 1
-                
-                ( action, args, kwargs ) = self._inverted_commands[ self._current_index ]
-                
-        
-        if action is not None:
-            
-            self._controller.WriteSynchronous( action, *args, **kwargs )
-            
-            self._controller.pub( 'notify_new_undo' )
-            
-        
-    
-    def Redo( self ):
-        
-        action = None
-        
-        with self._lock:
-            
-            if len( self._commands ) > 0 and self._current_index < len( self._commands ):
-                
-                ( action, args, kwargs ) = self._commands[ self._current_index ]
-                
-                self._current_index += 1
-                
-            
-        
-        if action is not None:
-            
-            self._controller.WriteSynchronous( action, *args, **kwargs )
-            
-            self._controller.pub( 'notify_new_undo' )
-            
-        
-    
diff --git a/include/ClientConstants.py b/include/ClientConstants.py
index aaaace3f..233ea29a 100755
--- a/include/ClientConstants.py
+++ b/include/ClientConstants.py
@@ -587,7 +587,7 @@ class GlobalPixmaps( object ):
         GlobalPixmaps.copy = QG.QPixmap( os.path.join(HC.STATIC_DIR,'copy.png') )
         GlobalPixmaps.paste = QG.QPixmap( os.path.join(HC.STATIC_DIR,'paste.png') )
         
-        GlobalPixmaps.eight_chan = QG.QPixmap( os.path.join(HC.STATIC_DIR,'8chan.png') )
+        GlobalPixmaps.eight_kun = QG.QPixmap( os.path.join(HC.STATIC_DIR,'8kun.png') )
         GlobalPixmaps.twitter = QG.QPixmap( os.path.join(HC.STATIC_DIR,'twitter.png') )
         GlobalPixmaps.tumblr = QG.QPixmap( os.path.join(HC.STATIC_DIR,'tumblr.png') )
         GlobalPixmaps.discord = QG.QPixmap( os.path.join(HC.STATIC_DIR,'discord.png') )
diff --git a/include/ClientController.py b/include/ClientController.py
index d35f33e8..9b9f00a0 100755
--- a/include/ClientController.py
+++ b/include/ClientController.py
@@ -14,6 +14,9 @@ from . import ClientDownloading
 from . import ClientFiles
 from . import ClientGUIMenus
 from . import ClientGUIShortcuts
+from . import ClientGUIStyle
+from . import ClientImportSubscriptions
+from . import ClientManagers
 from . import ClientNetworking
 from . import ClientNetworkingBandwidth
 from . import ClientNetworkingDomain
@@ -79,7 +82,7 @@ class App( QW.QApplication ):
         # Since aboutToQuit gets called not only on external shutdown events (like user logging off), but even if we explicitely call QApplication.exit(),
         # this check will make sure that we only do an emergency exit if it's really necessary (i.e. QApplication.exit() wasn't called by us).
         if not QW.QApplication.instance().property( 'normal_exit' ):
-        
+            
             HG.emergency_exit = True
             
             if hasattr( HG.client_controller, 'gui' ):
@@ -195,6 +198,23 @@ class Controller( HydrusController.HydrusController ):
         self.SafeShowCriticalMessage( 'shutdown error', traceback.format_exc() )
         
     
+    def _ShutdownSubscriptionsManager( self ):
+        
+        self.subscriptions_manager.Shutdown()
+        
+        started = HydrusData.GetNow()
+        
+        while not self.subscriptions_manager.IsShutdown():
+            
+            time.sleep( 0.1 )
+            
+            if HydrusData.TimeHasPassed( started + 30 ):
+                
+                break
+                
+            
+        
+    
     def AcquirePageKey( self ):
         
         with self._page_key_lock:
@@ -416,7 +436,7 @@ class Controller( HydrusController.HydrusController ):
         
         if HG.program_is_shutting_down:
             
-            return True
+            return False
             
         
         if HG.force_idle_mode:
@@ -483,7 +503,7 @@ class Controller( HydrusController.HydrusController ):
         
         if HG.program_is_shutting_down:
             
-            return True
+            return False
             
         
         if self._idle_started is not None and HydrusData.TimeHasPassed( self._idle_started + 3600 ):
@@ -609,6 +629,7 @@ class Controller( HydrusController.HydrusController ):
                 HG.emergency_exit = True
                 
                 self.Exit()
+                
             
         
     
@@ -699,7 +720,7 @@ class Controller( HydrusController.HydrusController ):
         
         self.pub( 'splash_set_status_subtext', 'services' )
         
-        self.services_manager = ClientCaches.ServicesManager( self )
+        self.services_manager = ClientManagers.ServicesManager( self )
         
         self.pub( 'splash_set_status_subtext', 'options' )
         
@@ -809,7 +830,7 @@ class Controller( HydrusController.HydrusController ):
         
         self.local_booru_manager = ClientCaches.LocalBooruCache( self )
         
-        self.file_viewing_stats_manager = ClientCaches.FileViewingStatsManager( self )
+        self.file_viewing_stats_manager = ClientManagers.FileViewingStatsManager( self )
         
         self.pub( 'splash_set_status_subtext', 'tag display' )
         
@@ -828,18 +849,19 @@ class Controller( HydrusController.HydrusController ):
         
         self.pub( 'splash_set_status_subtext', 'tag siblings' )
         
-        self.tag_siblings_manager = ClientCaches.TagSiblingsManager( self )
+        self.tag_siblings_manager = ClientManagers.TagSiblingsManager( self )
         
         self.pub( 'splash_set_status_subtext', 'tag parents' )
         
-        self.tag_parents_manager = ClientCaches.TagParentsManager( self )
-        self._managers[ 'undo' ] = ClientCaches.UndoManager( self )
+        self.tag_parents_manager = ClientManagers.TagParentsManager( self )
+        self._managers[ 'undo' ] = ClientManagers.UndoManager( self )
         
         def qt_code():
             
             self._caches[ 'images' ] = ClientCaches.RenderedImageCache( self )
             self._caches[ 'thumbnail' ] = ClientCaches.ThumbnailCache( self )
-            self.bitmap_manager = ClientCaches.BitmapManager( self )
+            
+            self.bitmap_manager = ClientManagers.BitmapManager( self )
             
             CC.GlobalPixmaps.STATICInitialise()
             
@@ -885,14 +907,46 @@ class Controller( HydrusController.HydrusController ):
         
         self.pub( 'splash_set_title_text', 'booting gui\u2026' )
         
+        self.subscriptions_manager = ClientImportSubscriptions.SubscriptionsManager( self )
+        
         def qt_code_gui():
             
+            ClientGUIStyle.InitialiseDefaults()
+            
+            qt_style_name = self.new_options.GetNoneableString( 'qt_style_name' )
+            
+            if qt_style_name is not None:
+                
+                try:
+                    
+                    ClientGUIStyle.SetStyle( qt_style_name )
+                    
+                except Exception as e:
+                    
+                    HydrusData.Print( 'Could not load Qt style: {}'.format( e ) )
+                    
+                
+            
+            qt_stylesheet_name = self.new_options.GetNoneableString( 'qt_stylesheet_name' )
+            
+            if qt_stylesheet_name is not None:
+                
+                try:
+                    
+                    ClientGUIStyle.SetStylesheet( qt_stylesheet_name )
+                    
+                except Exception as e:
+                    
+                    HydrusData.Print( 'Could not load Qt stylesheet: {}'.format( e ) )
+                    
+                
+            
             self.gui = ClientGUI.FrameGUI( self )
             
             self.ResetIdleTimer()
             
         
-        self.CallBlockingToQt(self._splash, qt_code_gui)
+        self.CallBlockingToQt( self._splash, qt_code_gui )
         
         # ShowText will now popup as a message, as popup message manager has overwritten the hooks
         
@@ -904,7 +958,6 @@ class Controller( HydrusController.HydrusController ):
         
         if not HG.no_daemons:
             
-            self._daemons.append( HydrusThreading.DAEMONForegroundWorker( self, 'SynchroniseSubscriptions', ClientDaemons.DAEMONSynchroniseSubscriptions, ( 'notify_restart_subs_sync_daemon', 'notify_new_subscriptions' ), period = 4 * 3600, init_wait = 60, pre_call_wait = 3 ) )
             self._daemons.append( HydrusThreading.DAEMONForegroundWorker( self, 'MaintainTrash', ClientDaemons.DAEMONMaintainTrash, init_wait = 120 ) )
             self._daemons.append( HydrusThreading.DAEMONForegroundWorker( self, 'SynchroniseRepositories', ClientDaemons.DAEMONSynchroniseRepositories, ( 'notify_restart_repo_sync_daemon', 'notify_new_permissions', 'wake_idle_workers' ), period = 4 * 3600, pre_call_wait = 1 ) )
             
@@ -1423,6 +1476,8 @@ class Controller( HydrusController.HydrusController ):
     
     def ShutdownModel( self ):
         
+        self.pub( 'splash_set_status_text', 'saving and exiting objects' )
+        
         if self._is_booted:
             
             self.file_viewing_stats_manager.Flush()
@@ -1437,12 +1492,20 @@ class Controller( HydrusController.HydrusController ):
         
         if not HG.emergency_exit:
             
+            self.pub( 'splash_set_status_text', 'waiting for subscriptions to exit' )
+            
+            self._ShutdownSubscriptionsManager()
+            
             self.pub( 'splash_set_status_text', 'waiting for daemons to exit' )
             
             self._ShutdownDaemons()
             
+            self.pub( 'splash_set_status_subtext', '' )
+            
             if HG.do_idle_shutdown_work:
                 
+                self.pub( 'splash_set_status_text', 'waiting for idle shutdown work' )
+                
                 try:
                     
                     self.DoIdleShutdownWork()
diff --git a/include/ClientDB.py b/include/ClientDB.py
index c351f0ab..ee5645c2 100755
--- a/include/ClientDB.py
+++ b/include/ClientDB.py
@@ -13189,6 +13189,38 @@ class DB( HydrusDB.HydrusDB ):
                 
             
         
+        if version == 375:
+            
+            try:
+                
+                domain_manager = self._GetJSONDump( HydrusSerialisable.SERIALISABLE_TYPE_NETWORK_DOMAIN_MANAGER )
+                
+                domain_manager.Initialise()
+                
+                #
+                
+                domain_manager.OverwriteDefaultGUGs( ( 'pixiv tag search', 'twitter username lookup' ) )
+                domain_manager.OverwriteDefaultURLClasses( ( 'pixiv search api', 'twitter tweets api - media only' ) )
+                domain_manager.OverwriteDefaultParsers( ( 'pixiv tag search api parser', 'twitter tweet parser (video from koto.reisen)', 'twitter media tweets api parser' ) )
+                
+                #
+                
+                domain_manager.TryToLinkURLClassesAndParsers()
+                
+                #
+                
+                self._SetJSONDump( domain_manager )
+                
+            except Exception as e:
+                
+                HydrusData.PrintException( e )
+                
+                message = 'Trying to update some parsers failed! Please let hydrus dev know!'
+                
+                self.pub_initial_message( message )
+                
+            
+        
         self._controller.pub( 'splash_set_title_text', 'updated db to v' + str( version + 1 ) )
         
         self._c.execute( 'UPDATE version SET version = ?;', ( version + 1, ) )
diff --git a/include/ClientDaemons.py b/include/ClientDaemons.py
index 09792727..93b16c52 100644
--- a/include/ClientDaemons.py
+++ b/include/ClientDaemons.py
@@ -166,167 +166,3 @@ def DAEMONSynchroniseRepositories( controller ):
             
         
     
-
-class SubscriptionJob( object ):
-    
-    def __init__( self, controller, name ):
-        
-        self._controller = controller
-        self._name = name
-        self._job_done = threading.Event()
-        
-    
-    def _DoWork( self ):
-        
-        if HG.subscription_report_mode:
-            
-            HydrusData.ShowText( 'Subscription "' + self._name + '" about to start.' )
-            
-        
-        subscription = self._controller.Read( 'serialisable_named', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION, self._name )
-        
-        subscription.Sync()
-        
-    
-    def IsDone( self ):
-        
-        return self._job_done.is_set()
-        
-    
-    def Work( self ):
-        
-        try:
-            
-            self._DoWork()
-            
-        finally:
-            
-            self._job_done.set()
-            
-        
-    
-def DAEMONSynchroniseSubscriptions( controller ):
-    
-    def filter_finished_jobs( subs_jobs ):
-        
-        done_indices = [ i for ( i, ( thread, job ) ) in enumerate( subs_jobs ) if job.IsDone() ]
-        
-        done_indices.reverse()
-        
-        for i in done_indices:
-            
-            del subs_jobs[ i ]
-            
-        
-    
-    def wait_for_free_slot( controller, subs_jobs, max_simultaneous_subscriptions ):
-        
-        time.sleep( 0.1 )
-        
-        while True:
-            
-            p1 = controller.options[ 'pause_subs_sync' ]
-            p2 = HydrusThreading.IsThreadShuttingDown()
-            p3 = controller.new_options.GetBoolean( 'pause_all_new_network_traffic' )
-            
-            if p1 or p2 or p3:
-                
-                if HG.subscription_report_mode:
-                    
-                    HydrusData.ShowText( 'Subscriptions cancelling. Global sub pause is {}, sub daemon thread shutdown status is {}, and global network pause is {}.'.format( p1, p2, p3 ) )
-                    
-                
-                if p2:
-                    
-                    for ( thread, job ) in subs_jobs:
-                        
-                        HydrusThreading.ShutdownThread( thread )
-                        
-                    
-                
-                raise HydrusExceptions.CancelledException( 'subs cancelling or thread shutting down' )
-                
-            
-            filter_finished_jobs( subs_jobs )
-            
-            if len( subs_jobs ) < max_simultaneous_subscriptions:
-                
-                return
-                
-            
-            time.sleep( 1.0 )
-            
-        
-    
-    def wait_for_all_finished( subs_jobs ):
-        
-        while True:
-            
-            filter_finished_jobs( subs_jobs )
-            
-            if len( subs_jobs ) == 0:
-                
-                return
-                
-            
-            time.sleep( 1.0 )
-            
-        
-    
-    if HG.subscription_report_mode:
-        
-        HydrusData.ShowText( 'Subscription daemon started a run.' )
-        
-    
-    subscription_names = list( controller.Read( 'serialisable_names', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION ) )
-    
-    if controller.new_options.GetBoolean( 'process_subs_in_random_order' ):
-        
-        random.shuffle( subscription_names )
-        
-    else:
-        
-        subscription_names.sort()
-        
-    
-    HG.subscriptions_running = True
-    
-    subs_jobs = []
-    
-    try:
-        
-        for name in subscription_names:
-            
-            max_simultaneous_subscriptions = controller.new_options.GetInteger( 'max_simultaneous_subscriptions' )
-            
-            try:
-                
-                wait_for_free_slot( controller, subs_jobs, max_simultaneous_subscriptions )
-                
-            except HydrusExceptions.CancelledException:
-                
-                break
-                
-            
-            job = SubscriptionJob( controller, name )
-            
-            thread = threading.Thread( target = job.Work, name = 'subscription thread' )
-            
-            thread.start()
-            
-            subs_jobs.append( ( thread, job ) )
-            
-            # while we initialise the queue, don't hammer the cpu
-            if len( subs_jobs ) < max_simultaneous_subscriptions:
-                
-                time.sleep( 1.0 )
-                
-            
-        
-        wait_for_all_finished( subs_jobs )
-        
-    finally:
-        
-        HG.subscriptions_running = False
-        
-    
diff --git a/include/ClientDefaults.py b/include/ClientDefaults.py
index 9f160de8..64ee95d0 100644
--- a/include/ClientDefaults.py
+++ b/include/ClientDefaults.py
@@ -21,7 +21,6 @@ def GetClientDefaultOptions():
     options[ 'hpos' ] = 400
     options[ 'vpos' ] = -240
     options[ 'thumbnail_cache_size' ] = 25 * 1048576
-    options[ 'preview_cache_size' ] = 15 * 1048576
     options[ 'fullscreen_cache_size' ] = 150 * 1048576
     options[ 'thumbnail_dimensions' ] = [ 150, 125 ]
     options[ 'password' ] = None
diff --git a/include/ClientDragDrop.py b/include/ClientDragDrop.py
index 23fed743..c5711bc7 100644
--- a/include/ClientDragDrop.py
+++ b/include/ClientDragDrop.py
@@ -113,10 +113,7 @@ def DoFileExportDragDrop( window, page_key, media, alt_down ):
     
     hashes = [ m.GetHash() for m in media ]
     
-    if not HC.PLATFORM_MACOS:
-        
-        data_object.setHydrusFiles( page_key, hashes )
-        
+    data_object.setHydrusFiles( page_key, hashes )
     
     # old way of doing this that makes some external programs (discord) reject it
     '''
@@ -168,7 +165,7 @@ class FileDropTarget( QC.QObject ):
         if event.type() == QC.QEvent.Drop:
             
             if self.OnDrop( event.pos().x(), event.pos().y() ):
-
+                
                 event.setDropAction( self.OnData( event.mimeData(), event.proposedAction() ) )
                 event.accept()
                 
@@ -183,90 +180,92 @@ class FileDropTarget( QC.QObject ):
     
     def OnData( self, mime_data, result ):
         
-        if mime_data.formats():
+        media_dnd = isinstance( mime_data, QMimeDataHydrusFiles )
+        urls_dnd = mime_data.hasUrls()
+        text_dnd = mime_data.hasText()
+        
+        if media_dnd and self._media_callable is not None:
             
-            if isinstance( mime_data, QMimeDataHydrusFiles ) and self._media_callable is not None:
+            result = mime_data.hydrusFiles()
+            
+            if result is not None:
                 
-                result = mime_data.hydrusFiles()
+                ( page_key, hashes ) = result
                 
-                if result is not None:
+                if page_key is not None:
                     
-                    ( page_key, hashes ) = result
-                    
-                    if page_key is not None:
-                        
-                        QP.CallAfter( self._media_callable, page_key, hashes )  # callafter so we can terminate dnd event now
-                        
-                    
-                
-                result = QC.Qt.MoveAction
-                
-                # old way of doing it that messed up discord et al
-                '''
-            elif mime_data.formats().count( 'application/hydrus-media' ) and self._media_callable is not None:
-                
-                mview = mime_data.data( 'application/hydrus-media' )
-
-                data_bytes = mview.data()
-
-                data_str = str( data_bytes, 'utf-8' )
-
-                (encoded_page_key, encoded_hashes) = json.loads( data_str )
-
-                if encoded_page_key is not None:
-                    
-                    page_key = bytes.fromhex( encoded_page_key )
-                    hashes = [ bytes.fromhex( encoded_hash ) for encoded_hash in encoded_hashes ]
-
                     QP.CallAfter( self._media_callable, page_key, hashes )  # callafter so we can terminate dnd event now
                     
+                
+            
+            result = QC.Qt.MoveAction
+            
+            # old way of doing it that messed up discord et al
+            '''
+        elif mime_data.formats().count( 'application/hydrus-media' ) and self._media_callable is not None:
+            
+            mview = mime_data.data( 'application/hydrus-media' )
 
-                result = QC.Qt.MoveAction
-                '''
-            elif mime_data.hasUrls() and self._filenames_callable is not None:
+            data_bytes = mview.data()
+
+            data_str = str( data_bytes, 'utf-8' )
+
+            (encoded_page_key, encoded_hashes) = json.loads( data_str )
+
+            if encoded_page_key is not None:
                 
-                paths = []
-                urls = []
+                page_key = bytes.fromhex( encoded_page_key )
+                hashes = [ bytes.fromhex( encoded_hash ) for encoded_hash in encoded_hashes ]
+
+                QP.CallAfter( self._media_callable, page_key, hashes )  # callafter so we can terminate dnd event now
                 
-                for url in mime_data.urls():
+
+            result = QC.Qt.MoveAction
+            '''
+        elif urls_dnd and self._filenames_callable is not None:
+            
+            paths = []
+            urls = []
+            
+            for url in mime_data.urls():
+                
+                if url.isLocalFile():
                     
-                    if url.isLocalFile():
-                        
-                        paths.append( os.path.normpath( url.toLocalFile() ) )
-                        
-                    else:
-                        
-                        urls.append( url.url() )
-                        
+                    paths.append( os.path.normpath( url.toLocalFile() ) )
+                    
+                else:
+                    
+                    urls.append( url.url() )
                     
                 
-                if len( paths ) > 0:
+            
+            if len( paths ) > 0:
+                
+                QP.CallAfter( self._filenames_callable, paths ) # callafter to terminate dnd event now
+                
+            
+            if len( urls ) > 0:
+                
+                for url in urls:
                     
-                    QP.CallAfter( self._filenames_callable, paths ) # callafter to terminate dnd event now
+                    QP.CallAfter( self._url_callable, url ) # callafter to terminate dnd event now
                     
                 
-                if len( urls ) > 0:
-                    
-                    for url in urls:
-                        
-                        QP.CallAfter( self._url_callable, url ) # callafter to terminate dnd event now
-                        
-                    
-                
-                result = QC.Qt.IgnoreAction
-                
-            elif mime_data.hasText() and self._url_callable is not None:
-                
-                text = mime_data.text()
-                
-                QP.CallAfter( self._url_callable, text ) # callafter to terminate dnd event now
-                
-                result = QC.Qt.CopyAction
-                
-            else:                      
-                
-                result = QC.Qt.MoveAction
-                
+            
+            result = QC.Qt.IgnoreAction
+            
+        elif text_dnd and self._url_callable is not None:
+            
+            text = mime_data.text()
+            
+            QP.CallAfter( self._url_callable, text ) # callafter to terminate dnd event now
+            
+            result = QC.Qt.CopyAction
+            
+            
+        else:
+            
+            result = QC.Qt.IgnoreAction
             
         
         return result
diff --git a/include/ClientExporting.py b/include/ClientExporting.py
index d70844d3..987e6127 100644
--- a/include/ClientExporting.py
+++ b/include/ClientExporting.py
@@ -84,6 +84,12 @@ def GenerateExportFilename( destination_directory, media, terms, append_number =
                 
                 filename += hash.hex()
                 
+            elif term == 'file_id':
+                
+                hash_id = media.GetHashId()
+                
+                filename += str( hash_id )
+                
             
         elif term_type == 'tag':
             
diff --git a/include/ClientGUI.py b/include/ClientGUI.py
index 0baf7ec9..9fa0ba47 100755
--- a/include/ClientGUI.py
+++ b/include/ClientGUI.py
@@ -26,6 +26,7 @@ from . import ClientGUIScrolledPanelsEdit
 from . import ClientGUIScrolledPanelsManagement
 from . import ClientGUIScrolledPanelsReview
 from . import ClientGUIShortcuts
+from . import ClientGUIStyle
 from . import ClientGUITags
 from . import ClientGUITopLevelWindows
 from . import ClientMedia
@@ -384,7 +385,6 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
         self._widget_event_filter.EVT_LEFT_DCLICK( self.EventFrameNewPage )
         self._widget_event_filter.EVT_MIDDLE_DOWN( self.EventFrameNewPage )
         self._widget_event_filter.EVT_RIGHT_DOWN( self.EventFrameNotebookMenu )
-        self._widget_event_filter.EVT_CLOSE( self.EventClose )
         self._widget_event_filter.EVT_SET_FOCUS( self.EventFocus )
         self._widget_event_filter.EVT_ICONIZE( self.EventIconize )
         
@@ -1878,7 +1878,7 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
         
         #self._controller.CallLaterQtSafe(self, 1.0, self.adjustSize ) # some i3 thing--doesn't layout main gui on init for some reason
         
-        self._controller.CallLaterQtSafe(self, last_session_save_period_minutes * 60, self.SaveLastSession)
+        self._controller.CallLaterQtSafe(self, last_session_save_period_minutes * 60, self.AutoSaveLastSession)
         
         self._clipboard_watcher_repeating_job = self._controller.CallRepeatingQtSafe(self, 1.0, 1.0, self.REPEATINGClipboardWatcher)
         
@@ -2298,6 +2298,27 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
             dlg.exec()
             
         
+        qt_style_name = self._controller.new_options.GetNoneableString( 'qt_style_name' )
+        qt_stylesheet_name = self._controller.new_options.GetNoneableString( 'qt_stylesheet_name' )
+        
+        if qt_style_name is None:
+            
+            ClientGUIStyle.SetStyle( ClientGUIStyle.ORIGINAL_STYLE )
+            
+        else:
+            
+            ClientGUIStyle.SetStyle( qt_style_name )
+            
+        
+        if qt_stylesheet_name is None:
+            
+            ClientGUIStyle.ClearStylesheet()
+            
+        else:
+            
+            ClientGUIStyle.SetStylesheet( qt_stylesheet_name )
+            
+        
         self._controller.pub( 'wake_daemons' )
         self.SetStatusBarDirty()
         self._controller.pub( 'refresh_page_name' )
@@ -2414,6 +2435,8 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
                     
                     HG.client_controller.Write( 'serialisables_overwrite', [ HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION ], subscriptions )
                     
+                    HG.client_controller.subscriptions_manager.NewSubscriptions( subscriptions )
+                    
                 
             
         
@@ -2427,7 +2450,7 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
                 
                 try:
                     
-                    if HG.subscriptions_running:
+                    if HG.client_controller.subscriptions_manager.SubscriptionsRunning():
                         
                         job_key = ClientThreading.JobKey()
                         
@@ -2437,7 +2460,7 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
                             
                             controller.pub( 'message', job_key )
                             
-                            while HG.subscriptions_running:
+                            while HG.client_controller.subscriptions_manager.SubscriptionsRunning():
                                 
                                 time.sleep( 0.1 )
                                 
@@ -2486,7 +2509,7 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
                     
                     try:
                         
-                        controller.CallBlockingToQt(self, qt_do_it, subscriptions, original_pause_status)
+                        controller.CallBlockingToQt( self, qt_do_it, subscriptions, original_pause_status )
                         
                     except HydrusExceptions.QtDeadWindowException:
                         
@@ -2497,8 +2520,6 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
                     
                     controller.options[ 'pause_subs_sync' ] = original_pause_status
                     
-                    controller.pub( 'notify_new_subscriptions' )
-                    
                 
             
         
@@ -2694,7 +2715,7 @@ class FrameGUI( ClientGUITopLevelWindows.MainFrameThatResizes ):
             
             HC.options[ 'pause_subs_sync' ] = not HC.options[ 'pause_subs_sync' ]
             
-            self._controller.pub( 'notify_restart_subs_sync_daemon' )
+            self._controller.subscriptions_manager.Wake()
             
         elif sync_type == 'export_folders':
             
@@ -3556,7 +3577,7 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             
             hide_close_button = not job_key.IsCancellable()
             
-            with ClientGUITopLevelWindows.DialogNullipotent( self, title, hide_buttons = hide_close_button ) as dlg:
+            with ClientGUITopLevelWindows.DialogNullipotent( self, title, hide_buttons = hide_close_button, do_not_activate = True ) as dlg:
                 
                 panel = ClientGUIPopupMessages.PopupMessageDialogPanel( dlg, job_key )
                 
@@ -3567,6 +3588,29 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             
         
     
+    def AutoSaveLastSession( self ):
+        
+        only_save_last_session_during_idle = self._controller.new_options.GetBoolean( 'only_save_last_session_during_idle' )
+        
+        if only_save_last_session_during_idle and not self._controller.CurrentlyIdle():
+            
+            next_call_delay = 60
+            
+        else:
+            
+            if HC.options[ 'default_gui_session' ] == 'last session':
+                
+                self._notebook.SaveGUISession( 'last session' )
+                
+            
+            last_session_save_period_minutes = self._controller.new_options.GetInteger( 'last_session_save_period_minutes' )
+            
+            next_call_delay = last_session_save_period_minutes * 60
+            
+        
+        self._controller.CallLaterQtSafe( self, next_call_delay, self.AutoSaveLastSession )
+        
+    
     def DeleteAllClosedPages( self ):
         
         deletee_pages = [ page for ( time_closed, page ) in self._closed_pages ]
@@ -3635,13 +3679,13 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             
         
     
-    def EventClose( self, event ):
+    def closeEvent( self, event ):
         
         exit_allowed = self.Exit()
         
         if not exit_allowed:
             
-            return True # was: event.ignore()
+            event.ignore()
             
         
     
@@ -4126,7 +4170,7 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             
             if self._controller.new_options.GetBoolean( 'advanced_mode' ):
                 
-                ClientGUIMenus.AppendMenuItem( submenu, 'nudge subscriptions awake', 'Tell the subs daemon to wake up, just in case any subs are due.', self._controller.pub, 'notify_restart_subs_sync_daemon' )
+                ClientGUIMenus.AppendMenuItem( submenu, 'nudge subscriptions awake', 'Tell the subs daemon to wake up, just in case any subs are due.', self._controller.subscriptions_manager.ClearCacheAndWake )
                 
             
             ClientGUIMenus.AppendSeparator( submenu )
@@ -4325,7 +4369,8 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             links = QW.QMenu( menu )
             
             site = ClientGUIMenus.AppendMenuBitmapItem( links, 'site', 'Open hydrus\'s website, which is mostly a mirror of the local help.', CC.GlobalPixmaps.file_repository, ClientPaths.LaunchURLInWebBrowser, 'https://hydrusnetwork.github.io/hydrus/' )
-            site = ClientGUIMenus.AppendMenuBitmapItem( links, '8chan board', 'Open hydrus dev\'s 8chan board, where he makes release posts and other status updates. Much other discussion also occurs.', CC.GlobalPixmaps.eight_chan, ClientPaths.LaunchURLInWebBrowser, 'https://8ch.net/hydrus/index.html' )
+            site = ClientGUIMenus.AppendMenuBitmapItem( links, '8kun board', 'Open hydrus dev\'s 8kun board, where he makes release posts and other status updates.', CC.GlobalPixmaps.eight_kun, ClientPaths.LaunchURLInWebBrowser, 'https://8kun.top/hydrus/index.html' )
+            site = ClientGUIMenus.AppendMenuItem( links, 'Endchan board bunker', 'Open hydrus dev\'s Endchan board, the bunker for when 8kun is unavailable.', ClientPaths.LaunchURLInWebBrowser, 'https://endchan.net/hydrus/index.html' )
             site = ClientGUIMenus.AppendMenuBitmapItem( links, 'twitter', 'Open hydrus dev\'s twitter, where he makes general progress updates and emergency notifications.', CC.GlobalPixmaps.twitter, ClientPaths.LaunchURLInWebBrowser, 'https://twitter.com/hydrusnetwork' )
             site = ClientGUIMenus.AppendMenuBitmapItem( links, 'tumblr', 'Open hydrus dev\'s tumblr, where he makes release posts and other status updates.', CC.GlobalPixmaps.tumblr, ClientPaths.LaunchURLInWebBrowser, 'http://hydrus.tumblr.com/' )
             site = ClientGUIMenus.AppendMenuBitmapItem( links, 'discord', 'Open a discord channel where many hydrus users congregate. Hydrus dev visits regularly.', CC.GlobalPixmaps.discord, ClientPaths.LaunchURLInWebBrowser, 'https://discord.gg/vy8CUB4' )
@@ -4417,6 +4462,7 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             ClientGUIMenus.AppendMenuItem( data_actions, 'run slow memory maintenance', 'Tell all the slow caches to maintain themselves.', self._controller.MaintainMemorySlow )
             ClientGUIMenus.AppendMenuItem( data_actions, 'review threads', 'Show current threads and what they are doing.', self._ReviewThreads )
             ClientGUIMenus.AppendMenuItem( data_actions, 'show scheduled jobs', 'Print some information about the currently scheduled jobs log.', self._DebugShowScheduledJobs )
+            ClientGUIMenus.AppendMenuItem( data_actions, 'subscription manager snapshot', 'Have the subscription system show what it is doing.', self._controller.subscriptions_manager.ShowSnapshot )
             ClientGUIMenus.AppendMenuItem( data_actions, 'flush log', 'Command the log to write any buffered contents to hard drive.', HydrusData.DebugPrint, 'Flushing log' )
             ClientGUIMenus.AppendMenuItem( data_actions, 'print garbage', 'Print some information about the python garbage to the log.', self._DebugPrintGarbage )
             ClientGUIMenus.AppendMenuItem( data_actions, 'take garbage snapshot', 'Capture current garbage object counts.', self._DebugTakeGarbageSnapshot )
@@ -5539,29 +5585,6 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
             
         
     
-    def SaveLastSession( self ):
-        
-        only_save_last_session_during_idle = self._controller.new_options.GetBoolean( 'only_save_last_session_during_idle' )
-        
-        if only_save_last_session_during_idle and not self._controller.CurrentlyIdle():
-            
-            next_call_delay = 60
-            
-        else:
-            
-            if HC.options[ 'default_gui_session' ] == 'last session':
-                
-                self._notebook.SaveGUISession( 'last session' )
-                
-            
-            last_session_save_period_minutes = self._controller.new_options.GetInteger( 'last_session_save_period_minutes' )
-            
-            next_call_delay = last_session_save_period_minutes * 60
-            
-        
-        self._controller.CallLaterQtSafe(self, next_call_delay, self.SaveLastSession)
-        
-    
     def SetMediaFocus( self ):
         
         self._SetMediaFocus()
diff --git a/include/ClientGUIACDropdown.py b/include/ClientGUIACDropdown.py
index 2341f5c6..0258a1b8 100644
--- a/include/ClientGUIACDropdown.py
+++ b/include/ClientGUIACDropdown.py
@@ -518,9 +518,10 @@ class AutoCompleteDropdown( QW.QWidget ):
             
             self._dropdown_window = QW.QFrame( self )
             
+            self._dropdown_window.setWindowFlags( QC.Qt.Tool | QC.Qt.FramelessWindowHint )
+            
             self._dropdown_window.setAttribute( QC.Qt.WA_ShowWithoutActivating )
             
-            self._dropdown_window.setWindowFlags( QC.Qt.Tool | QC.Qt.FramelessWindowHint )
             self._dropdown_window.setFrameStyle( QW.QFrame.Panel | QW.QFrame.Raised )
             self._dropdown_window.setLineWidth( 2 )
             
@@ -995,6 +996,8 @@ class AutoCompleteDropdown( QW.QWidget ):
         
         HG.client_controller.gui.close()
         
+        return True
+        
     
     def EventKillFocus( self, event ):
         
diff --git a/include/ClientGUIAsync.py b/include/ClientGUIAsync.py
index f188433e..2f74067b 100644
--- a/include/ClientGUIAsync.py
+++ b/include/ClientGUIAsync.py
@@ -188,7 +188,12 @@ class FastThreadToGUIUpdater( object ):
     # if not, we won't get bungled up with 10,000+ pubsub events in the event queue
     def Update( self, *args, **kwargs ):
         
-        if HG.view_shutdown:
+        if HG.model_shutdown:
+            
+            return
+            
+        
+        if self._win is None:
             
             return
             
diff --git a/include/ClientGUICanvas.py b/include/ClientGUICanvas.py
index 3eba3801..7690da04 100755
--- a/include/ClientGUICanvas.py
+++ b/include/ClientGUICanvas.py
@@ -926,11 +926,27 @@ class CanvasFrame( ClientGUITopLevelWindows.FrameThatResizes ):
         self.destroyed.connect( HG.client_controller.gui.MaintainCanvasFrameReferences )
         
     
-    def close( self ):
+    def closeEvent( self, event ):
         
-        self._canvas_window.CleanBeforeDestroy()
-        
-        ClientGUITopLevelWindows.FrameThatResizes.close( self )
+        if self._canvas_window is not None:
+            
+            can_close = self._canvas_window.TryToDoPreClose()
+            
+            if can_close:
+                
+                self._canvas_window.CleanBeforeDestroy()
+                
+                ClientGUITopLevelWindows.FrameThatResizes.closeEvent( self, event )
+                
+            else:
+                
+                event.ignore()
+                
+            
+        else:
+            
+            ClientGUITopLevelWindows.FrameThatResizes.closeEvent( self, event )
+            
         
     
     def FullscreenSwitch( self ):
@@ -1008,8 +1024,6 @@ class CanvasFrame( ClientGUITopLevelWindows.FrameThatResizes ):
         # just to reinforce, as Qt sometimes sets none focus for this window until it goes off and back on
         self._canvas_window.setFocus( QC.Qt.OtherFocusReason )
         
-        self._widget_event_filter.EVT_CLOSE( self._canvas_window.EventClose )
-        
     
     def TakeFocusForUser( self ):
         
@@ -1043,8 +1057,6 @@ class Canvas( QW.QWidget ):
         
         self._maintain_pan_and_zoom = False
         
-        self._closing = False
-        
         self._service_keys_to_services = {}
         
         self._current_media = None
@@ -1954,24 +1966,21 @@ class Canvas( QW.QWidget ):
     
     def resizeEvent( self, event ):
         
-        if not self._closing:
+        ( my_width, my_height ) = self.size().toTuple()
+        
+        if self._current_media is not None:
             
-            ( my_width, my_height ) = self.size().toTuple()
+            ( media_width, media_height ) = self._media_container.size().toTuple()
             
-            if self._current_media is not None:
+            if my_width != media_width or my_height != media_height:
                 
-                ( media_width, media_height ) = self._media_container.size().toTuple()
+                self._ReinitZoom()
                 
-                if my_width != media_width or my_height != media_height:
-                    
-                    self._ReinitZoom()
-                    
-                    self._ResetMediaWindowCenterPosition()
-                    
+                self._ResetMediaWindowCenterPosition()
                 
             
-            self.update()
-            
+        
+        self.update()
         
     
     def FlipActiveCustomShortcutName( self, name ):
@@ -2775,23 +2784,21 @@ class CanvasWithHovers( CanvasWithDetails ):
         HG.client_controller.sub( self, 'FullscreenSwitch', 'canvas_fullscreen_switch' )
         
     
-    def _Close( self ):
-        
-        self._closing = True
-        
-        self.parentWidget().close()
-        
-    
     def _GenerateHoverTopFrame( self ):
         
         raise NotImplementedError()
         
     
+    def _TryToCloseWindow( self ):
+        
+        self.window().close()
+        
+    
     def CloseFromHover( self, canvas_key ):
         
         if canvas_key == self._canvas_key:
             
-            self._Close()
+            self._TryToCloseWindow()
             
         
     
@@ -2918,6 +2925,13 @@ class CanvasWithHovers( CanvasWithDetails ):
             
         
     
+    def TryToDoPreClose( self ):
+        
+        can_close = True
+        
+        return can_close
+        
+    
 class CanvasFilterDuplicates( CanvasWithHovers ):
     
     def __init__( self, parent, file_search_context, both_files_match ):
@@ -2959,7 +2973,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
         QP.CallAfter( self._ShowNewPair )
         
     
-    def _Close( self ):
+    def TryToDoPreClose( self ):
         
         num_committable = self._GetNumCommittableDecisions()
         
@@ -2978,7 +2992,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
                     self._GoBack()
                     
                 
-                return
+                return False
                 
             elif result == QW.QDialog.Accepted:
                 
@@ -2991,7 +3005,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
         
         HG.client_controller.pub( 'refresh_dupe_page_numbers' )
         
-        CanvasWithHovers._Close( self )
+        return True
         
     
     def _CommitProcessed( self, blocking = True ):
@@ -3276,7 +3290,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
                     
                     QW.QMessageBox.critical( self, 'Error', 'Due to an unexpected series of events (likely a series of file deletes), the duplicate filter has no valid pair to back up to. It will now close.' )
                     
-                    self._Close()
+                    self.window().deleteLater()
                     
                     return
                     
@@ -3409,7 +3423,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
                         
                         QW.QMessageBox.critical( self, 'Error', 'Due to an unexpected series of events (likely a series of file deletes), the duplicate filter has no valid pair to back up to. It will now close.' )
                         
-                        self._Close()
+                        self.window().deleteLater()
                         
                         return
                         
@@ -3478,7 +3492,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
                         
                         QW.QMessageBox.critical( self, 'Error', 'It seems an entire batch of pairs were unable to be displayed. The duplicate filter will now close.' )
                         
-                        self._Close()
+                        self.window().deleteLater()
                         
                         return
                         
@@ -3503,7 +3517,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
                 
                 self._CommitProcessed( blocking = True )
                 
-                self._Close()
+                self._TryToCloseWindow()
                 
                 return
                 
@@ -3585,11 +3599,6 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
             
         
     
-    def EventClose( self, event ):
-        
-        if not self._closing: self._Close()
-        
-    
     def EventMouse( self, event ):
         
         if self._IShouldCatchShortcutEvent( event = event ):
@@ -3662,7 +3671,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
             
             if key in ( QC.Qt.Key_Enter, QC.Qt.Key_Return, QC.Qt.Key_Escape ):
                 
-                self._Close()
+                self._TryToCloseWindow()
                 
             else:
                 
@@ -3820,7 +3829,7 @@ class CanvasFilterDuplicates( CanvasWithHovers ):
             
             QW.QMessageBox.information( self, 'Information', 'All pairs have been filtered!' )
             
-            self._Close()
+            self._TryToCloseWindow()
             
         
         def qt_continue( unprocessed_pairs ):
@@ -3866,11 +3875,11 @@ class CanvasMediaList( ClientMedia.ListeningMediaList, CanvasWithHovers ):
         HG.client_controller.pub( 'set_focus', self._page_key, None )
         
     
-    def _Close( self ):
+    def TryToDoPreClose( self ):
         
         HG.client_controller.pub( 'set_focus', self._page_key, self._current_media )
         
-        CanvasWithHovers._Close( self )
+        return CanvasWithHovers.TryToDoPreClose( self )
         
     
     def _GetIndexString( self ):
@@ -3975,7 +3984,7 @@ class CanvasMediaList( ClientMedia.ListeningMediaList, CanvasWithHovers ):
         
         if self.HasNoMedia():
             
-            self._Close()
+            self._TryToCloseWindow()
             
         elif self.HasMedia( self._current_media ):
             
@@ -4026,11 +4035,6 @@ class CanvasMediaList( ClientMedia.ListeningMediaList, CanvasWithHovers ):
             
         
     
-    def EventClose( self, event ):
-        
-        if not self._closing: self._Close()
-        
-    
     def EventFullscreenSwitch( self, event ):
         
         self.parentWidget().FullscreenSwitch()
@@ -4061,7 +4065,7 @@ class CanvasMediaList( ClientMedia.ListeningMediaList, CanvasWithHovers ):
         
         if self.HasNoMedia():
             
-            self._Close()
+            self._TryToCloseWindow()
             
         elif self.HasMedia( self._current_media ):
             
@@ -4116,75 +4120,72 @@ class CanvasMediaListFilterArchiveDelete( CanvasMediaList ):
             
         
     
-    def _Close( self ):
+    def TryToDoPreClose( self ):
         
-        if self._IShouldCatchShortcutEvent():
+        if len( self._kept ) > 0 or len( self._deleted ) > 0:
             
-            if len( self._kept ) > 0 or len( self._deleted ) > 0:
+            label = 'keep ' + HydrusData.ToHumanInt( len( self._kept ) ) + ' and delete ' + HydrusData.ToHumanInt( len( self._deleted ) ) + ' files?'
+            
+            ( result, cancelled ) = ClientGUIDialogsQuick.GetFinishFilteringAnswer( self, label )
+            
+            if cancelled:
                 
-                label = 'keep ' + HydrusData.ToHumanInt( len( self._kept ) ) + ' and delete ' + HydrusData.ToHumanInt( len( self._deleted ) ) + ' files?'
+                if self._current_media in self._kept:
+                    
+                    self._kept.remove( self._current_media )
+                    
                 
-                result, cancelled = ClientGUIDialogsQuick.GetFinishFilteringAnswer( self, label )
+                if self._current_media in self._deleted:
+                    
+                    self._deleted.remove( self._current_media )
+                    
                 
-                if cancelled:
+                return False
+                
+            elif result == QW.QDialog.Accepted:
+                
+                def process_in_thread( service_keys_and_content_updates ):
                     
-                    if self._current_media in self._kept:
+                    for ( service_key, content_update ) in service_keys_and_content_updates:
                         
-                        self._kept.remove( self._current_media )
+                        HG.client_controller.WriteSynchronous( 'content_updates', { service_key : [ content_update ] } )
                         
                     
-                    if self._current_media in self._deleted:
-                        
-                        self._deleted.remove( self._current_media )
-                        
+                
+                self._deleted_hashes = [ media.GetHash() for media in self._deleted ]
+                self._kept_hashes = [ media.GetHash() for media in self._kept ]
+                
+                service_keys_and_content_updates = []
+                
+                reason = 'Deleted in Archive/Delete filter.'
+                
+                for chunk_of_hashes in HydrusData.SplitListIntoChunks( self._deleted_hashes, 64 ):
                     
-                    return
+                    service_keys_and_content_updates.append( ( CC.LOCAL_FILE_SERVICE_KEY, HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_DELETE, chunk_of_hashes, reason = reason ) ) )
                     
-                elif result == QW.QDialog.Accepted:
+                
+                service_keys_and_content_updates.append( ( CC.COMBINED_LOCAL_FILE_SERVICE_KEY, HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, self._kept_hashes ) ) )
+                
+                HG.client_controller.CallToThread( process_in_thread, service_keys_and_content_updates )
+                
+                self._kept = set()
+                self._deleted = set()
+                
+                self._current_media = self._GetFirst() # so the pubsub on close is better
+                
+                if HC.options[ 'remove_filtered_files' ]:
                     
-                    def process_in_thread( service_keys_and_content_updates ):
-                        
-                        for ( service_key, content_update ) in service_keys_and_content_updates:
-                            
-                            HG.client_controller.WriteSynchronous( 'content_updates', { service_key : [ content_update ] } )
-                            
-                        
+                    all_hashes = set()
                     
-                    self._deleted_hashes = [ media.GetHash() for media in self._deleted ]
-                    self._kept_hashes = [ media.GetHash() for media in self._kept ]
+                    all_hashes.update( self._deleted_hashes )
+                    all_hashes.update( self._kept_hashes )
                     
-                    service_keys_and_content_updates = []
-                    
-                    reason = 'Deleted in Archive/Delete filter.'
-                    
-                    for chunk_of_hashes in HydrusData.SplitListIntoChunks( self._deleted_hashes, 64 ):
-                        
-                        service_keys_and_content_updates.append( ( CC.LOCAL_FILE_SERVICE_KEY, HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_DELETE, chunk_of_hashes, reason = reason ) ) )
-                        
-                    
-                    service_keys_and_content_updates.append( ( CC.COMBINED_LOCAL_FILE_SERVICE_KEY, HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, self._kept_hashes ) ) )
-                    
-                    HG.client_controller.CallToThread( process_in_thread, service_keys_and_content_updates )
-                    
-                    self._kept = set()
-                    self._deleted = set()
-                    
-                    self._current_media = self._GetFirst() # so the pubsub on close is better
-                    
-                    if HC.options[ 'remove_filtered_files' ]:
-                        
-                        all_hashes = set()
-                        
-                        all_hashes.update( self._deleted_hashes )
-                        all_hashes.update( self._kept_hashes )
-                        
-                        HG.client_controller.pub( 'remove_media', self._page_key, all_hashes )
-                        
+                    HG.client_controller.pub( 'remove_media', self._page_key, all_hashes )
                     
                 
             
-            CanvasMediaList._Close( self )
-            
+        
+        return CanvasMediaList.TryToDoPreClose( self )
         
     
     def _Delete( self, media = None, reason = None, file_service_key = None ):
@@ -4196,8 +4197,14 @@ class CanvasMediaListFilterArchiveDelete( CanvasMediaList ):
         
         self._deleted.add( self._current_media )
         
-        if self._current_media == self._GetLast(): self._Close()
-        else: self._ShowNext()
+        if self._current_media == self._GetLast():
+            
+            self._TryToCloseWindow()
+            
+        else:
+            
+            self._ShowNext()
+            
         
         return True
         
@@ -4211,15 +4218,21 @@ class CanvasMediaListFilterArchiveDelete( CanvasMediaList ):
         
         self._kept.add( self._current_media )
         
-        if self._current_media == self._GetLast(): self._Close()
-        else: self._ShowNext()
+        if self._current_media == self._GetLast():
+            
+            self._TryToCloseWindow()
+            
+        else:
+            
+            self._ShowNext()
+            
         
     
     def _Skip( self ):
         
         if self._current_media == self._GetLast():
             
-            self._Close()
+            self._TryToCloseWindow()
             
         else:
             
@@ -4330,7 +4343,7 @@ class CanvasMediaListFilterArchiveDelete( CanvasMediaList ):
             
             if key in ( QC.Qt.Key_Enter, QC.Qt.Key_Return, QC.Qt.Key_Escape ):
                 
-                self._Close()
+                self._TryToCloseWindow()
                 
             else:
                 
@@ -4377,7 +4390,7 @@ class CanvasMediaListFilterArchiveDelete( CanvasMediaList ):
                 
             elif action == 'launch_the_archive_delete_filter':
                 
-                self._Close()
+                self._TryToCloseWindow()
                 
             else:
                 
@@ -4563,8 +4576,8 @@ class CanvasMediaListBrowser( CanvasMediaListNavigable ):
         self._timer_slideshow_job = None
         self._timer_slideshow_interval = 0
         
-        self._widget_event_filter.EVT_LEFT_DCLICK( self.EventClose )
-        self._widget_event_filter.EVT_MIDDLE_DOWN( self.EventClose )
+        self._widget_event_filter.EVT_LEFT_DCLICK( self.EventMouseClose )
+        self._widget_event_filter.EVT_MIDDLE_DOWN( self.EventMouseClose )
         
         if first_hash is None:
             
@@ -4587,6 +4600,11 @@ class CanvasMediaListBrowser( CanvasMediaListNavigable ):
         HG.client_controller.sub( self, 'AddMediaResults', 'add_media_results' )
         
     
+    def EventMouseClose( self, event ):
+        
+        self._TryToCloseWindow()
+        
+    
     def _PausePlaySlideshow( self ):
         
         if self._timer_slideshow_job is not None:
@@ -4855,7 +4873,10 @@ class CanvasMediaListBrowser( CanvasMediaListNavigable ):
             if modifier == QC.Qt.NoModifier and key in CC.DELETE_KEYS: self._Delete()
             elif modifier == QC.Qt.ShiftModifier and key in CC.DELETE_KEYS: self._Undelete()
             elif modifier == QC.Qt.NoModifier and key in ( QC.Qt.Key_Space, ): self._PausePlaySlideshow()
-            elif key in ( QC.Qt.Key_Enter, QC.Qt.Key_Return, QC.Qt.Key_Escape ): self._Close()
+            elif key in ( QC.Qt.Key_Enter, QC.Qt.Key_Return, QC.Qt.Key_Escape ):
+                
+                self._TryToCloseWindow()
+                
             else:
                 
                 CanvasMediaListNavigable.keyPressEvent( self, event )
@@ -4907,7 +4928,7 @@ class MediaContainer( QW.QWidget ):
         QW.QWidget.__init__( self, parent )
         
         # If I do not set this, macOS goes 100% CPU endless repaint events!
-        # My guess is it is due to the borked layout
+        # My guess is it due to the borked layout
         self.setAttribute( QC.Qt.WA_OpaquePaintEvent, True )
         
         self._media = None
diff --git a/include/ClientGUICommon.py b/include/ClientGUICommon.py
index e8dab686..a8356511 100755
--- a/include/ClientGUICommon.py
+++ b/include/ClientGUICommon.py
@@ -930,6 +930,7 @@ class ExportPatternButton( BetterButton ):
         
         ClientGUIMenus.AppendSeparator( menu )
         
+        ClientGUIMenus.AppendMenuItem( menu, 'unique numerical file id - {file_id}', 'copy "{file_id}" to the clipboard', HG.client_controller.pub, 'clipboard', 'text', '{file_id}' )
         ClientGUIMenus.AppendMenuItem( menu, 'the file\'s hash - {hash}', 'copy "{hash}" to the clipboard', HG.client_controller.pub, 'clipboard', 'text', '{hash}' )
         ClientGUIMenus.AppendMenuItem( menu, 'all the file\'s tags - {tags}', 'copy "{tags}" to the clipboard', HG.client_controller.pub, 'clipboard', 'text', '{tags}' )
         ClientGUIMenus.AppendMenuItem( menu, 'all the file\'s non-namespaced tags - {nn tags}', 'copy "{nn tags}" to the clipboard', HG.client_controller.pub, 'clipboard', 'text', '{nn tags}' )
diff --git a/include/ClientGUIControls.py b/include/ClientGUIControls.py
index 4b1b9e8b..10f40063 100644
--- a/include/ClientGUIControls.py
+++ b/include/ClientGUIControls.py
@@ -649,7 +649,7 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             
             self._transformation_type = ClientGUICommon.BetterChoice( self )
             
-            for t_type in ( ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_PREPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_APPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_ENCODE, ClientParsing.STRING_TRANSFORMATION_DECODE, ClientParsing.STRING_TRANSFORMATION_REVERSE, ClientParsing.STRING_TRANSFORMATION_REGEX_SUB, ClientParsing.STRING_TRANSFORMATION_DATE_DECODE, ClientParsing.STRING_TRANSFORMATION_INTEGER_ADDITION ):
+            for t_type in ( ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_PREPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_APPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_ENCODE, ClientParsing.STRING_TRANSFORMATION_DECODE, ClientParsing.STRING_TRANSFORMATION_REVERSE, ClientParsing.STRING_TRANSFORMATION_REGEX_SUB, ClientParsing.STRING_TRANSFORMATION_DATE_DECODE, ClientParsing.STRING_TRANSFORMATION_DATE_ENCODE, ClientParsing.STRING_TRANSFORMATION_INTEGER_ADDITION ):
                 
                 self._transformation_type.addItem( ClientParsing.transformation_type_str_lookup[ t_type], t_type )
                 
@@ -660,7 +660,8 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             self._data_regex_pattern = QW.QLineEdit( self )
             self._data_regex_repl = QW.QLineEdit( self )
             self._data_date_link = ClientGUICommon.BetterHyperLink( self, 'link to date info', 'https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior' )
-            self._data_timezone = ClientGUICommon.BetterChoice( self )
+            self._data_timezone_decode = ClientGUICommon.BetterChoice( self )
+            self._data_timezone_encode = ClientGUICommon.BetterChoice( self )
             self._data_timezone_offset = QP.MakeQSpinBox( self, min=-86400, max=86400 )
             
             for e in ( 'hex', 'base64' ):
@@ -668,9 +669,12 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
                 self._data_encoding.addItem( e, e )
                 
             
-            self._data_timezone.addItem( 'GMT', HC.TIMEZONE_GMT )
-            self._data_timezone.addItem( 'Local', HC.TIMEZONE_LOCAL )
-            self._data_timezone.addItem( 'Offset', HC.TIMEZONE_OFFSET )
+            self._data_timezone_decode.addItem( 'UTC', HC.TIMEZONE_GMT )
+            self._data_timezone_decode.addItem( 'Local', HC.TIMEZONE_LOCAL )
+            self._data_timezone_decode.addItem( 'Offset', HC.TIMEZONE_OFFSET )
+            
+            self._data_timezone_encode.addItem( 'UTC', HC.TIMEZONE_GMT )
+            self._data_timezone_encode.addItem( 'Local', HC.TIMEZONE_LOCAL )
             
             #
             
@@ -696,9 +700,16 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
                 ( phrase, timezone_type, timezone_offset ) = data
                 
                 self._data_text.setText( phrase )
-                self._data_timezone.SetValue( timezone_type )
+                self._data_timezone_decode.SetValue( timezone_type )
                 self._data_timezone_offset.setValue( timezone_offset )
                 
+            elif transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_ENCODE:
+                
+                ( phrase, timezone_type ) = data
+                
+                self._data_text.setText( phrase )
+                self._data_timezone_encode.SetValue( timezone_type )
+                
             elif data is not None:
                 
                 if isinstance( data, int ):
@@ -721,8 +732,9 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             rows.append( ( 'regex pattern: ', self._data_regex_pattern ) )
             rows.append( ( 'regex replacement: ', self._data_regex_repl ) )
             rows.append( ( 'date info: ', self._data_date_link ) )
-            rows.append( ( 'date timezone: ', self._data_timezone ) )
+            rows.append( ( 'date decode timezone: ', self._data_timezone_decode ) )
             rows.append( ( 'timezone offset: ', self._data_timezone_offset ) )
+            rows.append( ( 'date encode timezone: ', self._data_timezone_encode ) )
             
             gridbox = ClientGUICommon.WrapInGrid( self, rows )
             
@@ -737,7 +749,8 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             
             self._transformation_type.currentIndexChanged.connect( self._UpdateDataControls )
             self._data_encoding.currentIndexChanged.connect( self._UpdateDataControls )
-            self._data_timezone.currentIndexChanged.connect( self._UpdateDataControls )
+            self._data_timezone_decode.currentIndexChanged.connect( self._UpdateDataControls )
+            self._data_timezone_encode.currentIndexChanged.connect( self._UpdateDataControls )
             
         
         def _UpdateDataControls( self ):
@@ -747,8 +760,9 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             self._data_encoding.setEnabled( False )
             self._data_regex_pattern.setEnabled( False )
             self._data_regex_repl.setEnabled( False )
-            self._data_timezone.setEnabled( False )
+            self._data_timezone_decode.setEnabled( False )
             self._data_timezone_offset.setEnabled( False )
+            self._data_timezone_encode.setEnabled( False )
             
             transformation_type = self._transformation_type.GetValue()
             
@@ -756,19 +770,23 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
                 
                 self._data_encoding.setEnabled( True )
                 
-            elif transformation_type in ( ClientParsing.STRING_TRANSFORMATION_PREPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_APPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_DATE_DECODE ):
+            elif transformation_type in ( ClientParsing.STRING_TRANSFORMATION_PREPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_APPEND_TEXT, ClientParsing.STRING_TRANSFORMATION_DATE_DECODE, ClientParsing.STRING_TRANSFORMATION_DATE_ENCODE ):
                 
                 self._data_text.setEnabled( True )
                 
                 if transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_DECODE:
                     
-                    self._data_timezone.setEnabled( True )
+                    self._data_timezone_decode.setEnabled( True )
                     
-                    if self._data_timezone.GetValue() == HC.TIMEZONE_OFFSET:
+                    if self._data_timezone_decode.GetValue() == HC.TIMEZONE_OFFSET:
                         
                         self._data_timezone_offset.setEnabled( True )
                         
                     
+                elif transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_ENCODE:
+                    
+                    self._data_timezone_encode.setEnabled( True )
+                    
                 
             elif transformation_type in ( ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_INTEGER_ADDITION ):
                 
@@ -816,11 +834,18 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             elif transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_DECODE:
                 
                 phrase = self._data_text.text()
-                timezone_time = self._data_timezone.GetValue()
+                timezone_time = self._data_timezone_decode.GetValue()
                 timezone_offset = self._data_timezone_offset.value()
                 
                 data = ( phrase, timezone_time, timezone_offset )
                 
+            elif transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_ENCODE:
+                
+                phrase = self._data_text.text()
+                timezone_time = self._data_timezone_encode.GetValue()
+                
+                data = ( phrase, timezone_time )
+                
             else:
                 
                 data = None
diff --git a/include/ClientGUIDialogs.py b/include/ClientGUIDialogs.py
index a8b97872..c3e36461 100755
--- a/include/ClientGUIDialogs.py
+++ b/include/ClientGUIDialogs.py
@@ -102,6 +102,10 @@ class Dialog( QP.Dialog ):
 
         QP.Dialog.__init__( self, parent )
         
+        self.setWindowFlags( style )
+        
+        self.setWindowTitle( title )
+        
         if parent is not None and position == 'topleft':
             
             parent_tlp = self.parentWidget().window()                
@@ -115,9 +119,6 @@ class Dialog( QP.Dialog ):
             pos = None
             
         
-        self.setWindowTitle( title )
-        self.setWindowFlags( style )
-        
         if pos: self.move( pos )
         
         self.setWindowFlag( QC.Qt.WindowContextHelpButtonHint, on = False )
@@ -193,9 +194,9 @@ class DialogChooseNewServiceMethod( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         self._should_register = False
         
@@ -281,9 +282,9 @@ class DialogGenerateNewAccounts( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._ok.setFocus, QC.Qt.OtherFocusReason )
         
@@ -437,11 +438,11 @@ class DialogInputLocalBooruShare( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 350 )
+        size_hint.setWidth( max( size_hint.width(), 350 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._ok.setFocus, QC.Qt.OtherFocusReason)
         
@@ -550,9 +551,9 @@ class DialogInputNamespaceRegex( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._ok.setFocus, QC.Qt.OtherFocusReason)
         
@@ -640,11 +641,11 @@ class DialogInputTags( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 300 )
+        size_hint.setWidth( max( size_hint.width(), 300 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._tag_box.setFocus, QC.Qt.OtherFocusReason)
         
@@ -736,9 +737,9 @@ class DialogInputUPnPMapping( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._ok.setFocus, QC.Qt.OtherFocusReason)
         
@@ -889,9 +890,9 @@ class DialogModifyAccounts( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( self._exit.setFocus, QC.Qt.OtherFocusReason)
         
@@ -1012,12 +1013,12 @@ class DialogSelectFromURLTree( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 640 )
-        y = max( y, 640 )
+        size_hint.setWidth( max( size_hint.width(), 640 ) )
+        size_hint.setHeight( max( size_hint.height(), 640 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
     
     def _AddDirectory( self, root, children ):
@@ -1129,16 +1130,16 @@ class DialogSelectImageboard( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        if x < 320: x = 320
-        if y < 640: y = 640
+        size_hint.setWidth( max( size_hint.width(), 320 ) )
+        size_hint.setHeight( max( size_hint.height(), 640 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
     
     def EventActivate( self, item, column ):
-                
+        
         data_object = item.data( 0, QC.Qt.UserRole )
         
         if data_object is None: item.setExpanded( not item.isExpanded() )
@@ -1228,11 +1229,11 @@ class DialogTextEntry( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 250 )
+        size_hint.setWidth( max( size_hint.width(), 250 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
     
     def _CheckText( self ):
@@ -1329,11 +1330,11 @@ class DialogYesYesNo( Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 250 )
+        size_hint.setWidth( max( size_hint.width(), 250 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         QP.CallAfter( yes_buttons[0].setFocus, QC.Qt.OtherFocusReason )
         
diff --git a/include/ClientGUIDialogsManage.py b/include/ClientGUIDialogsManage.py
index 0670ec5a..fe943b62 100644
--- a/include/ClientGUIDialogsManage.py
+++ b/include/ClientGUIDialogsManage.py
@@ -111,9 +111,9 @@ class DialogManageRatings( ClientGUIDialogs.Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         #
         
@@ -354,11 +354,11 @@ class DialogManageUPnP( ClientGUIDialogs.Dialog ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        x = max( x, 760 )
+        size_hint.setWidth( max( size_hint.width(), 760 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         #
         
diff --git a/include/ClientGUIDialogsQuick.py b/include/ClientGUIDialogsQuick.py
index a895b538..66d15bb7 100644
--- a/include/ClientGUIDialogsQuick.py
+++ b/include/ClientGUIDialogsQuick.py
@@ -42,7 +42,9 @@ def GetFinishFilteringAnswer( win, label ):
         
         dlg.SetPanel( panel )
         
-        return ( dlg.exec(), dlg.WasCancelled() )
+        result = ( dlg.exec(), dlg.WasCancelled() )
+        
+        return result
         
     
 def GetInterstitialFilteringAnswer( win, label ):
@@ -53,7 +55,9 @@ def GetInterstitialFilteringAnswer( win, label ):
         
         dlg.SetPanel( panel )
         
-        return dlg.exec()
+        result = dlg.exec()
+        
+        return result
         
     
 def GetYesNo( win, message, title = 'Are you sure?', yes_label = 'yes', no_label = 'no', auto_yes_time = None, auto_no_time = None, check_for_cancelled = False ):
diff --git a/include/ClientGUIExport.py b/include/ClientGUIExport.py
index 1aea5435..6d41e604 100644
--- a/include/ClientGUIExport.py
+++ b/include/ClientGUIExport.py
@@ -396,7 +396,7 @@ If you select synchronise, be careful!'''
         run_regularly = self._run_regularly.isChecked()
         
         period = self._period.GetValue()
-               
+        
         if self._path.GetPath() in ( '', None ):
             
             raise HydrusExceptions.VetoException( 'You must enter a folder path to export to!' )
diff --git a/include/ClientGUIFrames.py b/include/ClientGUIFrames.py
index add5c028..4d9198d9 100644
--- a/include/ClientGUIFrames.py
+++ b/include/ClientGUIFrames.py
@@ -52,12 +52,12 @@ class ShowKeys( ClientGUITopLevelWindows.Frame ):
         
         self.setLayout( vbox )
         
-        ( x, y ) = QP.GetEffectiveMinSize( self )
+        size_hint = self.sizeHint()
         
-        if x < 500: x = 500
-        if y < 200: y = 200
+        size_hint.setWidth( max( size_hint.width(), 500 ) )
+        size_hint.setHeight( max( size_hint.height(), 200 ) )
         
-        QP.SetInitialSize( self, (x,y) )
+        QP.SetInitialSize( self, size_hint )
         
         self.show()
         
diff --git a/include/ClientGUIFunctions.py b/include/ClientGUIFunctions.py
index 98c7a212..80bcf5f8 100644
--- a/include/ClientGUIFunctions.py
+++ b/include/ClientGUIFunctions.py
@@ -355,9 +355,9 @@ def IsQtAncestor( child, ancestor, through_tlws = False ):
     
 def NotebookScreenToHitTest( notebook, screen_position ):
     
-    position = notebook.mapFromGlobal( screen_position )    
+    tab_pos = notebook.tabBar().mapFromGlobal( screen_position )    
     
-    return notebook.tabBar().tabAt( position )
+    return notebook.tabBar().tabAt( tab_pos )
     
 def SetBitmapButtonBitmap( button, bitmap ):
     
diff --git a/include/ClientGUIHoverFrames.py b/include/ClientGUIHoverFrames.py
index c4890f26..2f932a17 100644
--- a/include/ClientGUIHoverFrames.py
+++ b/include/ClientGUIHoverFrames.py
@@ -28,11 +28,13 @@ class FullscreenHoverFrame( QW.QFrame ):
         QW.QFrame.__init__( self, parent )
         
         self.setWindowFlags( QC.Qt.FramelessWindowHint | QC.Qt.Tool )
-        self.setFrameStyle( QW.QFrame.Panel | QW.QFrame.Raised )
-        self.setLineWidth( 2 )
+        
         self.setAttribute( QC.Qt.WA_ShowWithoutActivating )
         self.setAttribute( QC.Qt.WA_DeleteOnClose )
         
+        self.setFrameStyle( QW.QFrame.Panel | QW.QFrame.Raised )
+        self.setLineWidth( 2 )
+        
         self._my_canvas = my_canvas
         self._canvas_key = canvas_key
         self._current_media = None
@@ -1163,7 +1165,7 @@ class FullscreenHoverFrameTopRight( FullscreenHoverFrame ):
                 
                 self._last_seen_urls = list( urls )
                 
-                QP.ClearLayout( self._urls_vbox, delete_widgets=True )
+                QP.ClearLayout( self._urls_vbox, delete_widgets = True )
                 
                 url_tuples = HG.client_controller.network_engine.domain_manager.ConvertURLsToMediaViewerTuples( urls )
                 
@@ -1172,7 +1174,10 @@ class FullscreenHoverFrameTopRight( FullscreenHoverFrame ):
                     link = ClientGUICommon.BetterHyperLink( self, display_string, url )
                     
                     QP.AddToLayout( self._urls_vbox, link, CC.FLAGS_EXPAND_PERPENDICULAR )
+                    
                     self.layout().addStretch( 1 )
+                    
+                
             
         
         self._SizeAndPosition()
@@ -1180,7 +1185,7 @@ class FullscreenHoverFrameTopRight( FullscreenHoverFrame ):
     
     def wheelEvent( self, event ):
         
-        QW.QApplication.sendEvent(self.parentWidget(), event)
+        QW.QApplication.sendEvent( self.parentWidget(), event )
         
     
     def ProcessContentUpdates( self, service_keys_to_content_updates ):
diff --git a/include/ClientGUIListBoxes.py b/include/ClientGUIListBoxes.py
index 70c4c22c..ad84f294 100644
--- a/include/ClientGUIListBoxes.py
+++ b/include/ClientGUIListBoxes.py
@@ -1278,13 +1278,13 @@ class ListBox( QW.QScrollArea ):
                 
                 ( x, y ) = ( x_start, current_index * text_height )
                 
-                ( text_width, text_height ) = painter.fontMetrics().size( QC.Qt.TextSingleLine, text ).toTuple()
+                ( this_text_width, this_text_height ) = painter.fontMetrics().size( QC.Qt.TextSingleLine, text ).toTuple()
                 
-                painter.drawText( QC.QRectF( x, y, text_width, text_height ), text )
+                painter.drawText( QC.QRectF( x, y, this_text_width, this_text_height ), text )
                 
                 if there_is_more_than_one_text:
                     
-                    x_start += text_width
+                    x_start += this_text_width
                     
                 
             
diff --git a/include/ClientGUIListCtrl.py b/include/ClientGUIListCtrl.py
index 0c987cf9..6e00d1e6 100644
--- a/include/ClientGUIListCtrl.py
+++ b/include/ClientGUIListCtrl.py
@@ -22,7 +22,6 @@ def SafeNoneInt( value ):
 def SafeNoneStr( value ):
     
     return '' if value is None else value
-           
     
 class BetterListCtrl( QW.QTreeWidget ):
     
@@ -74,8 +73,10 @@ class BetterListCtrl( QW.QTreeWidget ):
                 
             
             self.headerItem().setText( i, name )
+            
             self.setColumnWidth( i, width )
             
+        
         # Technically this is the previous behavior, but the two commented lines might work better in some cases (?)
         self.header().setStretchLastSection( False )
         self.header().setSectionResizeMode( resize_column - 1 , QW.QHeaderView.Stretch )
@@ -110,8 +111,17 @@ class BetterListCtrl( QW.QTreeWidget ):
         
         for i in range( len( display_tuple ) ):
             
-            append_item.setText( i, display_tuple[i] )
+            text = display_tuple[i]
             
+            if len( text ) > 0:
+                
+                text = text.splitlines()[0]
+                
+            
+            append_item.setText( i, text )
+            append_item.setToolTip( i, text )
+            
+        
         self.addTopLevelItem( append_item )
         
         index = self.topLevelItemCount() - 1 
@@ -241,11 +251,19 @@ class BetterListCtrl( QW.QTreeWidget ):
         
         for ( column_index, value ) in enumerate( display_tuple ):
             
-            existing_value = self.topLevelItem( index ).text( column_index )
+            if len( value ) > 0:
+                
+                value = value.splitlines()[0]
+                
+            
+            tree_widget_item = self.topLevelItem( index )
+            
+            existing_value = tree_widget_item.text( column_index )
             
             if existing_value != value:
                 
-                self.topLevelItem( index ).setText( column_index, value )
+                tree_widget_item.setText( column_index, value )
+                tree_widget_item.setToolTip( column_index, value )
                 
             
         
diff --git a/include/ClientGUIPages.py b/include/ClientGUIPages.py
index 5fd06568..e74cbccb 100755
--- a/include/ClientGUIPages.py
+++ b/include/ClientGUIPages.py
@@ -1780,12 +1780,16 @@ class PagesNotebook( QP.TabWidgetWithDnD ):
         
         position = event.pos()
         
-        tab_index = self.tabBar().tabAt( position )
+        screen_pos = self.mapToGlobal( position )
+        
+        tab_pos = self.tabBar().mapFromGlobal( screen_pos )
+        
+        tab_index = self.tabBar().tabAt( tab_pos )
         
         if tab_index == -1:
             
             self.ChooseNewPage()
-                
+            
         else:
             
             return True # was: event.ignore()
@@ -1815,7 +1819,11 @@ class PagesNotebook( QP.TabWidgetWithDnD ):
         
         position = event.pos()
         
-        tab_index = self.tabBar().tabAt( position )
+        screen_pos = self.mapToGlobal( position )
+        
+        tab_pos = self.tabBar().mapFromGlobal( screen_pos )
+        
+        tab_index = self.tabBar().tabAt( tab_pos )
         
         if tab_index == -1:
             
diff --git a/include/ClientGUIPanels.py b/include/ClientGUIPanels.py
index 265748da..f160c45b 100644
--- a/include/ClientGUIPanels.py
+++ b/include/ClientGUIPanels.py
@@ -834,8 +834,15 @@ class ReviewServicePanel( QW.QWidget ):
             self._address = ClientGUICommon.BetterStaticText( self )
             self._functional = ClientGUICommon.BetterStaticText( self )
             self._bandwidth_summary = ClientGUICommon.BetterStaticText( self )
+            
             self._bandwidth_panel = QW.QWidget( self )
             
+            vbox = QP.VBoxLayout()
+            
+            self._bandwidth_panel.setLayout( vbox )
+            
+            self._rule_widgets = []
+            
             #
             
             self._Refresh()
@@ -871,24 +878,29 @@ class ReviewServicePanel( QW.QWidget ):
             
             self._bandwidth_summary.setText( bandwidth_summary )
             
-            QP.DestroyChildren( self._bandwidth_panel )
+            vbox = self._bandwidth_panel.layout()
             
-            b_gauges = []
+            for rule_widget in self._rule_widgets:
+                
+                vbox.removeWidget( rule_widget )
+                
+                rule_widget.deleteLater()
+                
+            
+            self._rule_widgets = []
             
             bandwidth_rows = self._service.GetBandwidthStringsAndGaugeTuples()
             
-            b_vbox = QP.VBoxLayout()
-            
             for ( status, ( value, range ) ) in bandwidth_rows:
                 
                 gauge = ClientGUICommon.TextAndGauge( self._bandwidth_panel )
                 
                 gauge.SetValue( status, value, range )
                 
-                QP.AddToLayout( b_vbox, gauge, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR )
+                self._rule_widgets.append( gauge )
+                
+                QP.AddToLayout( vbox, gauge, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR )
                 
-            
-            self._bandwidth_panel.setLayout( b_vbox )
             
         
         def ServiceUpdated( self, service ):
@@ -916,8 +928,15 @@ class ReviewServicePanel( QW.QWidget ):
             self._status_st = ClientGUICommon.BetterStaticText( self )
             self._next_sync_st = ClientGUICommon.BetterStaticText( self )
             self._bandwidth_summary = ClientGUICommon.BetterStaticText( self )
+            
             self._bandwidth_panel = QW.QWidget( self )
             
+            vbox = QP.VBoxLayout()
+            
+            self._bandwidth_panel.setLayout( vbox )
+            
+            self._rule_widgets = []
+            
             self._refresh_account_button = ClientGUICommon.BetterButton( self, 'refresh account', self._RefreshAccount )
             self._copy_account_key_button = ClientGUICommon.BetterButton( self, 'copy account key', self._CopyAccountKey )
             self._permissions_button = ClientGUICommon.MenuButton( self, 'see special permissions', [] )
@@ -986,24 +1005,29 @@ class ReviewServicePanel( QW.QWidget ):
             
             self._bandwidth_summary.setText( bandwidth_summary )
             
-            QP.DestroyChildren( self._bandwidth_panel )
+            vbox = self._bandwidth_panel.layout()
             
-            b_gauges = []
+            for rule_widget in self._rule_widgets:
+                
+                vbox.removeWidget( rule_widget )
+                
+                rule_widget.deleteLater()
+                
+            
+            self._rule_widgets = []
             
             bandwidth_rows = account.GetBandwidthStringsAndGaugeTuples()
             
-            b_vbox = QP.VBoxLayout()
-            
             for ( status, ( value, range ) ) in bandwidth_rows:
                 
                 gauge = ClientGUICommon.TextAndGauge( self._bandwidth_panel )
                 
                 gauge.SetValue( status, value, range )
                 
-                QP.AddToLayout( b_vbox, gauge, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR )
+                self._rule_widgets.append( gauge )
+                
+                QP.AddToLayout( vbox, gauge, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR )
                 
-            
-            self._bandwidth_panel.setLayout( b_vbox )
             
             #
             
diff --git a/include/ClientGUIParsing.py b/include/ClientGUIParsing.py
index b3c0e25a..2f8c3b99 100644
--- a/include/ClientGUIParsing.py
+++ b/include/ClientGUIParsing.py
@@ -636,7 +636,7 @@ class EditCompoundFormulaPanel( ClientGUIScrolledPanels.EditPanel ):
         
         with ClientGUITopLevelWindows.DialogEdit( self, 'edit formula', frame_key = 'deeply_nested_dialog' ) as dlg:
             
-            panel = EditFormulaPanel( dlg, existing_formula, self._test_panel.GetTestContext )
+            panel = EditFormulaPanel( dlg, existing_formula, self._test_panel.GetTestContextForChild )
             
             dlg.SetPanel( panel )
             
@@ -681,7 +681,7 @@ class EditCompoundFormulaPanel( ClientGUIScrolledPanels.EditPanel ):
             
             with ClientGUITopLevelWindows.DialogEdit( self, 'edit formula', frame_key = 'deeply_nested_dialog' ) as dlg:
                 
-                panel = EditFormulaPanel( dlg, old_formula, self._test_panel.GetTestContext )
+                panel = EditFormulaPanel( dlg, old_formula, self._test_panel.GetTestContextForChild )
                 
                 dlg.SetPanel( panel )
                 
@@ -1823,6 +1823,14 @@ class EditContentParserPanel( ClientGUIScrolledPanels.EditPanel ):
         
         #
         
+        test_panel = ClientGUICommon.StaticBox( self, 'test' )
+        
+        QP.SetBackgroundColour( test_panel, QP.GetSystemColour( QG.QPalette.Button ) )
+        
+        self._test_panel = TestPanel( test_panel, self.GetValue, test_context = test_context )
+        
+        #
+        
         self._edit_panel = ClientGUICommon.StaticBox( self, 'edit' )
         
         QP.SetBackgroundColour( self._edit_panel, QP.GetSystemColour( QG.QPalette.Button ) )
@@ -1909,15 +1917,7 @@ class EditContentParserPanel( ClientGUIScrolledPanels.EditPanel ):
         
         ( name, content_type, formula, sort_type, sort_asc, additional_info ) = content_parser.ToTuple()
         
-        self._formula = EditFormulaPanel( self._edit_panel, formula, self.GetTestContext )
-        
-        #
-        
-        test_panel = ClientGUICommon.StaticBox( self, 'test' )
-        
-        QP.SetBackgroundColour( test_panel, QP.GetSystemColour( QG.QPalette.Button ) )
-        
-        self._test_panel = TestPanel( test_panel, self.GetValue, test_context = test_context )
+        self._formula = EditFormulaPanel( self._edit_panel, formula, self._test_panel.GetTestContextForChild )
         
         #
         
@@ -2164,11 +2164,6 @@ class EditContentParserPanel( ClientGUIScrolledPanels.EditPanel ):
             
         
     
-    def GetTestContext( self ):
-        
-        return self._test_panel.GetTestContext()
-        
-    
     def GetValue( self ):
         
         name = self._name.text()
@@ -2965,19 +2960,6 @@ class EditPageParserPanel( ClientGUIScrolledPanels.EditPanel ):
         
         #
         
-        
-        content_parsers_panel = QW.QWidget( edit_notebook )
-        
-        QP.SetBackgroundColour( content_parsers_panel, QP.GetSystemColour( QG.QPalette.Button ) )
-        
-        #
-        
-        permitted_content_types = [ HC.CONTENT_TYPE_URLS, HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_TYPE_HASH, HC.CONTENT_TYPE_TIMESTAMP, HC.CONTENT_TYPE_TITLE, HC.CONTENT_TYPE_VETO ]
-        
-        self._content_parsers = EditContentParsersPanel( content_parsers_panel, self.GetTestContext, permitted_content_types )
-        
-        #
-        
         test_panel = ClientGUICommon.StaticBox( self, 'test' )
         
         QP.SetBackgroundColour( test_panel, QP.GetSystemColour( QG.QPalette.Button ) )
@@ -2998,6 +2980,18 @@ class EditPageParserPanel( ClientGUIScrolledPanels.EditPanel ):
             self._test_panel = TestPanelPageParserSubsidiary( test_panel, self.GetValue, self._string_converter.GetValue, self.GetFormula, test_context = test_context )
             
         
+        #
+        
+        content_parsers_panel = QW.QWidget( edit_notebook )
+        
+        QP.SetBackgroundColour( content_parsers_panel, QP.GetSystemColour( QG.QPalette.Button ) )
+        
+        #
+        
+        permitted_content_types = [ HC.CONTENT_TYPE_URLS, HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_TYPE_HASH, HC.CONTENT_TYPE_TIMESTAMP, HC.CONTENT_TYPE_TITLE, HC.CONTENT_TYPE_VETO ]
+        
+        self._content_parsers = EditContentParsersPanel( content_parsers_panel, self._test_panel.GetTestContextForChild, permitted_content_types )
+        
         #
         
         name = parser.GetName()
@@ -3139,7 +3133,7 @@ class EditPageParserPanel( ClientGUIScrolledPanels.EditPanel ):
         
         with ClientGUITopLevelWindows.DialogEdit( self, 'edit sub page parser', frame_key = 'deeply_nested_dialog' ) as dlg:
             
-            panel = EditPageParserPanel( dlg, page_parser, formula = formula, test_context = self._test_panel.GetTestContext() )
+            panel = EditPageParserPanel( dlg, page_parser, formula = formula, test_context = self._test_panel.GetTestContextForChild() )
             
             dlg.SetPanel( panel )
             
@@ -3207,7 +3201,7 @@ class EditPageParserPanel( ClientGUIScrolledPanels.EditPanel ):
             
             with ClientGUITopLevelWindows.DialogEdit( self, 'edit sub page parser', frame_key = 'deeply_nested_dialog' ) as dlg:
                 
-                panel = EditPageParserPanel( dlg, page_parser, formula = formula, test_context = self._test_panel.GetTestContext() )
+                panel = EditPageParserPanel( dlg, page_parser, formula = formula, test_context = self._test_panel.GetTestContextForChild() )
                 
                 dlg.SetPanel( panel )
                 
@@ -3294,11 +3288,6 @@ class EditPageParserPanel( ClientGUIScrolledPanels.EditPanel ):
         HG.client_controller.CallToThread( wait_and_do_it, network_job )
         
     
-    def GetTestContext( self ):
-        
-        return self._test_panel.GetTestContext()
-        
-    
     def GetFormula( self ):
         
         return self._formula.GetValue()
@@ -4503,6 +4492,11 @@ class TestPanel( QW.QWidget ):
         return ( example_parsing_context, self._example_data_raw )
         
     
+    def GetTestContextForChild( self ):
+        
+        return self.GetTestContext()
+        
+    
     def SetExampleData( self, example_data ):
         
         self._SetExampleData( example_data )
@@ -4662,7 +4656,7 @@ class TestPanelPageParser( TestPanel ):
         self._example_data_post_conversion_preview.setPlainText( preview )
         
     
-    def GetTestContext( self ):
+    def GetTestContextForChild( self ):
         
         example_parsing_context = self._example_parsing_context.GetValue()
         
@@ -4775,7 +4769,7 @@ class TestPanelPageParserSubsidiary( TestPanelPageParser ):
         self._example_data_post_separation_preview.setPlainText( preview )
         
     
-    def GetTestContext( self ):
+    def GetTestContextForChild( self ):
         
         example_parsing_context = self._example_parsing_context.GetValue()
         
@@ -4801,15 +4795,15 @@ class TestPanelPageParserSubsidiary( TestPanelPageParser ):
         
         try:
             
-            example_parsing_context = self._example_parsing_context.GetValue()
+            ( example_parsing_context, example_data ) = self.GetTestContext()
             
             if formula is None:
                 
-                posts = [ self._example_data_raw ]
+                posts = [ example_data ]
                 
             else:
                 
-                posts = formula.Parse( example_parsing_context, self._example_data_raw )
+                posts = formula.Parse( example_parsing_context, example_data )
                 
             
             pretty_texts = []
diff --git a/include/ClientGUIPopupMessages.py b/include/ClientGUIPopupMessages.py
index 2487753f..a7cd4dd9 100644
--- a/include/ClientGUIPopupMessages.py
+++ b/include/ClientGUIPopupMessages.py
@@ -536,9 +536,11 @@ class PopupMessageManager( QW.QWidget ):
         QW.QWidget.__init__( self, parent )
         
         self.setWindowFlags( QC.Qt.Tool | QC.Qt.FramelessWindowHint )
-        self.setSizePolicy( QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Preferred )
+        
         self.setAttribute( QC.Qt.WA_ShowWithoutActivating )
         
+        self.setSizePolicy( QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Preferred )
+        
         QP.SetBackgroundColour( self, QP.GetSystemColour( QG.QPalette.Button ) )
         
         self._last_best_size_i_fit_on = ( 0, 0 )
@@ -711,25 +713,32 @@ class PopupMessageManager( QW.QWidget ):
         
         try:
             
-            parent = self.parentWidget()
+            gui_frame = self.parentWidget()
             
-            possibly_on_hidden_virtual_desktop = not ClientGUITopLevelWindows.MouseIsOnMyDisplay( parent )
+            possibly_on_hidden_virtual_desktop = not ClientGUITopLevelWindows.MouseIsOnMyDisplay( gui_frame )
             
             going_to_bug_out_at_hide_or_show = possibly_on_hidden_virtual_desktop
             
             current_focus_tlp = QW.QApplication.activeWindow()
             
-            main_gui_is_active = current_focus_tlp in ( self, parent )
+            main_gui_is_active = current_focus_tlp in ( self, gui_frame )
             
             on_top_frame_is_active = False
             
-            if not main_gui_is_active:
+            if not main_gui_is_active and current_focus_tlp is not None:
                 
-                c_f_tlp_is_child_frame_of_main_gui = current_focus_tlp is not None and current_focus_tlp.parentWidget() == parent
+                c_f_tlp_is_resizing_frame = isinstance( current_focus_tlp, ClientGUITopLevelWindows.FrameThatResizes )
                 
-                if c_f_tlp_is_child_frame_of_main_gui:
+                frame_parent = current_focus_tlp.parentWidget()
+                
+                if c_f_tlp_is_resizing_frame and frame_parent is not None:
                     
-                    on_top_frame_is_active = True
+                    c_f_tlp_is_child_frame_of_main_gui = frame_parent.window() == gui_frame
+                    
+                    if c_f_tlp_is_child_frame_of_main_gui:
+                        
+                        on_top_frame_is_active = True
+                        
                     
                 
             
@@ -739,16 +748,16 @@ class PopupMessageManager( QW.QWidget ):
             
             if there_is_stuff_to_display:
                 
-                ( parent_width, parent_height ) = parent.size().toTuple()
+                ( parent_width, parent_height ) = gui_frame.size().toTuple()
                 
                 ( my_width, my_height ) = self.size().toTuple()
                 
                 my_x = ( parent_width - my_width ) - 20
                 my_y = ( parent_height - my_height ) - 25
                 
-                if parent.isVisible():
+                if gui_frame.isVisible():
                     
-                    my_position = ClientGUIFunctions.ClientToScreen( parent, ( my_x, my_y ) )
+                    my_position = ClientGUIFunctions.ClientToScreen( gui_frame, ( my_x, my_y ) )
                     
                     if my_position != self.pos():
                         
@@ -758,7 +767,7 @@ class PopupMessageManager( QW.QWidget ):
                 
                 # Unhiding tends to raise the main gui tlp, which is annoying if a media viewer window has focus
                 # Qt port note: the on_top_frame_is_active part was uncommented originally, but it IS annoying since it leads to flickering (e.g. open the options window with this uncommented to see it in action)
-                show_is_not_annoying = main_gui_is_active or self._DisplayingError() # or on_top_frame_is_active
+                show_is_not_annoying = main_gui_is_active or self._DisplayingError() or on_top_frame_is_active
                 
                 ok_to_show = show_is_not_annoying and not going_to_bug_out_at_hide_or_show
                 
@@ -783,7 +792,7 @@ class PopupMessageManager( QW.QWidget ):
             
             HydrusData.Print( traceback.format_exc() )
             
-            QW.QMessageBox.critical( HG.client_controller.gui, 'Error', text )
+            QW.QMessageBox.critical( gui_frame, 'Error', text )
             
             self._update_job.Cancel()
             
diff --git a/include/ClientGUIPredicates.py b/include/ClientGUIPredicates.py
index 5e8f977b..cde095ff 100644
--- a/include/ClientGUIPredicates.py
+++ b/include/ClientGUIPredicates.py
@@ -14,6 +14,7 @@ from . import HydrusConstants as HC
 from . import HydrusData
 from . import HydrusGlobals as HG
 from . import HydrusText
+import os
 import re
 import string
 from qtpy import QtCore as QC
@@ -29,6 +30,7 @@ class InputFileSystemPredicate( ClientGUIScrolledPanels.EditPanel ):
         
         self._predicates = []
         
+        label = None
         editable_pred_panel_classes = []
         static_pred_buttons = []
         
@@ -78,6 +80,10 @@ class InputFileSystemPredicate( ClientGUIScrolledPanels.EditPanel ):
             
         elif predicate_type == HC.PREDICATE_TYPE_SYSTEM_LIMIT:
             
+            label = 'Please note that, for now, system:limit generally samples randomly from the full search results.'
+            label += os.linesep
+            label += 'It will not clip the n largest/longest/most tagged files given a particular file sort.'
+            
             static_pred_buttons.append( StaticSystemPredicateButton( self, ( ClientSearch.Predicate( HC.PREDICATE_TYPE_SYSTEM_LIMIT, 64 ), ) ) )
             static_pred_buttons.append( StaticSystemPredicateButton( self, ( ClientSearch.Predicate( HC.PREDICATE_TYPE_SYSTEM_LIMIT, 256 ), ) ) )
             static_pred_buttons.append( StaticSystemPredicateButton( self, ( ClientSearch.Predicate( HC.PREDICATE_TYPE_SYSTEM_LIMIT, 1024 ), ) ) )
@@ -135,6 +141,13 @@ class InputFileSystemPredicate( ClientGUIScrolledPanels.EditPanel ):
         
         vbox = QP.VBoxLayout()
         
+        if label is not None:
+            
+            st = ClientGUICommon.BetterStaticText( self, label = label )
+            
+            QP.AddToLayout( vbox, st, CC.FLAGS_EXPAND_BOTH_WAYS )
+            
+        
         for button in static_pred_buttons:
             
             QP.AddToLayout( vbox, button, CC.FLAGS_EXPAND_PERPENDICULAR )
diff --git a/include/ClientGUIScrolledPanelsButtonQuestions.py b/include/ClientGUIScrolledPanelsButtonQuestions.py
index dc5aa59c..b2ffa1dc 100644
--- a/include/ClientGUIScrolledPanelsButtonQuestions.py
+++ b/include/ClientGUIScrolledPanelsButtonQuestions.py
@@ -50,6 +50,7 @@ class QuestionFinishFilteringPanel( ClientGUIScrolledPanels.ResizingScrolledPane
             
             parent.SetCancelled( True )
             parent.done( QW.QDialog.Rejected )
+            
         
         self._back = ClientGUICommon.BetterButton( self, 'back to filtering', cancel_callback, parent )
         
diff --git a/include/ClientGUIScrolledPanelsEdit.py b/include/ClientGUIScrolledPanelsEdit.py
index 8e7cf016..78e69f00 100644
--- a/include/ClientGUIScrolledPanelsEdit.py
+++ b/include/ClientGUIScrolledPanelsEdit.py
@@ -3866,7 +3866,7 @@ But if 2 is--and is also perhaps accompanied by many 'could not parse' errors--t
         file_velocity = checker_options.GetRawCurrentVelocity( query.GetFileSeedCache(), last_check_time )
         pretty_file_velocity = checker_options.GetPrettyCurrentVelocity( query.GetFileSeedCache(), last_check_time, no_prefix = True )
         
-        estimate = self._original_subscription.GetBandwidthWaitingEstimate( query )
+        estimate = query.GetBandwidthWaitingEstimate( self._original_subscription.GetName() )
         
         if estimate == 0:
             
@@ -5063,7 +5063,7 @@ class EditSubscriptionsPanel( ClientGUIScrolledPanels.EditPanel ):
                 
                 for subscription in self._subscriptions.GetData():
                     
-                    if subscription.HasQuerySearchText( search_text ):
+                    if subscription.HasQuerySearchTextFragment( search_text ):
                         
                         selectee_subscriptions.append( subscription )
                         
diff --git a/include/ClientGUIScrolledPanelsManagement.py b/include/ClientGUIScrolledPanelsManagement.py
index 98cf79cb..e6868431 100644
--- a/include/ClientGUIScrolledPanelsManagement.py
+++ b/include/ClientGUIScrolledPanelsManagement.py
@@ -29,6 +29,7 @@ from . import ClientMedia
 from . import ClientRatings
 from . import ClientSerialisable
 from . import ClientServices
+from . import ClientGUIStyle
 from . import ClientGUITime
 import collections
 from . import HydrusConstants as HC
@@ -1176,7 +1177,7 @@ class ManageClientServicesPanel( ClientGUIScrolledPanels.ManagePanel ):
                 
                 if self._allow_non_local_connections.isChecked():
                     
-                    self._upnp.setValue( None )
+                    self._upnp.SetValue( None )
                     
                     self._upnp.setEnabled( False )
                     
@@ -1524,6 +1525,7 @@ class ManageOptionsPanel( ClientGUIScrolledPanels.ManagePanel ):
         self._listbook.AddPage( 'downloading', 'downloading', self._DownloadingPanel( self._listbook, self._new_options ) )
         self._listbook.AddPage( 'duplicates', 'duplicates', self._DuplicatesPanel( self._listbook, self._new_options ) )
         self._listbook.AddPage( 'importing', 'importing', self._ImportingPanel( self._listbook, self._new_options ) )
+        self._listbook.AddPage( 'style', 'style', self._StylePanel( self._listbook, self._new_options ) )
         self._listbook.AddPage( 'tag presentation', 'tag presentation', self._TagPresentationPanel( self._listbook, self._new_options ) )
         self._listbook.AddPage( 'tag suggestions', 'tag suggestions', self._TagSuggestionsPanel( self._listbook, self._new_options ) )
         self._listbook.AddPage( 'tags', 'tags', self._TagsPanel( self._listbook, self._new_options ) )
@@ -3818,6 +3820,112 @@ class ManageOptionsPanel( ClientGUIScrolledPanels.ManagePanel ):
             
         
     
+    class _StylePanel( QW.QWidget ):
+        
+        def __init__( self, parent, new_options ):
+            
+            QW.QWidget.__init__( self, parent )
+            
+            self._new_options = new_options
+            
+            #
+            
+            self._qt_style_name = ClientGUICommon.BetterChoice( self )
+            self._qt_stylesheet_name = ClientGUICommon.BetterChoice( self )
+            
+            self._qt_style_name.addItem( 'use default ("{}")'.format( ClientGUIStyle.ORIGINAL_STYLE ), None )
+            
+            try:
+                
+                for name in ClientGUIStyle.GetAvailableStyles():
+                    
+                    self._qt_style_name.addItem( name, name )
+                    
+                
+            except HydrusExceptions.DataMissing as e:
+                
+                HydrusData.ShowException( e )
+                
+            
+            self._qt_stylesheet_name.addItem( 'use default', None )
+            
+            try:
+                
+                for name in ClientGUIStyle.GetAvailableStylesheets():
+                    
+                    self._qt_stylesheet_name.addItem( name, name )
+                    
+                
+            except HydrusExceptions.DataMissing as e:
+                
+                HydrusData.ShowException( e )
+                
+            
+            #
+            
+            self._qt_style_name.SetValue( self._new_options.GetNoneableString( 'qt_style_name' ) )
+            self._qt_stylesheet_name.SetValue( self._new_options.GetNoneableString( 'qt_stylesheet_name' ) )
+            
+            #
+            
+            vbox = QP.VBoxLayout()
+            
+            #
+            
+            text = 'This is experimental! Some custom colours in hydrus do not play well with QSS theming yet! All feedback on errors and any preferred systems is appreciated.'
+            text += os.linesep * 2
+            text += 'The current styles are what your Qt has available, the stylesheets are what .css and .qss files are currently in install_dir/static/qss.'
+            
+            st = ClientGUICommon.BetterStaticText( self, label = text )
+            
+            QP.AddToLayout( vbox, st, CC.FLAGS_EXPAND_PERPENDICULAR )
+            
+            rows = []
+            
+            rows.append( ( 'Qt style:', self._qt_style_name ) )
+            rows.append( ( 'Qt stylesheet:', self._qt_stylesheet_name ) )
+            
+            gridbox = ClientGUICommon.WrapInGrid( self, rows )
+            
+            QP.AddToLayout( vbox, gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR )
+            
+            self.setLayout( vbox )
+            
+            self._qt_style_name.currentIndexChanged.connect( self.StyleChanged )
+            self._qt_stylesheet_name.currentIndexChanged.connect( self.StyleChanged )
+            
+        
+        def StyleChanged( self ):
+            
+            qt_style_name = self._qt_style_name.GetValue()
+            qt_stylesheet_name = self._qt_stylesheet_name.GetValue()
+            
+            if qt_style_name is None:
+                
+                ClientGUIStyle.SetStyle( ClientGUIStyle.ORIGINAL_STYLE )
+                
+            else:
+                
+                ClientGUIStyle.SetStyle( qt_style_name )
+                
+            
+            if qt_stylesheet_name is None:
+                
+                ClientGUIStyle.ClearStylesheet()
+                
+            else:
+                
+                ClientGUIStyle.SetStylesheet( qt_stylesheet_name )
+                
+            
+        
+        def UpdateOptions( self ):
+            
+            self._new_options.SetNoneableString( 'qt_style_name', self._qt_style_name.GetValue() )
+            self._new_options.SetNoneableString( 'qt_stylesheet_name', self._qt_stylesheet_name.GetValue() )
+            
+        
+    
     class _TagsPanel( QW.QWidget ):
         
         def __init__( self, parent, new_options ):
diff --git a/include/ClientGUIScrolledPanelsReview.py b/include/ClientGUIScrolledPanelsReview.py
index 1080d5a7..dbe11e72 100644
--- a/include/ClientGUIScrolledPanelsReview.py
+++ b/include/ClientGUIScrolledPanelsReview.py
@@ -1880,6 +1880,7 @@ class ReviewAllBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
         help += 'Please note that this system bases its calendar dates on UTC/GMT time (it helps servers and clients around the world stay in sync a bit easier). This has no bearing on what, for instance, the \'past 24 hours\' means, but monthly transitions may occur a few hours off whatever your midnight is.'
         help += os.linesep * 2
         help += 'If you do not understand what is going on here, you can safely leave it alone. The default settings make for a _reasonable_ and polite profile that will not accidentally cause you to download way too much in one go or piss off servers by being too aggressive. If you want to throttle your client, the simplest way is to add a simple rule like \'500MB per day\' to the global context.'
+        
         QW.QMessageBox.information( self, 'Information', help )
         
     
@@ -3433,8 +3434,6 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
         self._bandwidth_rules = self._controller.network_engine.bandwidth_manager.GetRules( self._network_context )
         self._bandwidth_tracker = self._controller.network_engine.bandwidth_manager.GetTracker( self._network_context )
         
-        self._last_fetched_rule_rows = set()
-        
         #
         
         info_panel = ClientGUICommon.StaticBox( self, 'description' )
@@ -3463,6 +3462,13 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
         
         self._rules_rows_panel = QW.QWidget( rules_panel )
         
+        vbox = QP.VBoxLayout()
+        
+        self._rules_rows_panel.setLayout( vbox )
+        
+        self._last_fetched_rule_rows = set()
+        self._rule_widgets = []
+        
         self._use_default_rules_button = ClientGUICommon.BetterButton( rules_panel, 'use default rules', self._UseDefaultRules )
         self._edit_rules_button = ClientGUICommon.BetterButton( rules_panel, 'edit rules', self._EditRules )
         
@@ -3538,9 +3544,9 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
         
         #
         
-        self._rules_job = HG.client_controller.CallRepeatingQtSafe(self, 0.5, 5.0, self._UpdateRules)
+        self._rules_job = HG.client_controller.CallRepeatingQtSafe( self, 0.5, 5.0, self._UpdateRules )
         
-        self._update_job = HG.client_controller.CallRepeatingQtSafe(self, 0.5, 1.0, self._Update)
+        self._update_job = HG.client_controller.CallRepeatingQtSafe( self, 0.5, 1.0, self._Update )
         
     
     def _EditRules( self ):
@@ -3595,8 +3601,6 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
     
     def _UpdateRules( self ):
         
-        changes_made = False
-        
         if self._network_context.IsDefault() or self._network_context == ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT:
             
             if self._use_default_rules_button.isVisible():
@@ -3604,8 +3608,6 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
                 self._uses_default_rules_st.hide()
                 self._use_default_rules_button.hide()
                 
-                changes_made = True
-                
             
         else:
             
@@ -3619,8 +3621,6 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
                     
                     self._use_default_rules_button.hide()
                     
-                    changes_made = True
-                    
                 
             else:
                 
@@ -3632,8 +3632,6 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
                     
                     self._use_default_rules_button.show()
                     
-                    changes_made = True
-                    
                 
             
         
@@ -3643,9 +3641,16 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
             
             self._last_fetched_rule_rows = rule_rows
             
-            QP.DestroyChildren( self._rules_rows_panel )
+            vbox = self._rules_rows_panel.layout()
             
-            vbox = QP.VBoxLayout()
+            for rule_widget in self._rule_widgets:
+                
+                vbox.removeWidget( rule_widget )
+                
+                rule_widget.deleteLater()
+                
+            
+            self._rule_widgets = []
             
             for ( status, ( v, r ) ) in rule_rows:
                 
@@ -3653,13 +3658,11 @@ class ReviewNetworkContextBandwidthPanel( ClientGUIScrolledPanels.ReviewPanel ):
                 
                 tg.SetValue( status, v, r )
                 
+                self._rule_widgets.append( tg )
+                
                 QP.AddToLayout( vbox, tg, CC.FLAGS_EXPAND_PERPENDICULAR )
                 
             
-            self._rules_rows_panel.setLayout( vbox )
-            
-            changes_made = True
-            
         
     
     def _UseDefaultRules( self ):
diff --git a/include/ClientGUIStyle.py b/include/ClientGUIStyle.py
new file mode 100644
index 00000000..b2c02fd6
--- /dev/null
+++ b/include/ClientGUIStyle.py
@@ -0,0 +1,90 @@
+from . import HydrusConstants as HC
+from . import HydrusData
+from . import HydrusExceptions
+import os
+from qtpy import QtWidgets as QW
+
+STYLESHEET_DIR = os.path.join( HC.BASE_DIR, 'static', 'qss' )
+
+ORIGINAL_STYLE = None
+ORIGINAL_STYLESHEET = None
+
+def ClearStylesheet():
+    
+    QW.QApplication.instance().setStyleSheet( ORIGINAL_STYLESHEET )
+    
+def GetAvailableStyles():
+    
+    # so eventually expand this to do QStylePlugin or whatever we are doing to add more QStyles
+    
+    return list( QW.QStyleFactory.keys() )
+    
+def GetCurrentStyleName():
+    
+    return QW.QApplication.instance().style().objectName()
+    
+def GetAvailableStylesheets():
+    
+    if not os.path.exists( STYLESHEET_DIR ) or not os.path.isdir( STYLESHEET_DIR ):
+        
+        raise HydrusExceptions.DataMissing( 'Stylesheet dir "{}" is missing or not a directory!'.format( STYLESHEET_DIR ) )
+        
+    
+    stylesheet_filenames = []
+    
+    extensions = [ '.qss', '.css' ]
+    
+    for filename in os.listdir( STYLESHEET_DIR ):
+        
+        if True in ( filename.endswith( ext ) for ext in extensions ):
+            
+            stylesheet_filenames.append( filename )
+            
+        
+    
+    return stylesheet_filenames
+    
+def InitialiseDefaults():
+    
+    global ORIGINAL_STYLE
+    
+    ORIGINAL_STYLE = GetCurrentStyleName()
+    
+    global ORIGINAL_STYLESHEET
+    
+    ORIGINAL_STYLESHEET = QW.QApplication.instance().styleSheet()
+    
+def SetStyle( name ):
+    
+    current_name = GetCurrentStyleName()
+    
+    if name == current_name:
+        
+        return
+        
+    
+    if name in QW.QStyleFactory.keys():
+        
+        QW.QApplication.instance().setStyle( QW.QStyleFactory.create( name ) )
+        
+    else:
+        
+        raise HydrusExceptions.DataMissing( 'Style "{}" does not exist!'.format( name ) )
+        
+    
+def SetStylesheet( filename ):
+    
+    path = os.path.join( STYLESHEET_DIR, filename )
+    
+    if not os.path.exists( path ):
+        
+        raise HydrusExceptions.DataMissing( 'Stylesheet "{}" does not exist!'.format( path ) )
+        
+    
+    with open( path, 'r', encoding = 'utf-8' ) as f:
+        
+        qss = f.read()
+        
+    
+    QW.QApplication.instance().setStyleSheet( qss )
+    
diff --git a/include/ClientGUITags.py b/include/ClientGUITags.py
index b3b4f5ef..9e9e8f4f 100644
--- a/include/ClientGUITags.py
+++ b/include/ClientGUITags.py
@@ -16,6 +16,7 @@ from . import ClientGUIScrolledPanelsEdit
 from . import ClientGUIScrolledPanelsReview
 from . import ClientGUIShortcuts
 from . import ClientGUITagSuggestions
+from . import ClientManagers
 from . import ClientMedia
 from . import ClientMigration
 from . import ClientTags
@@ -2287,8 +2288,8 @@ class ManageTagParents( ClientGUIScrolledPanels.ManagePanel ):
             
             ( gumpf, preview_height ) = ClientGUIFunctions.ConvertTextToPixels( self._children, ( 12, 6 ) )
             
-            QP.SetInitialSize( self._children, (-1,preview_height) )
-            QP.SetInitialSize( self._parents, (-1,preview_height) )
+            self._children.setMinimumHeight( preview_height )
+            self._parents.setMinimumHeight( preview_height )
             
             expand_parents = True
             
@@ -2611,9 +2612,9 @@ class ManageTagParents( ClientGUIScrolledPanels.ManagePanel ):
             
             if potential_parent in current_children:
                 
-                simple_children_to_parents = ClientCaches.BuildSimpleChildrenToParents( current_pairs )
+                simple_children_to_parents = ClientManagers.BuildSimpleChildrenToParents( current_pairs )
                 
-                if ClientCaches.LoopInSimpleChildrenToParents( simple_children_to_parents, potential_child, potential_parent ):
+                if ClientManagers.LoopInSimpleChildrenToParents( simple_children_to_parents, potential_child, potential_parent ):
                     
                     QW.QMessageBox.critical( self, 'Error', 'Adding '+potential_child+'->'+potential_parent+' would create a loop!' )
                     
@@ -3105,7 +3106,7 @@ class ManageTagSiblings( ClientGUIScrolledPanels.ManagePanel ):
             
             ( gumpf, preview_height ) = ClientGUIFunctions.ConvertTextToPixels( self._old_siblings, ( 12, 6 ) )
             
-            QP.SetInitialSize( self._old_siblings, (-1,preview_height) )
+            self._old_siblings.setMinimumHeight( preview_height )
             
             expand_parents = False
             
diff --git a/include/ClientGUITopLevelWindows.py b/include/ClientGUITopLevelWindows.py
index 482d4a04..f4ccc045 100644
--- a/include/ClientGUITopLevelWindows.py
+++ b/include/ClientGUITopLevelWindows.py
@@ -216,7 +216,7 @@ def SetInitialTLWSizeAndPosition( tlw, frame_key ):
         
     else:
         
-        ( min_width, min_height ) = QP.GetEffectiveMinSize( tlw )
+        ( min_width, min_height ) = tlw.sizeHint().toTuple()
         
         ( width, height ) = GetSafeSize( tlw, ( min_width, min_height ), default_gravity )
         
@@ -321,12 +321,16 @@ def SlideOffScreenTLWUpAndLeft( tlw ):
     
 class NewDialog( QP.Dialog ):
     
-    def __init__( self, parent, title ):
+    def __init__( self, parent, title, do_not_activate = False ):
         
         QP.Dialog.__init__( self, parent )
-        self.setWindowTitle( title )
         
-        self._consumed_esc_to_cancel = False
+        if do_not_activate:
+            
+            self.setAttribute( QC.Qt.WA_ShowWithoutActivating )
+            
+        
+        self.setWindowTitle( title )
         
         self._last_move_pub = 0.0
         
@@ -377,20 +381,21 @@ class NewDialog( QP.Dialog ):
         
         if not self.isModal(): # in some rare cases (including spammy AutoHotkey, looks like), this can be fired before the dialog can clean itself up
             
-            return
+            return False
             
         
         if not self._ReadyToClose( value ):
             
-            return
+            return False
             
         
         if value == QW.QDialog.Rejected:
             
             if not self._CanCancel():
                 
-                return
+                return False
                 
+            
             self.SetCancelled( True )
             
         
@@ -398,7 +403,7 @@ class NewDialog( QP.Dialog ):
             
             if not self._CanOK():
                 
-                return
+                return False
                 
             
             self._SaveOKPosition()
@@ -439,6 +444,8 @@ class NewDialog( QP.Dialog ):
                 
             
         
+        return True
+        
     
     def CleanBeforeDestroy( self ):
         
@@ -450,13 +457,19 @@ class NewDialog( QP.Dialog ):
         self._TryEndModal( QW.QDialog.Accepted )
         
     
-    def EventClose( self, event ):
+    def closeEvent( self, event ):
         
         if not self or not QP.isValid( self ):
             
             return
             
-        self._TryEndModal( QW.QDialog.Rejected )
+        
+        was_ended = self._TryEndModal( QW.QDialog.Rejected )
+        
+        if not was_ended:
+            
+            event.ignore()
+            
         
     
     def EventDialogButtonApply( self ):
@@ -514,9 +527,7 @@ class NewDialog( QP.Dialog ):
         
         event_from_us = current_focus is not None and ClientGUIFunctions.IsQtAncestor( current_focus, self )
         
-        if event_from_us and key == QC.Qt.Key_Escape and not self._consumed_esc_to_cancel:
-            
-            self._consumed_esc_to_cancel = True
+        if event_from_us and key == QC.Qt.Key_Escape:
             
             self._TryEndModal( QW.QDialog.Rejected )
             
@@ -528,11 +539,11 @@ class NewDialog( QP.Dialog ):
     
 class DialogThatResizes( NewDialog ):
     
-    def __init__( self, parent, title, frame_key ):
+    def __init__( self, parent, title, frame_key, do_not_activate = False ):
         
         self._frame_key = frame_key
         
-        NewDialog.__init__( self, parent, title )
+        NewDialog.__init__( self, parent, title, do_not_activate = do_not_activate )
         
     
     def _SaveOKPosition( self ):
@@ -542,12 +553,12 @@ class DialogThatResizes( NewDialog ):
     
 class DialogThatTakesScrollablePanel( DialogThatResizes ):
     
-    def __init__( self, parent, title, frame_key = 'regular_dialog', hide_buttons = False ):
+    def __init__( self, parent, title, frame_key = 'regular_dialog', hide_buttons = False, do_not_activate = False ):
         
         self._panel = None
         self._hide_buttons = hide_buttons
         
-        DialogThatResizes.__init__( self, parent, title, frame_key )
+        DialogThatResizes.__init__( self, parent, title, frame_key, do_not_activate = do_not_activate )
         
         self._InitialiseButtons()
         
@@ -676,8 +687,6 @@ class DialogApplyCancel( DialogThatTakesScrollablePanel ):
             self._apply.setVisible( False )
             self._cancel.setVisible( False )
             
-            self._widget_event_filter.EVT_CLOSE( self.EventClose ) # the close event no longer goes to the default button, since it is hidden, wew
-            
         
     
 class DialogEdit( DialogApplyCancel ):
@@ -768,6 +777,7 @@ class Frame( QW.QWidget ):
         
         self.setWindowFlags( QC.Qt.Window )
         self.setWindowFlag( QC.Qt.WindowContextHelpButtonHint, on = False )
+        
         self.setAttribute( QC.Qt.WA_DeleteOnClose )
         
         self._new_options = HG.client_controller.new_options
@@ -893,7 +903,7 @@ class FrameThatTakesScrollablePanel( FrameThatResizes ):
         FrameThatResizes.__init__( self, parent, title, frame_key )
         
         self._ok = QW.QPushButton( 'close', self )
-        self._ok.clicked.connect( self.EventClose )
+        self._ok.clicked.connect( self.close )
         
     
     def CleanBeforeDestroy( self ):
@@ -920,11 +930,6 @@ class FrameThatTakesScrollablePanel( FrameThatResizes ):
             
         
     
-    def EventClose( self ):
-        
-        self.close()
-        
-    
     def GetPanel( self ):
         
         return self._panel
@@ -934,7 +939,10 @@ class FrameThatTakesScrollablePanel( FrameThatResizes ):
         
         self._panel = panel
         
-        if hasattr( self._panel, 'okSignal' ): self._panel.okSignal.connect( self.EventClose )
+        if hasattr( self._panel, 'okSignal' ):
+            
+            self._panel.okSignal.connect( self.close )
+            
         
         vbox = QP.VBoxLayout()
         
diff --git a/include/ClientImportGallery.py b/include/ClientImportGallery.py
index 2840d1ac..c1341385 100644
--- a/include/ClientImportGallery.py
+++ b/include/ClientImportGallery.py
@@ -218,7 +218,10 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
                 
                 with self._lock:
                     
-                    text = text.splitlines()[0]
+                    if len( text ) > 0:
+                        
+                        text = text.splitlines()[0]
+                        
                     
                     self._file_status = text
                     
@@ -332,7 +335,10 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                text = text.splitlines()[0]
+                if len( text ) > 0:
+                    
+                    text = text.splitlines()[0]
+                    
                 
                 self._gallery_status = text
                 
diff --git a/include/ClientImportSimpleURLs.py b/include/ClientImportSimpleURLs.py
index d08400d7..81837072 100644
--- a/include/ClientImportSimpleURLs.py
+++ b/include/ClientImportSimpleURLs.py
@@ -190,7 +190,10 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                text = text.splitlines()[0]
+                if len( text ) > 0:
+                    
+                    text = text.splitlines()[0]
+                    
                 
                 self._current_action = text
                 
diff --git a/include/ClientImportSubscriptions.py b/include/ClientImportSubscriptions.py
index 058392b3..4c10b8b5 100644
--- a/include/ClientImportSubscriptions.py
+++ b/include/ClientImportSubscriptions.py
@@ -17,6 +17,7 @@ from . import HydrusSerialisable
 from . import HydrusThreading
 import os
 import random
+import threading
 import time
 
 class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
@@ -70,36 +71,34 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         self._merge_query_publish_events = True
         
     
+    def _CanDoWorkNow( self ):
+        
+        p1 = not ( self._paused or HG.client_controller.options[ 'pause_subs_sync' ] or HG.client_controller.new_options.GetBoolean( 'pause_all_new_network_traffic' ) )
+        p2 = not ( HG.view_shutdown or HydrusThreading.IsThreadShuttingDown() )
+        p3 = self._NoDelays()
+        
+        if HG.subscription_report_mode:
+            
+            message = 'Subscription "{}" CanDoWork check.'.format( self._name )
+            message += os.linesep
+            message += 'Paused/Global/Network Pause: {}/{}/{}'.format( self._paused, HG.client_controller.options[ 'pause_subs_sync' ], HG.client_controller.new_options.GetBoolean( 'pause_all_new_network_traffic' ) )
+            message += os.linesep
+            message += 'View/Thread shutdown: {}/{}'.format( HG.view_shutdown, HydrusThreading.IsThreadShuttingDown() )
+            message += os.linesep
+            message += 'No delays: {}'.format( self._NoDelays() )
+            
+            HydrusData.ShowText( message )
+            
+        
+        return p1 and p2 and p3
+        
+    
     def _DelayWork( self, time_delta, reason ):
         
         self._no_work_until = HydrusData.GetNow() + time_delta
         self._no_work_until_reason = reason
         
     
-    def _GetExampleNetworkContexts( self, query ):
-        
-        file_seed_cache = query.GetFileSeedCache()
-        
-        file_seed = file_seed_cache.GetNextFileSeed( CC.STATUS_UNKNOWN )
-        
-        if file_seed is None:
-            
-            return [ ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_SUBSCRIPTION, self._GetNetworkJobSubscriptionKey( query ) ), ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT ]
-            
-        
-        url = file_seed.file_seed_data
-        
-        example_nj = ClientNetworkingJobs.NetworkJobSubscription( self._GetNetworkJobSubscriptionKey( query ), 'GET', url )
-        example_network_contexts = example_nj.GetNetworkContexts()
-        
-        return example_network_contexts
-        
-    
-    def _GetNetworkJobSubscriptionKey( self, query ):
-        
-        return self._name + ': ' + query.GetHumanName()
-        
-    
     def _GetPublishingLabel( self, query ):
         
         if self._publish_label_override is None:
@@ -168,7 +167,7 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
     
     def _GenerateNetworkJobFactory( self, query ):
         
-        subscription_key = self._GetNetworkJobSubscriptionKey( query )
+        subscription_key = query.GetNetworkJobSubscriptionKey( self._name )
         
         def network_job_factory( *args, **kwargs ):
             
@@ -187,22 +186,6 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         return HydrusData.TimeHasPassed( self._no_work_until )
         
     
-    def _QueryBandwidthIsOK( self, query ):
-        
-        example_network_contexts = self._GetExampleNetworkContexts( query )
-        
-        threshold = 90
-        
-        result = HG.client_controller.network_engine.bandwidth_manager.CanDoWork( example_network_contexts, threshold = threshold )
-        
-        if HG.subscription_report_mode:
-            
-            HydrusData.ShowText( 'Query "' + query.GetHumanName() + '" pre-work bandwidth test. Bandwidth ok: ' + str( result ) + '.' )
-            
-        
-        return result
-        
-    
     def _QueryFileLoginIsOK( self, query ):
         
         file_seed_cache = query.GetFileSeedCache()
@@ -465,6 +448,8 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         
         queries = self._GetQueriesForProcessing()
         
+        queries = [ query for query in queries if query.HasFileWorkToDo() ]
+        
         num_queries = len( queries )
         
         for ( i, query ) in enumerate( queries ):
@@ -520,13 +505,11 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                         break
                         
                     
-                    p1 = HC.options[ 'pause_subs_sync' ]
-                    p2 = HydrusThreading.IsThreadShuttingDown()
-                    p3 = HG.view_shutdown
-                    p4 = not self._QueryBandwidthIsOK( query )
+                    p1 = not self._CanDoWorkNow()
+                    p4 = not query.BandwidthIsOK( self._name )
                     p5 = not self._QueryFileLoginIsOK( query )
                     
-                    if p1 or p2 or p3 or p4 or p5:
+                    if p1 or p4 or p5:
                         
                         if p4 and this_query_has_done_work:
                             
@@ -555,7 +538,10 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                         
                         def status_hook( text ):
                             
-                            text = text.splitlines()[0]
+                            if len( text ) > 0:
+                                
+                                text = text.splitlines()[0]
+                                
                             
                             job_key.SetVariable( 'popup_text_2', x_out_of_y + text )
                             
@@ -680,15 +666,25 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         
         for query in self._queries:
             
-            if query.CanWorkOnFiles():
+            if query.HasFileWorkToDo():
                 
-                if self._QueryBandwidthIsOK( query ):
+                if query.BandwidthIsOK( self._name ):
+                    
+                    if HG.subscription_report_mode:
+                        
+                        HydrusData.ShowText( 'Subscription "{}" checking if any file work due: True'.format( self._name ) )
+                        
                     
                     return True
                     
                 
             
         
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Subscription "{}" checking if any file work due: False'.format( self._name ) )
+            
+        
         return False
         
     
@@ -720,22 +716,12 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         
         queries = self._GetQueriesForProcessing()
         
+        queries = [ query for query in queries if query.IsSyncDue() ]
+        
         num_queries = len( queries )
         
         for ( i, query ) in enumerate( queries ):
             
-            can_sync = query.CanSync()
-            
-            if HG.subscription_report_mode:
-                
-                HydrusData.ShowText( 'Query "' + query.GetHumanName() + '" started. Current can_sync is ' + str( can_sync ) + '.' )
-                
-            
-            if not can_sync:
-                
-                continue
-                
-            
             query_text = query.GetQueryText()
             query_name = query.GetHumanName()
             file_seed_cache = query.GetFileSeedCache()
@@ -794,12 +780,10 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                 
                 while gallery_seed_log.WorkToDo():
                     
-                    p1 = HC.options[ 'pause_subs_sync' ]
-                    p2 = HG.view_shutdown
+                    p1 = not self._CanDoWorkNow()
                     p3 = not self._QuerySyncLoginIsOK( query )
-                    p4 = HydrusThreading.IsThreadShuttingDown()
                     
-                    if p1 or p2 or p3 or p4:
+                    if p1 or p3:
                         
                         if p3:
                             
@@ -829,7 +813,10 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                     
                     def status_hook( text ):
                         
-                        text = text.splitlines()[0]
+                        if len( text ) > 0:
+                            
+                            text = text.splitlines()[0]
+                            
                         
                         job_key.SetVariable( 'popup_text_1', prefix + ': ' + text )
                         
@@ -1000,13 +987,10 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
             
             file_seed_cache.AddFileSeeds( file_seeds_to_add_ordered )
             
-            query.RegisterSyncComplete()
+            query.RegisterSyncComplete( self._checker_options )
             query.UpdateNextCheckTime( self._checker_options )
             
-            if query.CanCompact( self._checker_options ):
-                
-                query.Compact( self._checker_options )
-                
+            #
             
             if query.IsDead():
                 
@@ -1023,7 +1007,7 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                 
                 if this_is_initial_sync:
                     
-                    if not self._QueryBandwidthIsOK( query ) and not have_made_an_initial_sync_bandwidth_notification:
+                    if not query.BandwidthIsOK( self._name ) and not have_made_an_initial_sync_bandwidth_notification:
                         
                         HydrusData.ShowText( 'FYI: The query "' + query_name + '" for subscription "' + self._name + '" performed its initial sync ok, but that domain is short on bandwidth right now, so no files will be downloaded yet. The subscription will catch up in future as bandwidth becomes available. You can review the estimated time until bandwidth is available under the manage subscriptions dialog. If more queries are performing initial syncs in this run, they may be the same.' )
                         
@@ -1036,7 +1020,32 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
     
     def _SyncQueryCanDoWork( self ):
         
-        return True in ( query.CanSync() for query in self._queries )
+        result = True in ( query.IsSyncDue() for query in self._queries )
+        
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Subscription "{}" checking if any sync work due: {}'.format( self._name, result ) )
+            
+        
+        return result
+        
+    
+    def AllPaused( self ):
+        
+        if self._paused:
+            
+            return True
+            
+        
+        for query in self._queries:
+            
+            if not query.IsPaused():
+                
+                return False
+                
+            
+        
+        return True
         
     
     def CanCheckNow( self ):
@@ -1074,15 +1083,6 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         self.ScrubDelay()
         
     
-    def GetBandwidthWaitingEstimate( self, query ):
-        
-        example_network_contexts = self._GetExampleNetworkContexts( query )
-        
-        ( estimate, bandwidth_network_context ) = HG.client_controller.network_engine.bandwidth_manager.GetWaitingEstimateAndContext( example_network_contexts )
-        
-        return estimate
-        
-    
     def GetBandwidthWaitingEstimateMinMax( self ):
         
         if len( self._queries ) == 0:
@@ -1094,9 +1094,7 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         
         for query in self._queries:
             
-            example_network_contexts = self._GetExampleNetworkContexts( query )
-            
-            ( estimate, bandwidth_network_context ) = HG.client_controller.network_engine.bandwidth_manager.GetWaitingEstimateAndContext( example_network_contexts )
+            estimate = query.GetBandwidthWaitingEstimate( self._name )
             
             estimates.append( estimate )
             
@@ -1107,6 +1105,50 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         return ( min_estimate, max_estimate )
         
     
+    def GetBestEarliestNextWorkTime( self ):
+        
+        next_work_times = set()
+        
+        for query in self._queries:
+            
+            next_work_time = query.GetNextWorkTime( self._name )
+            
+            if next_work_time is not None:
+                
+                next_work_times.add( next_work_time )
+                
+            
+        
+        if len( next_work_times ) == 0:
+            
+            return None
+            
+        
+        # if there are three queries due fifty seconds after our first one runs, we should wait that little bit longer
+        LAUNCH_WINDOW = 15 * 60
+        
+        earliest_next_work_time = min( next_work_times )
+        
+        latest_nearby_next_work_time = max( ( work_time for work_time in next_work_times if work_time < earliest_next_work_time + LAUNCH_WINDOW ) )
+        
+        # but if we are expecting to launch it right now (e.g. check_now call), we won't wait
+        if HydrusData.TimeUntil( earliest_next_work_time ) < 60:
+            
+            best_next_work_time = earliest_next_work_time
+            
+        else:
+            
+            best_next_work_time = latest_nearby_next_work_time
+            
+        
+        if not HydrusData.TimeHasPassed( self._no_work_until ):
+            
+            best_next_work_time = max( ( best_next_work_time, self._no_work_until ) )
+            
+        
+        return best_next_work_time
+        
+    
     def GetGUGKeyAndName( self ):
         
         return self._gug_key_and_name
@@ -1147,13 +1189,13 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         return self._tag_import_options
         
     
-    def HasQuerySearchText( self, search_text ):
+    def HasQuerySearchTextFragment( self, search_text_fragment ):
         
         for query in self._queries:
             
             query_text = query.GetQueryText()
             
-            if search_text in query_text:
+            if search_text_fragment in query_text:
                 
                 return True
                 
@@ -1210,17 +1252,6 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
             
         
     
-    def ReviveDead( self ):
-        
-        for query in self._queries:
-            
-            if query.IsDead():
-                
-                query.CheckNow()
-                
-            
-        
-    
     def Separate( self, base_name, only_these_queries = None ):
         
         if only_these_queries is None:
@@ -1302,28 +1333,10 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
     
     def Sync( self ):
         
-        p1 = not self._paused
-        p2 = not HG.view_shutdown
-        p3 = self._NoDelays()
-        p4 = self._SyncQueryCanDoWork()
-        p5 = self._WorkOnFilesCanDoWork()
+        sync_ok = self._SyncQueryCanDoWork()
+        files_ok = self._WorkOnFilesCanDoWork()
         
-        if HG.subscription_report_mode:
-            
-            message = 'Subscription "' + self._name + '" entered sync.'
-            message += os.linesep
-            message += 'Unpaused: ' + str( p1 )
-            message += os.linesep
-            message += 'No delays: ' + str( p3 )
-            message += os.linesep
-            message += 'Sync can do work: ' + str( p4 )
-            message += os.linesep
-            message += 'Files can do work: ' + str( p5 )
-            
-            HydrusData.ShowText( message )
-            
-        
-        if p1 and p2 and p3 and ( p4 or p5 ):
+        if self._CanDoWorkNow() and ( sync_ok or files_ok ):
             
             job_key = ClientThreading.JobKey( pausable = False, cancellable = True )
             
@@ -1336,7 +1349,11 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                     HG.client_controller.pub( 'message', job_key )
                     
                 
-                self._SyncQuery( job_key )
+                # it is possible a query becomes due for a check while others are syncing, so we repeat this while watching for a stop signal
+                while self._CanDoWorkNow() and self._SyncQueryCanDoWork():
+                    
+                    self._SyncQuery( job_key )
+                    
                 
                 self._WorkOnFiles( job_key )
                 
@@ -1386,6 +1403,381 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
         return ( self._name, self._gug_key_and_name, self._queries, self._checker_options, self._initial_file_limit, self._periodic_file_limit, self._paused, self._file_import_options, self._tag_import_options, self._no_work_until, self._no_work_until_reason )
         
     
+class SubscriptionJob( object ):
+    
+    def __init__( self, controller, subscription ):
+        
+        self._controller = controller
+        self._subscription = subscription
+        self._job_done = threading.Event()
+        
+    
+    def _DoWork( self ):
+        
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Subscription "{}" about to start.'.format( self._subscription.GetName() ) )
+            
+        
+        self._subscription.Sync()
+        
+    
+    def IsDone( self ):
+        
+        return self._job_done.is_set()
+        
+    
+    def Work( self ):
+        
+        try:
+            
+            self._DoWork()
+            
+        finally:
+            
+            self._job_done.set()
+            
+        
+    
+class SubscriptionsManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._running_subscriptions = {}
+        self._current_subscription_names = set()
+        self._names_to_next_work_time = {}
+        self._names_that_cannot_run = set()
+        
+        self._loading_sub = False
+        
+        self._lock = threading.Lock()
+        
+        self._shutdown = False
+        self._mainloop_finished = False
+        
+        self._wake_event = threading.Event()
+        
+        # cache deals with 'don't need to check, but have more files to do' and delay timings
+        # no prob if cache is empty of a sub, we'll just repopulate naturally
+        # also cache deals with pause info
+        # ideally this lad will launch subs exactly on time, rather than every twenty mins or whatever, but we should have a buffer on natural timings in order to get multiple queries together
+        
+        self._ReinitialiseNames()
+        
+        self._controller.CallToThreadLongRunning( self.MainLoop )
+        
+        self._controller.sub( self, 'Shutdown', 'shutdown' )
+        
+    
+    def _ClearFinishedSubscriptions( self ):
+        
+        for ( name, ( thread, job, subscription ) ) in list( self._running_subscriptions.items() ):
+            
+            if job.IsDone():
+                
+                self._UpdateSubscriptionInfo( subscription, just_finished_work = True )
+                
+                del self._running_subscriptions[ name ]
+                
+            
+        
+    
+    def _GetNameReadyToGo( self ):
+        
+        p1 = HG.client_controller.options[ 'pause_subs_sync' ]
+        p2 = HG.client_controller.new_options.GetBoolean( 'pause_all_new_network_traffic' )
+        p3 = HG.view_shutdown
+        
+        if p1 or p2 or p3:
+            
+            return None
+            
+        
+        max_simultaneous_subscriptions = HG.client_controller.new_options.GetInteger( 'max_simultaneous_subscriptions' )
+        
+        if len( self._running_subscriptions ) >= max_simultaneous_subscriptions:
+            
+            return None
+            
+        
+        possible_names = set( self._current_subscription_names )
+        possible_names.difference_update( set( self._running_subscriptions.keys() ) )
+        possible_names.difference_update( self._names_that_cannot_run )
+        
+        # just a couple of seconds for calculation and human breathing room
+        SUB_WORK_DELAY_BUFFER = 3
+        
+        names_not_due = { name for ( name, next_work_time ) in self._names_to_next_work_time.items() if not HydrusData.TimeHasPassed( next_work_time + SUB_WORK_DELAY_BUFFER ) }
+        
+        possible_names.difference_update( names_not_due )
+        
+        if len( possible_names ) == 0:
+            
+            return None
+            
+        
+        possible_names = list( possible_names )
+        
+        if HG.client_controller.new_options.GetBoolean( 'process_subs_in_random_order' ):
+            
+            subscription_name = random.choice( possible_names )
+            
+        else:
+            
+            possible_names.sort()
+            
+            subscription_name = possible_names.pop( 0 )
+            
+        
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Subscription manager selected "{}" to start.'.format( subscription_name ) )
+            
+        
+        return subscription_name
+        
+    
+    def _GetMainLoopWaitTime( self ):
+        
+        if self._shutdown:
+            
+            return 0.1
+            
+        
+        if len( self._running_subscriptions ) > 0:
+            
+            return 1
+            
+        else:
+            
+            subscription_name = self._GetNameReadyToGo()
+            
+            if subscription_name is not None:
+                
+                return 1
+                
+            else:
+                
+                return 15
+                
+            
+        
+    
+    def _ReinitialiseNames( self ):
+        
+        self._current_subscription_names = set( HG.client_controller.Read( 'serialisable_names', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION ) )
+        
+        self._names_that_cannot_run = set()
+        self._names_to_next_work_time = {}
+        
+    
+    def _UpdateSubscriptionInfo( self, subscription, just_finished_work = False ):
+        
+        name = subscription.GetName()
+        
+        if name in self._names_that_cannot_run:
+            
+            self._names_that_cannot_run.discard( name )
+            
+        
+        if name in self._names_to_next_work_time:
+            
+            del self._names_to_next_work_time[ name ]
+            
+        
+        if subscription.AllPaused():
+            
+            self._names_that_cannot_run.add( name )
+            
+        else:
+            
+            next_work_time = subscription.GetBestEarliestNextWorkTime()
+            
+            if next_work_time is None:
+                
+                self._names_that_cannot_run.add( name )
+                
+            else:
+                
+                if just_finished_work:
+                    
+                    # don't want to have a load/save cycle repeating over and over
+                    # this sets min resolution of a single sub repeat cycle
+                    # we'll clear it when we have data breakup done
+                    BUFFER_TIME = 60 * 60
+                    
+                    next_work_time = max( next_work_time, HydrusData.GetNow() + BUFFER_TIME )
+                    
+                
+                self._names_to_next_work_time[ name ] = next_work_time
+                
+            
+        
+    
+    def ClearCacheAndWake( self ):
+        
+        with self._lock:
+            
+            self._ReinitialiseNames()
+            
+            self.Wake()
+            
+        
+    
+    def IsShutdown( self ):
+        
+        return self._mainloop_finished
+        
+    
+    def MainLoop( self ):
+        
+        try:
+            
+            self._wake_event.wait( 60 )
+            
+            while not ( HG.view_shutdown or self._shutdown ):
+                
+                with self._lock:
+                    
+                    subscription_name = self._GetNameReadyToGo()
+                    
+                    if subscription_name is not None:
+                        
+                        self._loading_sub = True
+                        
+                    
+                
+                if subscription_name is not None:
+                    
+                    try:
+                        
+                        try:
+                            
+                            subscription = self._controller.Read( 'serialisable_named', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION, subscription_name )
+                            
+                        except Exception as e:
+                            
+                            HydrusData.ShowText( 'Subscription "{}" failed to load! Error information should follow. No more subscriptions will run this boot.'.format( subscription_name ) )
+                            HydrusData.ShowException( e )
+                            
+                            return
+                            
+                        
+                        job = SubscriptionJob( self._controller, subscription )
+                        
+                        thread = threading.Thread( target = job.Work, name = 'subscription thread' )
+                        
+                        thread.start()
+                        
+                        with self._lock:
+                            
+                            self._running_subscriptions[ subscription_name ] = ( thread, job, subscription )
+                            
+                        
+                    finally:
+                        
+                        with self._lock:
+                            
+                            self._loading_sub = False
+                            
+                        
+                    
+                
+                with self._lock:
+                    
+                    self._ClearFinishedSubscriptions()
+                    
+                    wait_time = self._GetMainLoopWaitTime()
+                    
+                
+                self._wake_event.wait( wait_time )
+                
+                self._wake_event.clear()
+                
+            
+        finally:
+            
+            with self._lock:
+                
+                for ( name, ( thread, job, subscription ) ) in self._running_subscriptions.items():
+                    
+                    HydrusThreading.ShutdownThread( thread )
+                    
+                
+            
+            while not HG.view_shutdown:
+                
+                with self._lock:
+                    
+                    self._ClearFinishedSubscriptions()
+                    
+                    if len( self._running_subscriptions ) == 0:
+                        
+                        break
+                        
+                    
+                
+                time.sleep( 0.1 )
+                
+            
+            self._mainloop_finished = True
+            
+        
+    
+    def NewSubscriptions( self, subscriptions ):
+        
+        with self._lock:
+            
+            self._current_subscription_names = { subscription.GetName() for subscription in subscriptions }
+            
+            self._names_that_cannot_run = set()
+            self._names_to_next_work_time = {}
+            
+            for subscription in subscriptions:
+                
+                self._UpdateSubscriptionInfo( subscription )
+                
+            
+        
+    
+    def ShowSnapshot( self ):
+        
+        with self._lock:
+            
+            message = '{} subs: {}'.format( HydrusData.ToHumanInt( len( self._current_subscription_names ) ), ', '.join( self._current_subscription_names ) )
+            message += os.linesep * 2
+            message += '{} running: {}'.format( HydrusData.ToHumanInt( len( self._running_subscriptions ) ), ', '.join( self._running_subscriptions.keys() ) )
+            message += os.linesep * 2
+            message += '{} not runnable: {}'.format( HydrusData.ToHumanInt( len( self._names_that_cannot_run ) ), ', '.join( self._names_that_cannot_run ) )
+            message += os.linesep * 2
+            message += '{} next times: {}'.format( HydrusData.ToHumanInt( len( self._names_to_next_work_time ) ), ', '.join( ( '{}: {}'.format( name, HydrusData.TimestampToPrettyTimeDelta( next_work_time ) ) for ( name, next_work_time ) in self._names_to_next_work_time.items() ) ) )
+            
+            HydrusData.ShowText( message )
+            
+        
+    
+    def Shutdown( self ):
+        
+        self._shutdown = True
+        
+        self._wake_event.set()
+        
+    
+    def SubscriptionsRunning( self ):
+        
+        with self._lock:
+            
+            return self._loading_sub or len( self._running_subscriptions ) > 0
+            
+        
+    
+    def Wake( self ):
+        
+        self._wake_event.set()
+        
+    
 HydrusSerialisable.SERIALISABLE_TYPES_TO_OBJECT_TYPES[ HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION ] = Subscription
 
 class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
@@ -1410,6 +1802,25 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         self._tag_import_options = ClientImportOptions.TagImportOptions()
         
     
+    def _GetExampleNetworkContexts( self, subscription_name ):
+        
+        file_seed = self._file_seed_cache.GetNextFileSeed( CC.STATUS_UNKNOWN )
+        
+        subscription_key = self.GetNetworkJobSubscriptionKey( subscription_name )
+        
+        if file_seed is None:
+            
+            return [ ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_SUBSCRIPTION, subscription_key ), ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT ]
+            
+        
+        url = file_seed.file_seed_data
+        
+        example_nj = ClientNetworkingJobs.NetworkJobSubscription( subscription_key, 'GET', url )
+        example_network_contexts = example_nj.GetNetworkContexts()
+        
+        return example_network_contexts
+        
+    
     def _GetSerialisableInfo( self ):
         
         serialisable_gallery_seed_log = self._gallery_seed_log.GetSerialisableTuple()
@@ -1458,16 +1869,20 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
             
         
     
-    def CanWorkOnFiles( self ):
+    def BandwidthIsOK( self, subscription_name ):
         
-        file_seed = self._file_seed_cache.GetNextFileSeed( CC.STATUS_UNKNOWN )
+        example_network_contexts = self._GetExampleNetworkContexts( subscription_name )
+        
+        threshold = 90
+        
+        result = HG.client_controller.network_engine.bandwidth_manager.CanDoWork( example_network_contexts, threshold = threshold )
         
         if HG.subscription_report_mode:
             
-            HydrusData.ShowText( 'Query "' + self._query + '" CanWorkOnFiles test. Next import is ' + repr( file_seed ) + '.' )
+            HydrusData.ShowText( 'Query "' + self.GetHumanName() + '" bandwidth test. Bandwidth ok: ' + str( result ) + '.' )
             
         
-        return file_seed is not None
+        return result
         
     
     def CanCheckNow( self ):
@@ -1475,15 +1890,6 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         return not self._check_now
         
     
-    def CanCompact( self, checker_options ):
-        
-        death_period = checker_options.GetDeathFileVelocityPeriod()
-        
-        compact_before_this_source_time = self._last_check_time - ( death_period * 2 )
-        
-        return self._file_seed_cache.CanCompact( compact_before_this_source_time ) or self._gallery_seed_log.CanCompact( compact_before_this_source_time )
-        
-    
     def CanRetryFailed( self ):
         
         return self._file_seed_cache.GetFileSeedCount( CC.STATUS_ERROR ) > 0
@@ -1494,21 +1900,6 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         return self._file_seed_cache.GetFileSeedCount( CC.STATUS_VETOED ) > 0
         
     
-    def CanSync( self ):
-        
-        if HG.subscription_report_mode:
-            
-            HydrusData.ShowText( 'Query "' + self._query + '" CanSync test. Paused status is ' + str( self._paused ) + ' and check time due is ' + str( HydrusData.TimeHasPassed( self._next_check_time ) ) + ' and check_now is ' + str( self._check_now ) + '.' )
-            
-        
-        if self._paused:
-            
-            return False
-            
-        
-        return HydrusData.TimeHasPassed( self._next_check_time ) or self._check_now
-        
-    
     def CheckNow( self ):
         
         self._check_now = True
@@ -1518,14 +1909,13 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         self._status = ClientImporting.CHECKER_STATUS_OK
         
     
-    def Compact( self, checker_options ):
+    def GetBandwidthWaitingEstimate( self, subscription_name ):
         
-        death_period = checker_options.GetDeathFileVelocityPeriod()
+        example_network_contexts = self._GetExampleNetworkContexts( subscription_name )
         
-        compact_before_this_time = self._last_check_time - ( death_period * 2 )
+        ( estimate, bandwidth_network_context ) = HG.client_controller.network_engine.bandwidth_manager.GetWaitingEstimateAndContext( example_network_contexts )
         
-        self._file_seed_cache.Compact( compact_before_this_time )
-        self._gallery_seed_log.Compact( compact_before_this_time )
+        return estimate
         
     
     def GetDisplayName( self ):
@@ -1595,11 +1985,54 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetNextWorkTime( self, subscription_name ):
+        
+        if self.IsPaused():
+            
+            return None
+            
+        
+        work_times = set()
+        
+        if self.HasFileWorkToDo():
+            
+            file_bandwidth_estimate = self.GetBandwidthWaitingEstimate( subscription_name )
+            
+            if file_bandwidth_estimate == 0:
+                
+                work_times.add( 0 )
+                
+            else:
+                
+                file_work_time = HydrusData.GetNow() + file_bandwidth_estimate
+                
+                work_times.add( file_work_time )
+                
+            
+        
+        if not self.IsDead():
+            
+            work_times.add( self._next_check_time )
+            
+        
+        if len( work_times ) == 0:
+            
+            return None
+            
+        
+        return min( work_times )
+        
+    
     def GetNumURLsAndFailed( self ):
         
         return ( self._file_seed_cache.GetFileSeedCount( CC.STATUS_UNKNOWN ), len( self._file_seed_cache ), self._file_seed_cache.GetFileSeedCount( CC.STATUS_ERROR ) )
         
     
+    def GetNetworkJobSubscriptionKey( self, subscription_name ):
+        
+        return subscription_name + ': ' + self.GetHumanName()
+        
+    
     def GetQueryText( self ):
         
         return self._query
@@ -1610,6 +2043,18 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         return self._tag_import_options
         
     
+    def HasFileWorkToDo( self ):
+        
+        file_seed = self._file_seed_cache.GetNextFileSeed( CC.STATUS_UNKNOWN )
+        
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Query "' + self._query + '" HasFileWorkToDo test. Next import is ' + repr( file_seed ) + '.' )
+            
+        
+        return file_seed is not None
+        
+    
     def IsDead( self ):
         
         return self._status == ClientImporting.CHECKER_STATUS_DEAD
@@ -1625,17 +2070,46 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
         return self._paused
         
     
+    def IsSyncDue( self ):
+        
+        if HG.subscription_report_mode:
+            
+            HydrusData.ShowText( 'Query "' + self._query + '" IsSyncDue test. Paused/dead status is {}/{}, check time due is {}, and check_now is {}.'.format( self._paused, self.IsDead(), HydrusData.TimeHasPassed( self._next_check_time ), self._check_now ) )
+            
+        
+        if self._paused or self.IsDead():
+            
+            return False
+            
+        
+        return HydrusData.TimeHasPassed( self._next_check_time ) or self._check_now
+        
+    
     def PausePlay( self ):
         
         self._paused = not self._paused
         
     
-    def RegisterSyncComplete( self ):
+    def RegisterSyncComplete( self, checker_options ):
         
         self._last_check_time = HydrusData.GetNow()
         
         self._check_now = False
         
+        death_period = checker_options.GetDeathFileVelocityPeriod()
+        
+        compact_before_this_time = self._last_check_time - ( death_period * 2 )
+        
+        if self._gallery_seed_log.CanCompact( compact_before_this_time ):
+            
+            self._gallery_seed_log.Compact( compact_before_this_time )
+            
+        
+        if self._file_seed_cache.CanCompact( compact_before_this_time ):
+            
+            self._file_seed_cache.Compact( compact_before_this_time )
+            
+        
     
     def Reset( self ):
         
@@ -1698,7 +2172,10 @@ class SubscriptionQuery( HydrusSerialisable.SerialisableBase ):
                 
                 self._status = ClientImporting.CHECKER_STATUS_DEAD
                 
-                self._paused = True
+                if not self.HasFileWorkToDo():
+                    
+                    self._paused = True
+                    
                 
             
             last_next_check_time = self._next_check_time
diff --git a/include/ClientImportWatchers.py b/include/ClientImportWatchers.py
index 3bfa9bb6..a593f34c 100644
--- a/include/ClientImportWatchers.py
+++ b/include/ClientImportWatchers.py
@@ -617,7 +617,10 @@ class WatcherImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                text = text.splitlines()[0]
+                if len( text ) > 0:
+                    
+                    text = text.splitlines()[0]
+                    
                 
                 self._watcher_status = text
                 
@@ -627,7 +630,10 @@ class WatcherImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                text = text.splitlines()[0]
+                if len( text ) > 0:
+                    
+                    text = text.splitlines()[0]
+                    
                 
                 self._subject = text
                 
@@ -928,7 +934,10 @@ class WatcherImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                text = text.splitlines()[0]
+                if len( text ) > 0:
+                    
+                    text = text.splitlines()[0]
+                    
                 
                 self._file_status = text
                 
diff --git a/include/ClientImporting.py b/include/ClientImporting.py
index 5311a3ef..4be284eb 100644
--- a/include/ClientImporting.py
+++ b/include/ClientImporting.py
@@ -148,7 +148,10 @@ def THREADDownloadURL( job_key, url, url_string ):
     
     def status_hook( text ):
         
-        text = text.splitlines()[0]
+        if len( text ) > 0:
+            
+            text = text.splitlines()[0]
+            
         
         job_key.SetVariable( 'popup_text_1', text )
         
@@ -219,7 +222,10 @@ def THREADDownloadURLs( job_key, urls, title ):
     
     def status_hook( text ):
         
-        text = text.splitlines()[0]
+        if len( text ) > 0:
+            
+            text = text.splitlines()[0]
+            
         
         job_key.SetVariable( 'popup_text_2', text )
         
diff --git a/include/ClientManagers.py b/include/ClientManagers.py
new file mode 100644
index 00000000..3ba3b6b7
--- /dev/null
+++ b/include/ClientManagers.py
@@ -0,0 +1,1340 @@
+from . import ClientSearch
+from . import ClientServices
+from . import HydrusConstants as HC
+from . import HydrusExceptions
+import random
+import threading
+from . import HydrusData
+from . import ClientData
+from . import ClientConstants as CC
+from . import HydrusGlobals as HG
+import collections
+from . import HydrusTags
+import traceback
+from qtpy import QtGui as QG
+
+# now let's fill out grandparents
+def BuildServiceKeysToChildrenToParents( service_keys_to_simple_children_to_parents ):
+    
+    # important thing here, and reason why it is recursive, is because we want to preserve the parent-grandparent interleaving in list order
+    def AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, parents ):
+        
+        for parent in parents:
+            
+            if parent not in this_childs_parents:
+                
+                this_childs_parents.append( parent )
+                
+            
+            # this parent has its own parents, so the child should get those as well
+            if parent in simple_children_to_parents:
+                
+                grandparents = simple_children_to_parents[ parent ]
+                
+                AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, grandparents )
+                
+            
+        
+    
+    service_keys_to_children_to_parents = collections.defaultdict( HydrusData.default_dict_list )
+    
+    for ( service_key, simple_children_to_parents ) in service_keys_to_simple_children_to_parents.items():
+        
+        children_to_parents = service_keys_to_children_to_parents[ service_key ]
+        
+        for ( child, parents ) in list( simple_children_to_parents.items() ):
+            
+            this_childs_parents = children_to_parents[ child ]
+            
+            AddParentsAndGrandparents( simple_children_to_parents, this_childs_parents, parents )
+            
+        
+    
+    return service_keys_to_children_to_parents
+    
+def BuildServiceKeysToSimpleChildrenToParents( service_keys_to_pairs_flat ):
+    
+    service_keys_to_simple_children_to_parents = collections.defaultdict( HydrusData.default_dict_set )
+    
+    for ( service_key, pairs ) in service_keys_to_pairs_flat.items():
+        
+        service_keys_to_simple_children_to_parents[ service_key ] = BuildSimpleChildrenToParents( pairs )
+        
+    
+    return service_keys_to_simple_children_to_parents
+    
+# take pairs, make dict of child -> parents while excluding loops
+# no grandparents here
+def BuildSimpleChildrenToParents( pairs ):
+    
+    simple_children_to_parents = HydrusData.default_dict_set()
+    
+    for ( child, parent ) in pairs:
+        
+        if child == parent:
+            
+            continue
+            
+        
+        if parent in simple_children_to_parents and LoopInSimpleChildrenToParents( simple_children_to_parents, child, parent ):
+            
+            continue
+            
+        
+        simple_children_to_parents[ child ].add( parent )
+        
+    
+    return simple_children_to_parents
+    
+def CollapseTagSiblingPairs( groups_of_pairs ):
+    
+    # This now takes 'groups' of pairs in descending order of precedence
+    
+    # This allows us to mandate that local tags take precedence
+    
+    # a pair is invalid if:
+    # it causes a loop (a->b, b->c, c->a)
+    # there is already a relationship for the 'bad' sibling (a->b, a->c)
+    
+    valid_chains = {}
+    
+    for pairs in groups_of_pairs:
+        
+        pairs = list( pairs )
+        
+        pairs.sort()
+        
+        for ( bad, good ) in pairs:
+            
+            if bad == good:
+                
+                # a->a is a loop!
+                
+                continue
+                
+            
+            if bad not in valid_chains:
+                
+                we_have_a_loop = False
+                
+                current_best = good
+                
+                while current_best in valid_chains:
+                    
+                    current_best = valid_chains[ current_best ]
+                    
+                    if current_best == bad:
+                        
+                        we_have_a_loop = True
+                        
+                        break
+                        
+                    
+                
+                if not we_have_a_loop:
+                    
+                    valid_chains[ bad ] = good
+                    
+                
+            
+        
+    
+    # now we collapse the chains, turning:
+    # a->b, b->c ... e->f
+    # into
+    # a->f, b->f ... e->f
+    
+    siblings = {}
+    
+    for ( bad, good ) in list( valid_chains.items() ):
+        
+        # given a->b, want to find f
+        
+        if good in siblings:
+            
+            # f already calculated and added
+            
+            best = siblings[ good ]
+            
+        else:
+            
+            # we don't know f for this chain, so let's figure it out
+            
+            current_best = good
+            
+            while current_best in valid_chains:
+                
+                current_best = valid_chains[ current_best ] # pursue endpoint f
+                
+            
+            best = current_best
+            
+        
+        # add a->f
+        siblings[ bad ] = best
+        
+    
+    return siblings
+    
+def DeLoopTagSiblingPairs( groups_of_pairs ):
+    
+    pass
+    
+def LoopInSimpleChildrenToParents( simple_children_to_parents, child, parent ):
+    
+    potential_loop_paths = { parent }
+    
+    while True:
+        
+        new_potential_loop_paths = set()
+        
+        for potential_loop_path in potential_loop_paths:
+            
+            if potential_loop_path in simple_children_to_parents:
+                
+                new_potential_loop_paths.update( simple_children_to_parents[ potential_loop_path ] )
+                
+            
+        
+        potential_loop_paths = new_potential_loop_paths
+        
+        if child in potential_loop_paths:
+            
+            return True
+            
+        elif len( potential_loop_paths ) == 0:
+            
+            return False
+            
+        
+    
+class BitmapManager( object ):
+    
+    MAX_MEMORY_ALLOWANCE = 512 * 1024 * 1024
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._media_background_pixmap_path = None
+        self._media_background_pixmap = None
+        
+    
+    def _GetQtImageFormat( self, depth ):
+        
+        if depth == 24:
+            
+            return QG.QImage.Format_RGB888
+            
+        elif depth == 32:
+
+            return QG.QImage.Format_RGBA8888
+            
+        
+    
+    def GetQtImage( self, width, height, depth = 24 ):
+        
+        if width < 0:
+            
+            width = 20
+            
+        
+        if height < 0:
+            
+            height = 20
+            
+        
+        qt_image_format = self._GetQtImageFormat( depth )
+        
+        return QG.QImage( width, height, qt_image_format )
+        
+    
+    def GetQtPixmap( self, width, height ):
+        
+        if width < 0:
+            
+            width = 20
+            
+        
+        if height < 0:
+            
+            height = 20
+            
+        
+        key = ( width, height )
+        
+        return QG.QPixmap( width, height )
+        
+    
+    def GetQtImageFromBuffer( self, width, height, depth, data ):
+        
+        qt_image_format = self._GetQtImageFormat( depth )
+        
+        bytes_per_line = ( depth / 8 ) * width
+        
+        # no copy here
+        qt_image = QG.QImage( data, width, height, bytes_per_line, qt_image_format )
+        
+        # cheeky solution here
+        # the QImage init does not take python ownership of the data, so if it gets garbage collected, we crash
+        # so, add a beardy python ref to it, no problem :^)
+        # other anwser here is to do a .copy, but this can be a _little_ expensive and eats memory
+        qt_image.python_data_reference = data
+        
+        return qt_image
+        
+    
+    def GetQtPixmapFromBuffer( self, width, height, depth, data ):
+        
+        qt_image_format = self._GetQtImageFormat( depth )
+        
+        bytes_per_line = ( depth / 8 ) * width
+        
+        # no copy, no new data allocated
+        qt_image = QG.QImage( data, width, height, bytes_per_line, qt_image_format )
+        
+        # _should_ be a safe copy of the hot data
+        pixmap = QG.QPixmap.fromImage( qt_image )
+        
+        return pixmap
+        
+    
+    def GetMediaBackgroundPixmap( self ):
+        
+        pixmap_path = self._controller.new_options.GetNoneableString( 'media_background_bmp_path' )
+        
+        if pixmap_path != self._media_background_pixmap_path:
+            
+            self._media_background_pixmap_path = pixmap_path
+            
+            try:
+                
+                self._media_background_pixmap = QG.QPixmap( self._media_background_pixmap_path )
+                
+            except Exception as e:
+                
+                self._media_background_pixmap = None
+                
+                HydrusData.ShowText( 'Loading a bmp caused an error!' )
+                
+                HydrusData.ShowException( e )
+                
+                return None
+                
+            
+        
+        return self._media_background_pixmap
+        
+    
+class FileViewingStatsManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._lock = threading.Lock()
+        
+        self._pending_updates = {}
+        
+        self._last_update = HydrusData.GetNow()
+        
+        self._my_flush_job = self._controller.CallRepeating( 5, 60, self.REPEATINGFlush )
+        
+    
+    def _GenerateViewsRow( self, viewtype, viewtime_delta ):
+        
+        new_options = HG.client_controller.new_options
+        
+        preview_views_delta = 0
+        preview_viewtime_delta = 0
+        media_views_delta = 0
+        media_viewtime_delta = 0
+        
+        if viewtype == 'preview':
+            
+            preview_min = new_options.GetNoneableInteger( 'file_viewing_statistics_preview_min_time' )
+            preview_max = new_options.GetNoneableInteger( 'file_viewing_statistics_preview_max_time' )
+            
+            if preview_max is not None:
+                
+                viewtime_delta = min( viewtime_delta, preview_max )
+                
+            
+            if preview_min is None or viewtime_delta >= preview_min:
+                
+                preview_views_delta = 1
+                preview_viewtime_delta = viewtime_delta
+                
+            
+        elif viewtype in ( 'media', 'media_duplicates_filter' ):
+            
+            do_it = True
+            
+            if viewtime_delta == 'media_duplicates_filter' and not new_options.GetBoolean( 'file_viewing_statistics_active_on_dupe_filter' ):
+                
+                do_it = False
+                
+            
+            if do_it:
+                
+                media_min = new_options.GetNoneableInteger( 'file_viewing_statistics_media_min_time' )
+                media_max = new_options.GetNoneableInteger( 'file_viewing_statistics_media_max_time' )
+                
+                if media_max is not None:
+                    
+                    viewtime_delta = min( viewtime_delta, media_max )
+                    
+                
+                if media_min is None or viewtime_delta >= media_min:
+                    
+                    media_views_delta = 1
+                    media_viewtime_delta = viewtime_delta
+                    
+                
+            
+        
+        return ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
+        
+    
+    def _PubSubRow( self, hash, row ):
+        
+        ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) = row
+        
+        pubsub_row = ( hash, preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
+        
+        content_update = HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILE_VIEWING_STATS, HC.CONTENT_UPDATE_ADD, pubsub_row )
+        
+        service_keys_to_content_updates = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ content_update ] }
+        
+        HG.client_controller.pub( 'content_updates_data', service_keys_to_content_updates )
+        HG.client_controller.pub( 'content_updates_gui', service_keys_to_content_updates )
+        
+    
+    def REPEATINGFlush( self ):
+        
+        self.Flush()
+        
+    
+    def Flush( self ):
+        
+        with self._lock:
+            
+            if len( self._pending_updates ) > 0:
+                
+                content_updates = []
+                
+                for ( hash, ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) ) in self._pending_updates.items():
+                    
+                    row = ( hash, preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta )
+                    
+                    content_update = HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILE_VIEWING_STATS, HC.CONTENT_UPDATE_ADD, row )
+                    
+                    content_updates.append( content_update )
+                    
+                
+                service_keys_to_content_updates = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : content_updates }
+                
+                # non-synchronous
+                self._controller.Write( 'content_updates', service_keys_to_content_updates, do_pubsubs = False )
+                
+                self._pending_updates = {}
+                
+            
+        
+    
+    def FinishViewing( self, viewtype, hash, viewtime_delta ):
+        
+        if not HG.client_controller.new_options.GetBoolean( 'file_viewing_statistics_active' ):
+            
+            return
+            
+        
+        with self._lock:
+            
+            row = self._GenerateViewsRow( viewtype, viewtime_delta )
+            
+            if hash not in self._pending_updates:
+                
+                self._pending_updates[ hash ] = row
+                
+            else:
+                
+                ( preview_views_delta, preview_viewtime_delta, media_views_delta, media_viewtime_delta ) = row
+                
+                ( existing_preview_views_delta, existing_preview_viewtime_delta, existing_media_views_delta, existing_media_viewtime_delta ) = self._pending_updates[ hash ]
+                
+                self._pending_updates[ hash ] = ( existing_preview_views_delta + preview_views_delta, existing_preview_viewtime_delta + preview_viewtime_delta, existing_media_views_delta + media_views_delta, existing_media_viewtime_delta + media_viewtime_delta )
+                
+            
+        
+        self._PubSubRow( hash, row )
+        
+
+class ServicesManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._lock = threading.Lock()
+        self._keys_to_services = {}
+        self._services_sorted = []
+        
+        self.RefreshServices()
+        
+        self._controller.sub( self, 'RefreshServices', 'notify_new_services_data' )
+        
+    
+    def _GetService( self, service_key ):
+        
+        try:
+            
+            return self._keys_to_services[ service_key ]
+            
+        except KeyError:
+            
+            raise HydrusExceptions.DataMissing( 'That service was not found!' )
+            
+        
+    
+    def _SetServices( self, services ):
+        
+        self._keys_to_services = { service.GetServiceKey() : service for service in services }
+        
+        self._keys_to_services[ CC.TEST_SERVICE_KEY ] = ClientServices.GenerateService( CC.TEST_SERVICE_KEY, HC.TEST_SERVICE, 'test service' )
+        
+        key = lambda s: s.GetName()
+        
+        self._services_sorted = list( services )
+        self._services_sorted.sort( key = key )
+        
+    
+    def Filter( self, service_keys, desired_types ):
+        
+        with self._lock:
+            
+            filtered_service_keys = [ service_key for service_key in service_keys if service_key in self._keys_to_services and self._keys_to_services[ service_key ].GetServiceType() in desired_types ]
+            
+            return filtered_service_keys
+            
+        
+    
+    def FilterValidServiceKeys( self, service_keys ):
+        
+        with self._lock:
+            
+            filtered_service_keys = [ service_key for service_key in service_keys if service_key in self._keys_to_services ]
+            
+            return filtered_service_keys
+            
+        
+    
+    def GetName( self, service_key ):
+        
+        with self._lock:
+            
+            service = self._GetService( service_key )
+            
+            return service.GetName()
+            
+        
+    
+    def GetService( self, service_key ):
+        
+        with self._lock:
+            
+            return self._GetService( service_key )
+            
+        
+    
+    def GetServiceType( self, service_key ):
+        
+        with self._lock:
+            
+            return self._GetService( service_key ).GetServiceType()
+            
+        
+    
+    def GetServiceKeyFromName( self, allowed_types, service_name ):
+        
+        with self._lock:
+            
+            for service in self._services_sorted:
+                
+                if service.GetServiceType() in allowed_types and service.GetName() == service_name:
+                    
+                    return service.GetServiceKey()
+                    
+                
+            
+            raise HydrusExceptions.DataMissing()
+            
+        
+    
+    def GetServiceKeys( self, desired_types = HC.ALL_SERVICES ):
+        
+        with self._lock:
+            
+            filtered_service_keys = [ service_key for ( service_key, service ) in self._keys_to_services.items() if service.GetServiceType() in desired_types ]
+            
+            return filtered_service_keys
+            
+        
+    
+    def GetServices( self, desired_types = HC.ALL_SERVICES, randomised = True ):
+        
+        with self._lock:
+            
+            services = [ service for service in self._services_sorted if service.GetServiceType() in desired_types ]
+            
+            if randomised:
+                
+                random.shuffle( services )
+                
+            
+            return services
+            
+        
+    
+    def RefreshServices( self ):
+        
+        with self._lock:
+            
+            services = self._controller.Read( 'services' )
+            
+            self._SetServices( services )
+            
+        
+    
+    def ServiceExists( self, service_key ):
+        
+        with self._lock:
+            
+            return service_key in self._keys_to_services
+            
+        
+    
+class TagParentsManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._dirty = False
+        self._refresh_job = None
+        
+        self._service_keys_to_children_to_parents = collections.defaultdict( HydrusData.default_dict_list )
+        
+        self._RefreshParents()
+        
+        self._lock = threading.Lock()
+        
+        self._controller.sub( self, 'NotifyNewParents', 'notify_new_parents' )
+        
+    
+    def _RefreshParents( self ):
+        
+        service_keys_to_statuses_to_pairs = self._controller.Read( 'tag_parents' )
+        
+        # first collapse siblings
+        
+        siblings_manager = self._controller.tag_siblings_manager
+        
+        collapsed_service_keys_to_statuses_to_pairs = collections.defaultdict( HydrusData.default_dict_set )
+        
+        for ( service_key, statuses_to_pairs ) in service_keys_to_statuses_to_pairs.items():
+            
+            if service_key == CC.COMBINED_TAG_SERVICE_KEY:
+                
+                continue
+                
+            
+            for ( status, pairs ) in statuses_to_pairs.items():
+                
+                pairs = siblings_manager.CollapsePairs( service_key, pairs )
+                
+                collapsed_service_keys_to_statuses_to_pairs[ service_key ][ status ] = pairs
+                
+            
+        
+        # now collapse current and pending
+        
+        service_keys_to_pairs_flat = HydrusData.default_dict_set()
+        
+        for ( service_key, statuses_to_pairs ) in collapsed_service_keys_to_statuses_to_pairs.items():
+            
+            pairs_flat = statuses_to_pairs[ HC.CONTENT_STATUS_CURRENT ].union( statuses_to_pairs[ HC.CONTENT_STATUS_PENDING ] )
+            
+            service_keys_to_pairs_flat[ service_key ] = pairs_flat
+            
+        
+        # now create the combined tag service
+        
+        combined_pairs_flat = set()
+        
+        for pairs_flat in service_keys_to_pairs_flat.values():
+            
+            combined_pairs_flat.update( pairs_flat )
+            
+        
+        service_keys_to_pairs_flat[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_pairs_flat
+        
+        #
+        
+        service_keys_to_simple_children_to_parents = BuildServiceKeysToSimpleChildrenToParents( service_keys_to_pairs_flat )
+        
+        self._service_keys_to_children_to_parents = BuildServiceKeysToChildrenToParents( service_keys_to_simple_children_to_parents )
+        
+    
+    def ExpandPredicates( self, service_key, predicates, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        results = []
+        
+        with self._lock:
+            
+            for predicate in predicates:
+                
+                results.append( predicate )
+                
+                if predicate.GetType() == HC.PREDICATE_TYPE_TAG:
+                    
+                    tag = predicate.GetValue()
+                    
+                    parents = self._service_keys_to_children_to_parents[ service_key ][ tag ]
+                    
+                    for parent in parents:
+                        
+                        parent_predicate = ClientSearch.Predicate( HC.PREDICATE_TYPE_PARENT, parent )
+                        
+                        results.append( parent_predicate )
+                        
+                    
+                
+            
+            return results
+            
+        
+    
+    def ExpandTags( self, service_key, tags, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            tags_results = set( tags )
+            
+            for tag in tags:
+                
+                tags_results.update( self._service_keys_to_children_to_parents[ service_key ][ tag ] )
+                
+            
+            return tags_results
+            
+        
+    
+    def GetParents( self, service_key, tag, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_parents_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            return self._service_keys_to_children_to_parents[ service_key ][ tag ]
+            
+        
+    
+    def NotifyNewParents( self ):
+        
+        with self._lock:
+            
+            self._dirty = True
+            
+            if self._refresh_job is not None:
+                
+                self._refresh_job.Cancel()
+                
+            
+            self._refresh_job = self._controller.CallLater( 8.0, self.RefreshParentsIfDirty )
+            
+        
+    
+    def RefreshParentsIfDirty( self ):
+        
+        with self._lock:
+            
+            if self._dirty:
+                
+                self._RefreshParents()
+                
+                self._dirty = False
+                
+            
+        
+    
+class TagSiblingsManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._dirty = False
+        self._refresh_job = None
+        
+        self._service_keys_to_siblings = collections.defaultdict( dict )
+        self._service_keys_to_reverse_lookup = collections.defaultdict( dict )
+        
+        self._RefreshSiblings()
+        
+        self._lock = threading.Lock()
+        
+        self._controller.sub( self, 'NotifyNewSiblings', 'notify_new_siblings_data' )
+        
+    
+    def _CollapseTags( self, service_key, tags ):
+    
+        siblings = self._service_keys_to_siblings[ service_key ]
+        
+        return { siblings[ tag ] if tag in siblings else tag for tag in tags }
+        
+    
+    def _RefreshSiblings( self ):
+        
+        self._service_keys_to_siblings = collections.defaultdict( dict )
+        self._service_keys_to_reverse_lookup = collections.defaultdict( dict )
+        
+        local_tags_pairs = set()
+        
+        tag_repo_pairs = set()
+        
+        service_keys_to_statuses_to_pairs = self._controller.Read( 'tag_siblings' )
+        
+        for ( service_key, statuses_to_pairs ) in service_keys_to_statuses_to_pairs.items():
+            
+            all_pairs = statuses_to_pairs[ HC.CONTENT_STATUS_CURRENT ].union( statuses_to_pairs[ HC.CONTENT_STATUS_PENDING ] )
+            
+            service = self._controller.services_manager.GetService( service_key )
+            
+            if service.GetServiceType() == HC.LOCAL_TAG:
+                
+                local_tags_pairs = set( all_pairs )
+                
+            else:
+                
+                tag_repo_pairs.update( all_pairs )
+                
+            
+            siblings = CollapseTagSiblingPairs( [ all_pairs ] )
+            
+            self._service_keys_to_siblings[ service_key ] = siblings
+            
+            reverse_lookup = collections.defaultdict( list )
+            
+            for ( bad, good ) in siblings.items():
+                
+                reverse_lookup[ good ].append( bad )
+                
+            
+            self._service_keys_to_reverse_lookup[ service_key ] = reverse_lookup
+            
+        
+        combined_siblings = CollapseTagSiblingPairs( [ local_tags_pairs, tag_repo_pairs ] )
+        
+        self._service_keys_to_siblings[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_siblings
+        
+        combined_reverse_lookup = collections.defaultdict( list )
+        
+        for ( bad, good ) in combined_siblings.items():
+            
+            combined_reverse_lookup[ good ].append( bad )
+            
+        
+        self._service_keys_to_reverse_lookup[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_reverse_lookup
+        
+    
+    def CollapsePredicates( self, service_key, predicates, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            
+            results = [ predicate for predicate in predicates if predicate.GetType() != HC.PREDICATE_TYPE_TAG ]
+            
+            tag_predicates = [ predicate for predicate in predicates if predicate.GetType() == HC.PREDICATE_TYPE_TAG ]
+            
+            tags_to_predicates = {predicate.GetValue() : predicate for predicate in predicates if predicate.GetType() == HC.PREDICATE_TYPE_TAG}
+            
+            tags = list( tags_to_predicates.keys() )
+            
+            tags_to_include_in_results = set()
+            
+            for tag in tags:
+                
+                if tag in siblings:
+                    
+                    old_tag = tag
+                    old_predicate = tags_to_predicates[ old_tag ]
+                    
+                    new_tag = siblings[ old_tag ]
+                    
+                    if new_tag not in tags_to_predicates:
+                        
+                        ( old_pred_type, old_value, old_inclusive ) = old_predicate.GetInfo()
+                        
+                        new_predicate = ClientSearch.Predicate( old_pred_type, new_tag, old_inclusive )
+                        
+                        tags_to_predicates[ new_tag ] = new_predicate
+                        
+                        tags_to_include_in_results.add( new_tag )
+                        
+                    
+                    new_predicate = tags_to_predicates[ new_tag ]
+                    
+                    new_predicate.AddCounts( old_predicate )
+                    
+                else:
+                    
+                    tags_to_include_in_results.add( tag )
+                    
+                
+            
+            results.extend( [ tags_to_predicates[ tag ] for tag in tags_to_include_in_results ] )
+            
+            return results
+            
+        
+    
+    def CollapsePairs( self, service_key, pairs, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            
+            result = set()
+            
+            for ( a, b ) in pairs:
+                
+                if a in siblings:
+                    
+                    a = siblings[ a ]
+                    
+                
+                if b in siblings:
+                    
+                    b = siblings[ b ]
+                    
+                
+                result.add( ( a, b ) )
+                
+            
+            return result
+            
+        
+    
+    def CollapseStatusesToTags( self, service_key, statuses_to_tags, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            new_statuses_to_tags = HydrusData.default_dict_set()
+            
+            for ( status, tags ) in statuses_to_tags.items():
+                
+                new_statuses_to_tags[ status ] = self._CollapseTags( service_key, tags )
+                
+            
+            return new_statuses_to_tags
+            
+        
+    
+    def CollapseTag( self, service_key, tag, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            
+            if tag in siblings:
+                
+                return siblings[ tag ]
+                
+            else:
+                
+                return tag
+                
+            
+        
+    
+    def CollapseTags( self, service_key, tags, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            return self._CollapseTags( service_key, tags )
+            
+        
+    
+    def CollapseTagsToCount( self, service_key, tags_to_count, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            
+            results = collections.Counter()
+            
+            for ( tag, count ) in tags_to_count.items():
+                
+                if tag in siblings:
+                    
+                    tag = siblings[ tag ]
+                    
+                
+                results[ tag ] += count
+                
+            
+            return results
+            
+        
+    
+    def GetSibling( self, service_key, tag, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            
+            if tag in siblings:
+                
+                return siblings[ tag ]
+                
+            else:
+                
+                return None
+                
+            
+        
+    
+    def GetAllSiblings( self, service_key, tag, service_strict = False ):
+        
+        if not service_strict and self._controller.new_options.GetBoolean( 'apply_all_siblings_to_all_services' ):
+            
+            service_key = CC.COMBINED_TAG_SERVICE_KEY
+            
+        
+        with self._lock:
+            
+            siblings = self._service_keys_to_siblings[ service_key ]
+            reverse_lookup = self._service_keys_to_reverse_lookup[ service_key ]
+            
+            if tag in siblings:
+                
+                best_tag = siblings[ tag ]
+                
+            elif tag in reverse_lookup:
+                
+                best_tag = tag
+                
+            else:
+                
+                return [ tag ]
+                
+            
+            all_siblings = list( reverse_lookup[ best_tag ] )
+            
+            all_siblings.append( best_tag )
+            
+            return all_siblings
+            
+        
+    
+    def NotifyNewSiblings( self ):
+        
+        with self._lock:
+            
+            self._dirty = True
+            
+            if self._refresh_job is not None:
+                
+                self._refresh_job.Cancel()
+                
+            
+            self._refresh_job = self._controller.CallLater( 8.0, self.RefreshSiblingsIfDirty )
+            
+        
+    
+    def RefreshSiblingsIfDirty( self ):
+        
+        with self._lock:
+            
+            if self._dirty:
+                
+                self._RefreshSiblings()
+                
+                self._dirty = False
+                
+                self._controller.pub( 'notify_new_tag_display_rules' )
+                
+            
+        
+    
+class UndoManager( object ):
+    
+    def __init__( self, controller ):
+        
+        self._controller = controller
+        
+        self._commands = []
+        self._inverted_commands = []
+        self._current_index = 0
+        
+        self._lock = threading.Lock()
+        
+        self._controller.sub( self, 'Undo', 'undo' )
+        self._controller.sub( self, 'Redo', 'redo' )
+        
+    
+    def _FilterServiceKeysToContentUpdates( self, service_keys_to_content_updates ):
+        
+        filtered_service_keys_to_content_updates = {}
+        
+        for ( service_key, content_updates ) in service_keys_to_content_updates.items():
+            
+            filtered_content_updates = []
+            
+            for content_update in content_updates:
+                
+                ( data_type, action, row ) = content_update.ToTuple()
+                
+                if data_type == HC.CONTENT_TYPE_FILES:
+                    
+                    if action in ( HC.CONTENT_UPDATE_ADD, HC.CONTENT_UPDATE_DELETE, HC.CONTENT_UPDATE_UNDELETE, HC.CONTENT_UPDATE_RESCIND_PETITION, HC.CONTENT_UPDATE_ADVANCED ):
+                        
+                        continue
+                        
+                    
+                elif data_type == HC.CONTENT_TYPE_MAPPINGS:
+                    
+                    if action in ( HC.CONTENT_UPDATE_RESCIND_PETITION, HC.CONTENT_UPDATE_ADVANCED ):
+                        
+                        continue
+                        
+                    
+                else:
+                    
+                    continue
+                    
+                
+                filtered_content_update = HydrusData.ContentUpdate( data_type, action, row )
+                
+                filtered_content_updates.append( filtered_content_update )
+                
+            
+            if len( filtered_content_updates ) > 0:
+                
+                filtered_service_keys_to_content_updates[ service_key ] = filtered_content_updates
+                
+            
+        
+        return filtered_service_keys_to_content_updates
+        
+    
+    def _InvertServiceKeysToContentUpdates( self, service_keys_to_content_updates ):
+        
+        inverted_service_keys_to_content_updates = {}
+        
+        for ( service_key, content_updates ) in service_keys_to_content_updates.items():
+            
+            inverted_content_updates = []
+            
+            for content_update in content_updates:
+                
+                ( data_type, action, row ) = content_update.ToTuple()
+                
+                inverted_row = row
+                
+                if data_type == HC.CONTENT_TYPE_FILES:
+                    
+                    if action == HC.CONTENT_UPDATE_ARCHIVE: inverted_action = HC.CONTENT_UPDATE_INBOX
+                    elif action == HC.CONTENT_UPDATE_INBOX: inverted_action = HC.CONTENT_UPDATE_ARCHIVE
+                    elif action == HC.CONTENT_UPDATE_PEND: inverted_action = HC.CONTENT_UPDATE_RESCIND_PEND
+                    elif action == HC.CONTENT_UPDATE_RESCIND_PEND: inverted_action = HC.CONTENT_UPDATE_PEND
+                    elif action == HC.CONTENT_UPDATE_PETITION: inverted_action = HC.CONTENT_UPDATE_RESCIND_PETITION
+                    
+                elif data_type == HC.CONTENT_TYPE_MAPPINGS:
+                    
+                    if action == HC.CONTENT_UPDATE_ADD: inverted_action = HC.CONTENT_UPDATE_DELETE
+                    elif action == HC.CONTENT_UPDATE_DELETE: inverted_action = HC.CONTENT_UPDATE_ADD
+                    elif action == HC.CONTENT_UPDATE_PEND: inverted_action = HC.CONTENT_UPDATE_RESCIND_PEND
+                    elif action == HC.CONTENT_UPDATE_RESCIND_PEND: inverted_action = HC.CONTENT_UPDATE_PEND
+                    elif action == HC.CONTENT_UPDATE_PETITION: inverted_action = HC.CONTENT_UPDATE_RESCIND_PETITION
+                    
+                
+                inverted_content_update = HydrusData.ContentUpdate( data_type, inverted_action, inverted_row )
+                
+                inverted_content_updates.append( inverted_content_update )
+                
+            
+            inverted_service_keys_to_content_updates[ service_key ] = inverted_content_updates
+            
+        
+        return inverted_service_keys_to_content_updates
+        
+    
+    def AddCommand( self, action, *args, **kwargs ):
+        
+        with self._lock:
+            
+            inverted_action = action
+            inverted_args = args
+            inverted_kwargs = kwargs
+            
+            if action == 'content_updates':
+                
+                ( service_keys_to_content_updates, ) = args
+                
+                service_keys_to_content_updates = self._FilterServiceKeysToContentUpdates( service_keys_to_content_updates )
+                
+                if len( service_keys_to_content_updates ) == 0: return
+                
+                inverted_service_keys_to_content_updates = self._InvertServiceKeysToContentUpdates( service_keys_to_content_updates )
+                
+                if len( inverted_service_keys_to_content_updates ) == 0: return
+                
+                inverted_args = ( inverted_service_keys_to_content_updates, )
+                
+            else: return
+            
+            self._commands = self._commands[ : self._current_index ]
+            self._inverted_commands = self._inverted_commands[ : self._current_index ]
+            
+            self._commands.append( ( action, args, kwargs ) )
+            
+            self._inverted_commands.append( ( inverted_action, inverted_args, inverted_kwargs ) )
+            
+            self._current_index += 1
+            
+            self._controller.pub( 'notify_new_undo' )
+            
+        
+    
+    def GetUndoRedoStrings( self ):
+        
+        with self._lock:
+            
+            ( undo_string, redo_string ) = ( None, None )
+            
+            if self._current_index > 0:
+                
+                undo_index = self._current_index - 1
+                
+                ( action, args, kwargs ) = self._commands[ undo_index ]
+                
+                if action == 'content_updates':
+                    
+                    ( service_keys_to_content_updates, ) = args
+                    
+                    undo_string = 'undo ' + ClientData.ConvertServiceKeysToContentUpdatesToPrettyString( service_keys_to_content_updates )
+                    
+                
+            
+            if len( self._commands ) > 0 and self._current_index < len( self._commands ):
+                
+                redo_index = self._current_index
+                
+                ( action, args, kwargs ) = self._commands[ redo_index ]
+                
+                if action == 'content_updates':
+                    
+                    ( service_keys_to_content_updates, ) = args
+                    
+                    redo_string = 'redo ' + ClientData.ConvertServiceKeysToContentUpdatesToPrettyString( service_keys_to_content_updates )
+                    
+                
+            
+            return ( undo_string, redo_string )
+            
+        
+    
+    def Undo( self ):
+        
+        action = None
+        
+        with self._lock:
+            
+            if self._current_index > 0:
+                
+                self._current_index -= 1
+                
+                ( action, args, kwargs ) = self._inverted_commands[ self._current_index ]
+                
+        
+        if action is not None:
+            
+            self._controller.WriteSynchronous( action, *args, **kwargs )
+            
+            self._controller.pub( 'notify_new_undo' )
+            
+        
+    
+    def Redo( self ):
+        
+        action = None
+        
+        with self._lock:
+            
+            if len( self._commands ) > 0 and self._current_index < len( self._commands ):
+                
+                ( action, args, kwargs ) = self._commands[ self._current_index ]
+                
+                self._current_index += 1
+                
+            
+        
+        if action is not None:
+            
+            self._controller.WriteSynchronous( action, *args, **kwargs )
+            
+            self._controller.pub( 'notify_new_undo' )
+            
+        
+    
diff --git a/include/ClientMedia.py b/include/ClientMedia.py
index cc98824c..83d53090 100644
--- a/include/ClientMedia.py
+++ b/include/ClientMedia.py
@@ -473,6 +473,181 @@ def GetMediasTagCount( pool, tag_service_key, tag_display_type ):
     
     return ( current_tags_to_count, deleted_tags_to_count, pending_tags_to_count, petitioned_tags_to_count )
     
+class MediaResult( object ):
+    
+    def __init__( self, file_info_manager, tags_manager, locations_manager, ratings_manager, file_viewing_stats_manager ):
+        
+        self._file_info_manager = file_info_manager
+        self._tags_manager = tags_manager
+        self._locations_manager = locations_manager
+        self._ratings_manager = ratings_manager
+        self._file_viewing_stats_manager = file_viewing_stats_manager
+        
+    
+    def DeletePending( self, service_key ):
+        
+        try:
+            
+            service = HG.client_controller.services_manager.GetService( service_key )
+            
+        except HydrusExceptions.DataMissing:
+            
+            return
+            
+        
+        service_type = service.GetServiceType()
+        
+        if service_type in HC.TAG_SERVICES:
+            
+            self._tags_manager.DeletePending( service_key )
+            
+        elif service_type in HC.FILE_SERVICES:
+            
+            self._locations_manager.DeletePending( service_key )
+            
+        
+    
+    def Duplicate( self ):
+        
+        file_info_manager = self._file_info_manager.Duplicate()
+        tags_manager = self._tags_manager.Duplicate()
+        locations_manager = self._locations_manager.Duplicate()
+        ratings_manager = self._ratings_manager.Duplicate()
+        file_viewing_stats_manager = self._file_viewing_stats_manager.Duplicate()
+        
+        return MediaResult( file_info_manager, tags_manager, locations_manager, ratings_manager, file_viewing_stats_manager )
+        
+    
+    def GetDuration( self ):
+        
+        return self._file_info_manager.duration
+        
+    
+    def GetFileInfoManager( self ):
+        
+        return self._file_info_manager
+        
+    
+    def GetFileViewingStatsManager( self ):
+        
+        return self._file_viewing_stats_manager
+        
+    
+    def GetHash( self ):
+        
+        return self._file_info_manager.hash
+        
+    
+    def GetHashId( self ):
+        
+        return self._file_info_manager.hash_id
+        
+    
+    def GetInbox( self ):
+        
+        return self._locations_manager.GetInbox()
+        
+    
+    def GetLocationsManager( self ):
+        
+        return self._locations_manager
+        
+    
+    def GetMime( self ):
+        
+        return self._file_info_manager.mime
+        
+    
+    def GetNumFrames( self ):
+        
+        return self._file_info_manager.num_frames
+        
+    
+    def GetNumWords( self ):
+        
+        return self._file_info_manager.num_words
+        
+    
+    def GetRatingsManager( self ):
+        
+        return self._ratings_manager
+        
+    
+    def GetResolution( self ):
+        
+        return ( self._file_info_manager.width, self._file_info_manager.height )
+        
+    
+    def GetSize( self ):
+        
+        return self._file_info_manager.size
+        
+    
+    def GetTagsManager( self ):
+        
+        return self._tags_manager
+        
+    
+    def HasAudio( self ):
+        
+        return self._file_info_manager.has_audio is True
+        
+    
+    def IsStaticImage( self ):
+        
+        return self._file_info_manager.mime in HC.IMAGES and self._file_info_manager.duration in ( None, 0 )
+        
+    
+    def ProcessContentUpdate( self, service_key, content_update ):
+        
+        try:
+            
+            service = HG.client_controller.services_manager.GetService( service_key )
+            
+        except HydrusExceptions.DataMissing:
+            
+            return
+            
+        
+        service_type = service.GetServiceType()
+        
+        if service_type in HC.TAG_SERVICES:
+            
+            self._tags_manager.ProcessContentUpdate( service_key, content_update )
+            
+        elif service_type in HC.FILE_SERVICES:
+            
+            if content_update.GetDataType() == HC.CONTENT_TYPE_FILE_VIEWING_STATS:
+                
+                self._file_viewing_stats_manager.ProcessContentUpdate( content_update )
+                
+            else:
+                
+                self._locations_manager.ProcessContentUpdate( service_key, content_update )
+                
+            
+        elif service_type in HC.RATINGS_SERVICES:
+            
+            self._ratings_manager.ProcessContentUpdate( service_key, content_update )
+            
+        
+    
+    def ResetService( self, service_key ):
+        
+        self._tags_manager.ResetService( service_key )
+        self._locations_manager.ResetService( service_key )
+        
+    
+    def SetTagsManager( self, tags_manager ):
+        
+        self._tags_manager = tags_manager
+        
+    
+    def ToTuple( self ):
+        
+        return ( self._file_info_manager, self._tags_manager, self._locations_manager, self._ratings_manager )
+        
+    
 class DuplicatesManager( object ):
     
     def __init__( self, service_keys_to_dupe_statuses_to_counts ):
@@ -1919,7 +2094,7 @@ class MediaCollection( MediaList, Media ):
     
 class MediaSingleton( Media ):
     
-    def __init__( self, media_result ):
+    def __init__( self, media_result: MediaResult ):
         
         Media.__init__( self )
         
@@ -1951,6 +2126,11 @@ class MediaSingleton( Media ):
         return self._media_result.GetHash()
         
     
+    def GetHashId( self ):
+        
+        return self._media_result.GetHashId()
+        
+    
     def GetHashes( self, has_location = None, discriminant = None, not_uploaded_to = None, ordered = False ):
         
         if self.MatchesDiscriminant( has_location = has_location, discriminant = discriminant, not_uploaded_to = not_uploaded_to ):
@@ -2263,181 +2443,6 @@ class MediaSingleton( Media ):
             
         
     
-class MediaResult( object ):
-    
-    def __init__( self, file_info_manager, tags_manager, locations_manager, ratings_manager, file_viewing_stats_manager ):
-        
-        self._file_info_manager = file_info_manager
-        self._tags_manager = tags_manager
-        self._locations_manager = locations_manager
-        self._ratings_manager = ratings_manager
-        self._file_viewing_stats_manager = file_viewing_stats_manager
-        
-    
-    def DeletePending( self, service_key ):
-        
-        try:
-            
-            service = HG.client_controller.services_manager.GetService( service_key )
-            
-        except HydrusExceptions.DataMissing:
-            
-            return
-            
-        
-        service_type = service.GetServiceType()
-        
-        if service_type in HC.TAG_SERVICES:
-            
-            self._tags_manager.DeletePending( service_key )
-            
-        elif service_type in HC.FILE_SERVICES:
-            
-            self._locations_manager.DeletePending( service_key )
-            
-        
-    
-    def Duplicate( self ):
-        
-        file_info_manager = self._file_info_manager.Duplicate()
-        tags_manager = self._tags_manager.Duplicate()
-        locations_manager = self._locations_manager.Duplicate()
-        ratings_manager = self._ratings_manager.Duplicate()
-        file_viewing_stats_manager = self._file_viewing_stats_manager.Duplicate()
-        
-        return MediaResult( file_info_manager, tags_manager, locations_manager, ratings_manager, file_viewing_stats_manager )
-        
-    
-    def GetDuration( self ):
-        
-        return self._file_info_manager.duration
-        
-    
-    def GetFileInfoManager( self ):
-        
-        return self._file_info_manager
-        
-    
-    def GetFileViewingStatsManager( self ):
-        
-        return self._file_viewing_stats_manager
-        
-    
-    def GetHash( self ):
-        
-        return self._file_info_manager.hash
-        
-    
-    def GetHashId( self ):
-        
-        return self._file_info_manager.hash_id
-        
-    
-    def GetInbox( self ):
-        
-        return self._locations_manager.GetInbox()
-        
-    
-    def GetLocationsManager( self ):
-        
-        return self._locations_manager
-        
-    
-    def GetMime( self ):
-        
-        return self._file_info_manager.mime
-        
-    
-    def GetNumFrames( self ):
-        
-        return self._file_info_manager.num_frames
-        
-    
-    def GetNumWords( self ):
-        
-        return self._file_info_manager.num_words
-        
-    
-    def GetRatingsManager( self ):
-        
-        return self._ratings_manager
-        
-    
-    def GetResolution( self ):
-        
-        return ( self._file_info_manager.width, self._file_info_manager.height )
-        
-    
-    def GetSize( self ):
-        
-        return self._file_info_manager.size
-        
-    
-    def GetTagsManager( self ):
-        
-        return self._tags_manager
-        
-    
-    def HasAudio( self ):
-        
-        return self._file_info_manager.has_audio is True
-        
-    
-    def IsStaticImage( self ):
-        
-        return self._file_info_manager.mime in HC.IMAGES and self._file_info_manager.duration in ( None, 0 )
-        
-    
-    def ProcessContentUpdate( self, service_key, content_update ):
-        
-        try:
-            
-            service = HG.client_controller.services_manager.GetService( service_key )
-            
-        except HydrusExceptions.DataMissing:
-            
-            return
-            
-        
-        service_type = service.GetServiceType()
-        
-        if service_type in HC.TAG_SERVICES:
-            
-            self._tags_manager.ProcessContentUpdate( service_key, content_update )
-            
-        elif service_type in HC.FILE_SERVICES:
-            
-            if content_update.GetDataType() == HC.CONTENT_TYPE_FILE_VIEWING_STATS:
-                
-                self._file_viewing_stats_manager.ProcessContentUpdate( content_update )
-                
-            else:
-                
-                self._locations_manager.ProcessContentUpdate( service_key, content_update )
-                
-            
-        elif service_type in HC.RATINGS_SERVICES:
-            
-            self._ratings_manager.ProcessContentUpdate( service_key, content_update )
-            
-        
-    
-    def ResetService( self, service_key ):
-        
-        self._tags_manager.ResetService( service_key )
-        self._locations_manager.ResetService( service_key )
-        
-    
-    def SetTagsManager( self, tags_manager ):
-        
-        self._tags_manager = tags_manager
-        
-    
-    def ToTuple( self ):
-        
-        return ( self._file_info_manager, self._tags_manager, self._locations_manager, self._ratings_manager )
-        
-    
 class MediaSort( HydrusSerialisable.SerialisableBase ):
     
     SERIALISABLE_TYPE = HydrusSerialisable.SERIALISABLE_TYPE_MEDIA_SORT
diff --git a/include/ClientOptions.py b/include/ClientOptions.py
index 56ade752..8909b4d4 100644
--- a/include/ClientOptions.py
+++ b/include/ClientOptions.py
@@ -314,6 +314,8 @@ class ClientOptions( HydrusSerialisable.SerialisableBase ):
         self._dictionary[ 'noneable_strings' ][ 'media_background_bmp_path' ] = None
         self._dictionary[ 'noneable_strings' ][ 'http_proxy' ] = None
         self._dictionary[ 'noneable_strings' ][ 'https_proxy' ] = None
+        self._dictionary[ 'noneable_strings' ][ 'qt_style_name' ] = None
+        self._dictionary[ 'noneable_strings' ][ 'qt_stylesheet_name' ] = None
         
         self._dictionary[ 'strings' ] = {}
         
diff --git a/include/ClientParsing.py b/include/ClientParsing.py
index 99c36f10..eed58f53 100644
--- a/include/ClientParsing.py
+++ b/include/ClientParsing.py
@@ -2795,6 +2795,7 @@ STRING_TRANSFORMATION_REVERSE = 8
 STRING_TRANSFORMATION_REGEX_SUB = 9
 STRING_TRANSFORMATION_DATE_DECODE = 10
 STRING_TRANSFORMATION_INTEGER_ADDITION = 11
+STRING_TRANSFORMATION_DATE_ENCODE = 12
 
 transformation_type_str_lookup = {}
 
@@ -2808,8 +2809,9 @@ transformation_type_str_lookup[ STRING_TRANSFORMATION_CLIP_TEXT_FROM_BEGINNING ]
 transformation_type_str_lookup[ STRING_TRANSFORMATION_CLIP_TEXT_FROM_END ] = 'take the end of the string'
 transformation_type_str_lookup[ STRING_TRANSFORMATION_REVERSE ] = 'reverse text'
 transformation_type_str_lookup[ STRING_TRANSFORMATION_REGEX_SUB ] = 'regex substitution'
-transformation_type_str_lookup[ STRING_TRANSFORMATION_DATE_DECODE ] = 'date decode'
+transformation_type_str_lookup[ STRING_TRANSFORMATION_DATE_DECODE ] = 'datestring to timestamp'
 transformation_type_str_lookup[ STRING_TRANSFORMATION_INTEGER_ADDITION ] = 'integer addition'
+transformation_type_str_lookup[ STRING_TRANSFORMATION_DATE_ENCODE ] = 'timestamp to datestring'
 
 class StringConverter( HydrusSerialisable.SerialisableBase ):
     
@@ -2985,6 +2987,34 @@ class StringConverter( HydrusSerialisable.SerialisableBase ):
                     
                     s = str( timestamp )
                     
+                elif transformation_type == STRING_TRANSFORMATION_DATE_ENCODE:
+                    
+                    ( phrase, timezone ) = data
+                    
+                    try:
+                        
+                        timestamp = int( s )
+                        
+                    except:
+                        
+                        raise Exception( '"{}" was not an integer!'.format( s ) )
+                        
+                    
+                    if timezone == HC.TIMEZONE_GMT:
+                        
+                        # user wants a UTC string, so we need UTC struct
+                        
+                        struct_time = time.gmtime( timestamp )
+                        
+                    elif timezone == HC.TIMEZONE_LOCAL:
+                        
+                        # user wants a local string, so we need localtime
+                        
+                        struct_time = time.localtime( timestamp )
+                        
+                    
+                    s = time.strftime( phrase, struct_time )
+                    
                 elif transformation_type == STRING_TRANSFORMATION_INTEGER_ADDITION:
                     
                     delta = data
@@ -3063,7 +3093,11 @@ class StringConverter( HydrusSerialisable.SerialisableBase ):
             
         elif transformation_type == STRING_TRANSFORMATION_DATE_DECODE:
             
-            return 'date decode: ' + repr( data )
+            return 'datestring to timestamp: ' + repr( data )
+            
+        elif transformation_type == STRING_TRANSFORMATION_DATE_ENCODE:
+            
+            return 'timestamp to datestring: ' + repr( data )
             
         elif transformation_type == STRING_TRANSFORMATION_INTEGER_ADDITION:
             
diff --git a/include/HydrusConstants.py b/include/HydrusConstants.py
index a0691783..b3451ae4 100755
--- a/include/HydrusConstants.py
+++ b/include/HydrusConstants.py
@@ -67,7 +67,7 @@ options = {}
 # Misc
 
 NETWORK_VERSION = 18
-SOFTWARE_VERSION = 375
+SOFTWARE_VERSION = 376
 CLIENT_API_VERSION = 11
 
 SERVER_THUMBNAIL_DIMENSIONS = ( 200, 200 )
diff --git a/include/HydrusGlobals.py b/include/HydrusGlobals.py
index 4445af04..82248916 100644
--- a/include/HydrusGlobals.py
+++ b/include/HydrusGlobals.py
@@ -17,7 +17,6 @@ db_synchronous_override = None
 
 import_folders_running = False
 export_folders_running = False
-subscriptions_running = False
 
 callto_report_mode = False
 db_report_mode = False
diff --git a/include/HydrusPaths.py b/include/HydrusPaths.py
index 4f65d323..91eeeb41 100644
--- a/include/HydrusPaths.py
+++ b/include/HydrusPaths.py
@@ -370,7 +370,7 @@ def SetEnvTempDir( path ):
         
         if tmp_name in os.environ:
             
-            os.putenv( tmp_name, path )
+            os.environ[ tmp_name ] = path
             
         
     
diff --git a/include/QtPorting.py b/include/QtPorting.py
index 79e55b6d..738d23f0 100644
--- a/include/QtPorting.py
+++ b/include/QtPorting.py
@@ -13,7 +13,7 @@ if not 'QT_API' in os.environ:
 
         import PySide2
 
-        os.putenv( 'QT_API', 'pyside2' )
+        os.environ[ 'QT_API' ] = 'pyside2'
         
     except ImportError:
 
@@ -382,44 +382,31 @@ class TabBar( QW.QTabBar ):
     
     def dragEnterEvent(self, event):
 
-        if event.mimeData().formats():
-
-            event.accept()
+        if 'application/hydrus-tab' in event.mimeData().formats():
+            
+            event.ignore()
             
         else:
-
-            event.ignore()
+            
+            event.accept()
             
         
     
-    def dragMoveEvent(self, event):
-
-        if event.mimeData().formats():
-
+    def dragMoveEvent( self, event ):
+        
+        if 'application/hydrus-tab' not in event.mimeData().formats():
+            
             tab_index = self.tabAt( event.pos() )
-
+            
             if tab_index != -1:
                 
-                shift_down = event.keyboardModifiers() & QC.Qt.ShiftModifier
-
-                follow_dropped_page = not shift_down
-
-                new_options = HG.client_controller.new_options
-
-                if new_options.GetBoolean( 'reverse_page_shift_drag_behaviour' ):
-                    
-                    follow_dropped_page = not follow_dropped_page
-                    
-
-                if follow_dropped_page:
-                    
-                    self.parentWidget().setCurrentIndex( tab_index )
-                    
+                self.parentWidget().setCurrentIndex( tab_index )
                 
             
         else:
             
             event.ignore()
+            
         
     
     def lastClickedTabIndex( self ):
@@ -455,7 +442,7 @@ class TabWidgetWithDnD( QW.QTabWidget ):
         self._tab_bar = self.tabBar()
         
         self._supplementary_drop_target = None
-
+        
     
     def _LayoutPagesHelper( self ):
 
@@ -521,15 +508,11 @@ class TabWidgetWithDnD( QW.QTabWidget ):
             return
             
         
-        if HC.PLATFORM_MACOS:
-            
-            return
-            
+        my_mouse_pos = e.pos()
+        global_mouse_pos = self.mapToGlobal( my_mouse_pos )
+        tab_bar_mouse_pos = self._tab_bar.mapFromGlobal( global_mouse_pos )
         
-        global_pos = self.mapToGlobal( e.pos() )
-        pos_in_tab = self._tab_bar.mapFromGlobal( global_pos )
-        
-        if not self._tab_bar.rect().contains( pos_in_tab ):
+        if not self._tab_bar.rect().contains( tab_bar_mouse_pos ):
             
             return
             
@@ -553,6 +536,8 @@ class TabWidgetWithDnD( QW.QTabWidget ):
         
         mimeData = QC.QMimeData()
         
+        mimeData.setData( 'application/hydrus-tab', b'' )
+        
         drag = QG.QDrag( self._tab_bar )
         
         drag.setMimeData( mimeData )
@@ -561,7 +546,10 @@ class TabWidgetWithDnD( QW.QTabWidget ):
         
         cursor = QG.QCursor( QC.Qt.OpenHandCursor )
         
-        drag.setHotSpot( e.pos() - pos_in_tab )
+        drag.setHotSpot( QC.QPoint( 0, 0 ) )
+        
+        # this puts the tab pixmap exactly where we picked it up, but it looks bad
+        # drag.setHotSpot( tab_bar_mouse_pos - tab_rect.topLeft() )
         
         drag.setDragCursor( cursor.pixmap(), QC.Qt.MoveAction )
         
@@ -575,7 +563,7 @@ class TabWidgetWithDnD( QW.QTabWidget ):
             return QW.QTabWidget.dragEnterEvent( self, e )
             
         
-        if not e.mimeData().formats():
+        if 'application/hydrus-tab' in e.mimeData().formats():
             
             e.accept()
             
@@ -586,10 +574,14 @@ class TabWidgetWithDnD( QW.QTabWidget ):
         
     
     def dragMoveEvent( self, event ):
-
+        
         #if self.currentWidget() and self.currentWidget().rect().contains( self.currentWidget().mapFromGlobal( self.mapToGlobal( event.pos() ) ) ): return QW.QTabWidget.dragMoveEvent( self, event )
         
-        tab_index = self._tab_bar.tabAt( event.pos() )
+        screen_pos = self.mapToGlobal( event.pos() )
+        
+        tab_pos = self._tab_bar.mapFromGlobal( screen_pos )
+        
+        tab_index = self._tab_bar.tabAt( tab_pos )
         
         if tab_index != -1:
             
@@ -598,7 +590,7 @@ class TabWidgetWithDnD( QW.QTabWidget ):
             self.setCurrentIndex( tab_index )
             
         
-        if event.mimeData().formats():
+        if 'application/hydrus-tab' not in event.mimeData().formats():
             
             event.reject()
             
@@ -640,7 +632,7 @@ class TabWidgetWithDnD( QW.QTabWidget ):
             return QW.QTabWidget.dropEvent( self, e )
             
        
-        if len( e.mimeData().formats() ): #Page dnd has no associated mime data
+        if 'application/hydrus-tab' not in e.mimeData().formats(): #Page dnd has no associated mime data
             
             e.ignore()
             
@@ -681,8 +673,12 @@ class TabWidgetWithDnD( QW.QTabWidget ):
         e.accept()
         
         counter = self.count()
-
-        dropped_on_tab_index = self.tabBar().tabAt( e.pos() )
+        
+        screen_pos = self.mapToGlobal( e.pos() )
+        
+        tab_pos = self.tabBar().mapFromGlobal( screen_pos )
+        
+        dropped_on_tab_index = self.tabBar().tabAt( tab_pos )
         
         if source_notebook == self and dropped_on_tab_index == source_page_index:
             
@@ -1128,26 +1124,7 @@ def AdjustColour( colour, percent ):
     percent = percent / 100
     
     return QG.QColor( colour.red() + colour.red() * percent, colour.green() + colour.green() * percent, colour.blue() + colour.blue() * percent, colour.alpha() )
-
-
-def DestroyChildren( widget ):
-
-    if not widget.layout(): return
-
-    ClearLayout( widget.layout(), delete_widgets = True )
-
-    # This creates a new hidden widget, reparents the layout to it then deletes the widget.
-    # Not the nicest solution but otherwise widget.setLayout( None ) refused to work...
-    tmp = QW.QWidget()
-    tmp.setVisible( False )
-
-    tmp.setLayout( widget.layout() )
-
-    tmp.deleteLater()
-
-    widget.setLayout( None )
-
-
+    
 class BusyCursor:
     
     def __enter__( self ):
@@ -1268,10 +1245,6 @@ def Unsplit( splitter, widget ):
         widget.setVisible( False )
         
     
-def GetEffectiveMinSize( widget ):
-
-    return widget.sizeHint().toTuple() #widget.minimumSize().toTuple()
-    
 def GetSystemColour( colour ):
     
     return QG.QPalette().color( colour )
@@ -1590,6 +1563,7 @@ class AboutBox( QW.QDialog ):
         QW.QDialog.__init__( self, parent )
         
         self.setWindowFlag( QC.Qt.WindowContextHelpButtonHint, on = False )
+        
         self.setAttribute( QC.Qt.WA_DeleteOnClose )
         
         self.setWindowIcon( QG.QIcon( HG.client_controller.frame_icon_pixmap ) )
@@ -2022,9 +1996,12 @@ class Dialog( QW.QDialog ):
         return self
         
     
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__( self, exc_type, exc_val, exc_tb ):
         
-        self.deleteLater()
+        if isValid( self ):
+            
+            self.deleteLater()
+            
         
     
 class PasswordEntryDialog( Dialog ):
diff --git a/include/TestClientAPI.py b/include/TestClientAPI.py
index 94bd9d39..014cbc64 100644
--- a/include/TestClientAPI.py
+++ b/include/TestClientAPI.py
@@ -3,6 +3,7 @@ from . import ClientConstants as CC
 from . import ClientAPI
 from . import ClientLocalServer
 from . import ClientLocalServerResources
+from . import ClientManagers
 from . import ClientMedia
 from . import ClientRatings
 from . import ClientSearch
@@ -744,8 +745,8 @@ class TestClientAPI( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'tag_parents', tag_parents )
         
-        HG.test_controller.tag_siblings_manager = ClientCaches.TagSiblingsManager( HG.test_controller )
-        HG.test_controller.tag_parents_manager = ClientCaches.TagParentsManager( HG.test_controller )
+        HG.test_controller.tag_siblings_manager = ClientManagers.TagSiblingsManager( HG.test_controller )
+        HG.test_controller.tag_parents_manager = ClientManagers.TagParentsManager( HG.test_controller )
         
         # ok, now with
         
@@ -962,8 +963,6 @@ class TestClientAPI( unittest.TestCase ):
         
         expected_answer = {}
         
-        expected_answer = { 'url_type' : HC.URL_TYPE_WATCHABLE, 'url_type_string' : 'watchable url', 'match_name' : '8chan thread', 'can_parse' : True }
-        
         expected_answer[ 'normalised_url' ] = normalised_url
         expected_answer[ 'url_type' ] = HC.URL_TYPE_WATCHABLE
         expected_answer[ 'url_type_string' ] = 'watchable url'
diff --git a/include/TestClientConstants.py b/include/TestClientConstants.py
index 2fe392af..4d85f835 100644
--- a/include/TestClientConstants.py
+++ b/include/TestClientConstants.py
@@ -1,5 +1,6 @@
 from . import ClientConstants as CC
 from . import ClientGUIManagement
+from . import ClientManagers
 from . import ClientNetworking
 from . import ClientCaches
 from . import ClientServices
@@ -38,7 +39,7 @@ class TestManagers( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'services', services )
         
-        services_manager = ClientCaches.ServicesManager( HG.client_controller )
+        services_manager = ClientManagers.ServicesManager( HG.client_controller )
         
         #
         
@@ -82,7 +83,7 @@ class TestManagers( unittest.TestCase ):
         command_1_inverted = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_INBOX, { hash_1 } ) ] }
         command_2_inverted = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, { hash_2 } ) ] }
         
-        undo_manager = ClientCaches.UndoManager( HG.client_controller )
+        undo_manager = ClientManagers.UndoManager( HG.client_controller )
         
         #
         
diff --git a/include/TestClientMigration.py b/include/TestClientMigration.py
index bb5cb7e9..4a43b6a1 100644
--- a/include/TestClientMigration.py
+++ b/include/TestClientMigration.py
@@ -3,6 +3,7 @@ from . import ClientConstants as CC
 from . import ClientDB
 from . import ClientImportFileSeeds
 from . import ClientImportOptions
+from . import ClientManagers
 from . import ClientMigration
 from . import ClientServices
 from . import ClientTags
@@ -155,7 +156,7 @@ class TestMigration( unittest.TestCase ):
         
         self.WriteSynchronous( 'update_services', services )
         
-        self.services_manager = ClientCaches.ServicesManager( self )
+        self.services_manager = ClientManagers.ServicesManager( self )
         
     
     def _do_fake_imports( self ):
diff --git a/include/TestClientTags.py b/include/TestClientTags.py
index 79339a79..bb4c3725 100644
--- a/include/TestClientTags.py
+++ b/include/TestClientTags.py
@@ -1,6 +1,7 @@
 import collections
 from . import ClientCaches
 from . import ClientConstants as CC
+from . import ClientManagers
 from . import ClientMedia
 from . import ClientSearch
 from . import ClientTags
@@ -674,7 +675,7 @@ class TestTagParents( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'tag_parents', tag_parents )
         
-        cls._tag_parents_manager = ClientCaches.TagParentsManager( HG.client_controller )
+        cls._tag_parents_manager = ClientManagers.TagParentsManager( HG.client_controller )
         
     
     def test_expand_predicates( self ):
@@ -812,7 +813,7 @@ class TestTagSiblings( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'tag_siblings', tag_siblings )
         
-        cls._tag_siblings_manager = ClientCaches.TagSiblingsManager( HG.test_controller )
+        cls._tag_siblings_manager = ClientManagers.TagSiblingsManager( HG.test_controller )
         
     
     def test_collapse_predicates( self ):
diff --git a/include/TestController.py b/include/TestController.py
index 6bdabb7b..664285da 100644
--- a/include/TestController.py
+++ b/include/TestController.py
@@ -15,6 +15,7 @@ from . import HydrusGlobals as HG
 from . import ClientAPI
 from . import ClientDefaults
 from . import ClientFiles
+from . import ClientManagers
 from . import ClientNetworking
 from . import ClientNetworkingBandwidth
 from . import ClientNetworkingDomain
@@ -252,7 +253,7 @@ class Controller( object ):
         
         self._managers = {}
         
-        self.services_manager = ClientCaches.ServicesManager( self )
+        self.services_manager = ClientManagers.ServicesManager( self )
         self.client_files_manager = ClientFiles.ClientFilesManager( self )
         
         self.parsing_cache = ClientCaches.ParsingCache()
@@ -270,12 +271,12 @@ class Controller( object ):
         self.CallToThreadLongRunning( self.network_engine.MainLoop )
         
         self.tag_display_manager = ClientTags.TagDisplayManager()
-        self.tag_siblings_manager = ClientCaches.TagSiblingsManager( self )
-        self.tag_parents_manager = ClientCaches.TagParentsManager( self )
-        self._managers[ 'undo' ] = ClientCaches.UndoManager( self )
+        self.tag_siblings_manager = ClientManagers.TagSiblingsManager( self )
+        self.tag_parents_manager = ClientManagers.TagParentsManager( self )
+        self._managers[ 'undo' ] = ClientManagers.UndoManager( self )
         self.server_session_manager = HydrusSessions.HydrusSessionManagerServer()
         
-        self.bitmap_manager = ClientCaches.BitmapManager( self )
+        self.bitmap_manager = ClientManagers.BitmapManager( self )
         
         self.local_booru_manager = ClientCaches.LocalBooruCache( self )
         self.client_api_manager = ClientAPI.APIManager()
diff --git a/static/8chan.png b/static/8chan.png
deleted file mode 100644
index 28a10321240c2d02cf3d72db98f8431a53f9b6ef..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 264
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`EX7WqAsj$Z!;#Vf<nQ-%aSXBO
zeLK<G@34c2>-pIV0cDB(N2~rE@oQSNhB5Vwlg5NS5>j0X`b}&Pe=O^?FO(A3EM8?^
z{Ji|$0omDnM(eL!_uU&irFEaisU-~=uhvQ`O?%uHvF~KbxhoT=XP)3$@S%L|e5QE$
z*$<z*s4i_tWa&Bl<l3F@RWY_7{{GBjbSU}rPgeg<-K)8+pPBiMWd(oa-wt$)nOv!=
zlJo5T<;Wd#I_6!`KeH$3%SGd=OP^1x%>JH`6E=ybMfYE;wfO^<ZAqa!+22e#3-k(u
Mr>mdKI;Vst0GQr!@Bjb+

diff --git a/static/8kun.png b/static/8kun.png
new file mode 100644
index 0000000000000000000000000000000000000000..7943e64b91bde013c0774212de8f4381503b3ebf
GIT binary patch
literal 3464
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

literal 0
HcmV?d00001

diff --git a/static/default/gugs/pixiv tag search.png b/static/default/gugs/pixiv tag search.png
index 7fc6123e3dff439f4570bab82cab145360c28c11..d4441894b0fc2bf216a3adcc6b9582621f5e88a2 100644
GIT binary patch
delta 1629
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
b{~P`TY=>pOGssQO00000NkvXXu0mjf$@b-)

delta 2397
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
P00000NkvXXu0mjfOgeg)

diff --git a/static/default/gugs/twitter username lookup.png b/static/default/gugs/twitter username lookup.png
index 1f3a8713245171d7d0fa14161be6280785c7b91b..f55f9d3a4d1c188b6ddc7e0b78ea970a0bf55907 100644
GIT binary patch
delta 1743
zcmV;=1~B=;6W$GwBYy^^Nkl<Zc-rlqUx*b|9LLYuKU%x}p-5e%D3?W0gvzjo9)fy_
zz!<SW3g0YY){O8$Gnjn{6^Y4SB<wCe6vUN?La%8`cV8^8MbK=PaU-d#P+cXsEt%_|
zJEwEz%*;JA_uN0bcf~u-_lrAc=KP&Kzt1`6cV_2aDS7@A0)M4fl%Wq&tsZm%0Du4h
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

delta 2489
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
DBI>E^

diff --git a/static/default/parsers/pixiv tag search api parser.png b/static/default/parsers/pixiv tag search api parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a54e5bfd41f8a6fe6407afce68bd370498a0f1d
GIT binary patch
literal 1929
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
K-6~vylKuzLa%|)P

literal 0
HcmV?d00001

diff --git a/static/default/parsers/twitter media tweets api parser.png b/static/default/parsers/twitter media tweets api parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb1c9e0e5ff887485a4c43f612aa17f06da239b9
GIT binary patch
literal 2335
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

literal 0
HcmV?d00001

diff --git a/static/default/parsers/twitter tweet parser (video from koto.reisen).png b/static/default/parsers/twitter tweet parser (video from koto.reisen).png
new file mode 100644
index 0000000000000000000000000000000000000000..d3b45a937e79861d602bff43b39f07c3f58f830b
GIT binary patch
literal 2729
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
Wo(wlRffq;r9x%Rau3vc3DeQkpm;c-V

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/pixiv search api.png b/static/default/url_classes/pixiv search api.png
new file mode 100644
index 0000000000000000000000000000000000000000..9cdd89d531c9b76e3b4060f7e59939d1634e398c
GIT binary patch
literal 1664
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
IR&sFWKm6AFzW@LL

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/twitter tweets api - media only.png b/static/default/url_classes/twitter tweets api - media only.png
new file mode 100644
index 0000000000000000000000000000000000000000..20dacd5be77790db0ea90a69ca1fe25900743db5
GIT binary patch
literal 1959
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

literal 0
HcmV?d00001

diff --git a/static/qss/readme.txt b/static/qss/readme.txt
new file mode 100644
index 00000000..21aa723b
--- /dev/null
+++ b/static/qss/readme.txt
@@ -0,0 +1,7 @@
+Place a .css or .qss Qt Stylesheet file in here, and hydrus will provide it as an UI stylesheet option.
+
+I think to do this properly we'll want folders so we can include additional assets like images.
+
+Here's some examples, there are some QSS files buried here:
+
+https://wiki.qt.io/Gallery_of_Qt_CSS_Based_Styles
\ No newline at end of file