MessageQueue implementation now uses checked weak_ptr receivers for

broadcasts. This solves an issue where the message queue may prevent
components (like views) from getting cleaned up if they don't unregister
before they are discarded.

src/core/runtime/MessageQueue.cpp

@@ -132,7 +132,8 @@ void MessageQueue::RegisterForBroadcasts(IMessageTargetPtr target) {
 void MessageQueue::UnregisterForBroadcasts(IMessageTarget *target) {
     LockT lock(this->queueMutex);
     for (auto it : this->receivers) {
-        if (it.get() == target) {
+        auto shared = it.lock();
+        if (shared && shared.get() == target) {
             this->receivers.erase(it);
             return;
         }
@@ -242,19 +243,40 @@ void MessageQueue::Dispatch(IMessagePtr message) {
         message->Target()->ProcessMessage(*message);
     }
     else {
-        std::set<IMessageTargetPtr> copy;
+        std::set<IWeakMessageTarget, WeakPtrLess> copy;
 
+        /* copy to dispatch outside of a lock */
         {
             LockT lock(this->queueMutex);
-
             std::copy(
                 receivers.begin(),
                 receivers.end(),
                 std::inserter(copy, copy.begin()));
         }
 
+        /* dispatch */
+        bool prune = false;
         for (auto receiver : copy) {
-            receiver->ProcessMessage(*message);
+            auto shared = receiver.lock();
+            if (shared) {
+                shared->ProcessMessage(*message);
+            }
+            else {
+                prune = true;
+            }
+        }
+
+        if (prune) { /* at least one of our weak_ptrs is dead. */
+            LockT lock(this->queueMutex);
+            auto it = this->receivers.begin();
+            while (it != this->receivers.end()) {
+                if (it->expired()) {
+                    it = this->receivers.erase(it);
+                }
+                else {
+                    ++it;
+                }
+            }
         }
     }
 }

src/core/runtime/MessageQueue.h

@@ -65,15 +65,25 @@ namespace musik { namespace core { namespace runtime {
             }
 
         private:
+            typedef std::weak_ptr<IMessageTarget> IWeakMessageTarget;
+
+
             struct EnqueuedMessage {
                 IMessagePtr message;
                 std::chrono::milliseconds time;
             };
 
+            struct WeakPtrLess { /* https://stackoverflow.com/a/12875729 */
+                template <typename T>
+                bool operator() (const std::weak_ptr<T>& l, const std::weak_ptr<T>& r) const {
+                    return l.lock().get() < r.lock().get();
+                }
+            };
+
             std::mutex queueMutex;
             std::list<EnqueuedMessage*> queue;
             std::list<EnqueuedMessage*> dispatch;
-            std::set<IMessageTargetPtr> receivers;
+            std::set<IWeakMessageTarget, WeakPtrLess> receivers;
             std::condition_variable_any waitForDispatch;
             std::atomic<int64_t> nextMessageTime;
 

src/musikcube/app/layout/SettingsLayout.cpp

@@ -544,6 +544,7 @@ void SettingsLayout::OnAddedToParent(IWindow* parent) {
     auto receiver = this;
 #endif
     MessageQueue().RegisterForBroadcasts(receiver->shared_from_this());
+    MessageQueue().RegisterForBroadcasts(receiver->shared_from_this());
 }
 
 void SettingsLayout::OnRemovedFromParent(IWindow* parent) {