Convert "Layer Properties" dialog in a non-modal window

data/widgets/layer_properties.xml

@@ -13,12 +13,6 @@
       <label text="Opacity:" />
       <slider id="opacity" min="0" max="255" width="128" />
     </grid>
-    <separator horizontal="true" />
-    <hbox>
-      <boxfiller />
-      <button text="&amp;OK" closewindow="true" id="ok" magnet="true" width="60" />
-      <button text="&amp;Cancel" closewindow="true" id="cancel" width="60" />
-    </hbox>
   </vbox>
 </window>
 </gui>

src/app/cmd/set_layer_blend_mode.cpp

@@ -11,7 +11,10 @@
 
 #include "app/cmd/set_layer_blend_mode.h"
 
+#include "doc/document.h"
+#include "doc/document_event.h"
 #include "doc/layer.h"
+#include "doc/sprite.h"
 
 namespace app {
 namespace cmd {
@@ -35,5 +38,15 @@ void SetLayerBlendMode::onUndo()
   layer()->incrementVersion();
 }
 
+void SetLayerBlendMode::onFireNotifications()
+{
+  Layer* layer = this->layer();
+  doc::Document* doc = layer->sprite()->document();
+  DocumentEvent ev(doc);
+  ev.sprite(layer->sprite());
+  ev.layer(layer);
+  doc->notifyObservers<DocumentEvent&>(&DocumentObserver::onLayerBlendModeChange, ev);
+}
+
 } // namespace cmd
 } // namespace app

src/app/cmd/set_layer_blend_mode.h

@@ -29,6 +29,7 @@ namespace cmd {
   protected:
     void onExecute() override;
     void onUndo() override;
+    void onFireNotifications() override;
     size_t onMemSize() const override {
       return sizeof(*this);
     }

src/app/cmd/set_layer_name.cpp

@@ -11,7 +11,10 @@
 
 #include "app/cmd/set_layer_name.h"
 
+#include "doc/document.h"
+#include "doc/document_event.h"
 #include "doc/layer.h"
+#include "doc/sprite.h"
 
 namespace app {
 namespace cmd {
@@ -35,5 +38,15 @@ void SetLayerName::onUndo()
   layer()->incrementVersion();
 }
 
+void SetLayerName::onFireNotifications()
+{
+  Layer* layer = this->layer();
+  doc::Document* doc = layer->sprite()->document();
+  DocumentEvent ev(doc);
+  ev.sprite(layer->sprite());
+  ev.layer(layer);
+  doc->notifyObservers<DocumentEvent&>(&DocumentObserver::onLayerNameChange, ev);
+}
+
 } // namespace cmd
 } // namespace app

src/app/cmd/set_layer_name.h

@@ -26,6 +26,7 @@ namespace cmd {
   protected:
     void onExecute() override;
     void onUndo() override;
+    void onFireNotifications() override;
     size_t onMemSize() const override {
       return sizeof(*this);
     }

src/app/cmd/set_layer_opacity.cpp

@@ -11,7 +11,10 @@
 
 #include "app/cmd/set_layer_opacity.h"
 
+#include "doc/document.h"
+#include "doc/document_event.h"
 #include "doc/layer.h"
+#include "doc/sprite.h"
 
 namespace app {
 namespace cmd {
@@ -35,5 +38,15 @@ void SetLayerOpacity::onUndo()
   layer()->incrementVersion();
 }
 
+void SetLayerOpacity::onFireNotifications()
+{
+  Layer* layer = this->layer();
+  doc::Document* doc = layer->sprite()->document();
+  DocumentEvent ev(doc);
+  ev.sprite(layer->sprite());
+  ev.layer(layer);
+  doc->notifyObservers<DocumentEvent&>(&DocumentObserver::onLayerOpacityChange, ev);
+}
+
 } // namespace cmd
 } // namespace app

src/app/cmd/set_layer_opacity.h

@@ -28,6 +28,7 @@ namespace cmd {
   protected:
     void onExecute() override;
     void onUndo() override;
+    void onFireNotifications() override;
     size_t onMemSize() const override {
       return sizeof(*this);
     }

src/app/commands/cmd_layer_properties.cpp

@@ -9,21 +9,24 @@
 #include "config.h"
 #endif
 
-#include "base/bind.h"
-#include "ui/ui.h"
-
 #include "app/app.h"
 #include "app/cmd/set_layer_blend_mode.h"
 #include "app/cmd/set_layer_name.h"
 #include "app/cmd/set_layer_opacity.h"
 #include "app/commands/command.h"
+#include "app/console.h"
 #include "app/context_access.h"
 #include "app/modules/gui.h"
 #include "app/transaction.h"
+#include "app/ui_context.h"
+#include "base/bind.h"
+#include "base/scoped_value.h"
 #include "doc/document.h"
+#include "doc/document_event.h"
 #include "doc/image.h"
 #include "doc/layer.h"
 #include "doc/sprite.h"
+#include "ui/ui.h"
 
 #include "generated_layer_properties.h"
 
@@ -37,18 +40,21 @@ public:
   Command* clone() const override { return new LayerPropertiesCommand(*this); }
 
 protected:
-  bool onEnabled(Context* context);
-  void onExecute(Context* context);
+  bool onEnabled(Context* context) override;
+  void onExecute(Context* context) override;
 };
 
-class LayerPropertiesWindow : public app::gen::LayerProperties {
-public:
+class LayerPropertiesWindow;
+static LayerPropertiesWindow* g_window = nullptr;
 
-  LayerPropertiesWindow(const LayerImage* layer)
-    : m_layer(const_cast<LayerImage*>(layer))
-    , m_oldBlendMode(layer->blendMode())
-    , m_oldOpacity(layer->opacity()) {
-    name()->setText(layer->name().c_str());
+class LayerPropertiesWindow : public app::gen::LayerProperties
+                            , public doc::ContextObserver
+                            , public doc::DocumentObserver {
+public:
+  LayerPropertiesWindow()
+    : m_timer(250, this)
+    , m_layer(nullptr)
+    , m_selfUpdate(false) {
     name()->setMinSize(gfx::Size(128, 0));
     name()->setExpansive(true);
 
@@ -68,18 +74,68 @@ public:
     mode()->addItem("Saturation");
     mode()->addItem("Color");
     mode()->addItem("Luminosity");
-    mode()->setSelectedItemIndex((int)layer->blendMode());
-    opacity()->setValue(layer->opacity());
 
-    mode()->setEnabled(!layer->isBackground());
-    opacity()->setEnabled(!layer->isBackground());
-
-    mode()->Change.connect(Bind<void>(&LayerPropertiesWindow::onLayerPropsChange, this));
-    opacity()->Change.connect(Bind<void>(&LayerPropertiesWindow::onLayerPropsChange, this));
+    name()->EntryChange.connect(Bind<void>(&LayerPropertiesWindow::onShowChange, this));
+    mode()->Change.connect(Bind<void>(&LayerPropertiesWindow::onShowChange, this));
+    opacity()->Change.connect(Bind<void>(&LayerPropertiesWindow::onShowChange, this));
+    m_timer.Tick.connect(Bind<void>(&LayerPropertiesWindow::onCommitChange, this));
 
     remapWindow();
     centerWindow();
     load_window_pos(this, "LayerProperties");
+
+    UIContext::instance()->addObserver(this);
+  }
+
+  ~LayerPropertiesWindow() {
+    UIContext::instance()->removeObserver(this);
+  }
+
+  void setLayer(LayerImage* layer) {
+    // Save uncommited changes
+    if (m_layer) {
+      if (m_timer.isRunning())
+        onCommitChange();
+
+      document()->removeObserver(this);
+      m_layer = nullptr;
+    }
+
+    m_timer.stop();
+    m_layer = const_cast<LayerImage*>(layer);
+
+    base::ScopedValue<bool> switchSelf(m_selfUpdate, true, false);
+
+    if (m_layer) {
+      document()->addObserver(this);
+
+      m_oldName = layer->name();
+      m_oldBlendMode = layer->blendMode();
+      m_oldOpacity = layer->opacity();
+
+      name()->setText(layer->name().c_str());
+      name()->setEnabled(true);
+      mode()->setSelectedItemIndex((int)layer->blendMode());
+      mode()->setEnabled(!layer->isBackground());
+      opacity()->setValue(layer->opacity());
+      opacity()->setEnabled(!layer->isBackground());
+    }
+    else {
+      name()->setText("No Layer");
+      name()->setEnabled(false);
+      mode()->setEnabled(false);
+      opacity()->setEnabled(false);
+    }
+  }
+
+private:
+
+  app::Document* document() {
+    ASSERT(m_layer);
+    if (m_layer)
+      return static_cast<app::Document*>(m_layer->sprite()->document());
+    else
+      return nullptr;
   }
 
   std::string nameValue() const {
@@ -94,30 +150,109 @@ public:
     return opacity()->getValue();
   }
 
-protected:
-
   bool onProcessMessage(ui::Message* msg) override {
     switch (msg->type()) {
+
       case kCloseMessage:
-        m_layer->setBlendMode(m_oldBlendMode);
-        m_layer->setOpacity(m_oldOpacity);
+        // Save changes before we close the window
+        setLayer(nullptr);
         save_window_pos(this, "LayerProperties");
+
+        deferDelete();
+        g_window = nullptr;
         break;
+
     }
     return Window::onProcessMessage(msg);
   }
 
-  void onLayerPropsChange() {
+  void onShowChange() {
+    if (m_selfUpdate)
+      return;
+
+    m_layer->setName(nameValue());
     m_layer->setBlendMode(blendModeValue());
     m_layer->setOpacity(opacityValue());
+    m_timer.start();
 
-    update_screen_for_document(
-      static_cast<app::Document*>(m_layer->sprite()->document()));
+    update_screen_for_document(document());
   }
 
+  void onCommitChange() {
+    base::ScopedValue<bool> switchSelf(m_selfUpdate, true, false);
+
+    m_timer.stop();
+
+    std::string newName = nameValue();
+    int newOpacity = opacityValue();
+    BlendMode newBlendMode = blendModeValue();
+
+    m_layer->setName(m_oldName);
+    m_layer->setBlendMode(m_oldBlendMode);
+    m_layer->setOpacity(m_oldOpacity);
+
+    if (newName != m_layer->name() ||
+        newOpacity != m_layer->opacity() ||
+        newBlendMode != m_layer->blendMode()) {
+      try {
+        ContextWriter writer(UIContext::instance());
+        Transaction transaction(writer.context(), "Set Layer Properties");
+
+        if (newName != m_layer->name())
+          transaction.execute(new cmd::SetLayerName(writer.layer(), newName));
+
+        if (newOpacity != m_layer->opacity())
+          transaction.execute(new cmd::SetLayerOpacity(static_cast<LayerImage*>(writer.layer()), newOpacity));
+
+        if (newBlendMode != m_layer->blendMode())
+          transaction.execute(new cmd::SetLayerBlendMode(static_cast<LayerImage*>(writer.layer()), newBlendMode));
+
+        transaction.commit();
+      }
+      catch (const std::exception& e) {
+        Console::showException(e);
+      }
+
+      update_screen_for_document(document());
+    }
+  }
+
+  // ContextObserver impl
+  void onActiveSiteChange(const Site& site) override {
+    if (isVisible())
+      setLayer(dynamic_cast<LayerImage*>(const_cast<Layer*>(site.layer())));
+    else if (m_layer)
+      setLayer(nullptr);
+  }
+
+  // DocumentObserver impl
+  void onLayerNameChange(DocumentEvent& ev) override {
+    updateFromLayer(ev.layer());
+  }
+
+  void onLayerOpacityChange(DocumentEvent& ev) override {
+    updateFromLayer(ev.layer());
+  }
+
+  void onLayerBlendModeChange(DocumentEvent& ev) override {
+    updateFromLayer(ev.layer());
+  }
+
+  void updateFromLayer(Layer* layer) {
+    if (m_selfUpdate)
+      return;
+
+    // Cancel current editions (just in case)
+    m_timer.stop();
+    setLayer(dynamic_cast<LayerImage*>(layer));
+  }
+
+  Timer m_timer;
   LayerImage* m_layer;
+  std::string m_oldName;
   BlendMode m_oldBlendMode;
   int m_oldOpacity;
+  bool m_selfUpdate;
 };
 
 LayerPropertiesCommand::LayerPropertiesCommand()
@@ -135,40 +270,14 @@ bool LayerPropertiesCommand::onEnabled(Context* context)
 
 void LayerPropertiesCommand::onExecute(Context* context)
 {
-  const ContextReader reader(context);
-  const LayerImage* layer = static_cast<const LayerImage*>(reader.layer());
+  ContextReader reader(context);
+  LayerImage* layer = static_cast<LayerImage*>(reader.layer());
 
-  LayerPropertiesWindow window(layer);
+  if (!g_window)
+    g_window = new LayerPropertiesWindow;
 
-  window.openWindowInForeground();
-
-  if (window.getKiller() == window.ok()) {
-    std::string newName = window.nameValue();
-    int newOpacity = window.opacityValue();
-    BlendMode newBlendMode = window.blendModeValue();
-
-    if (newName != layer->name() ||
-        newOpacity != layer->opacity() ||
-        newBlendMode != layer->blendMode()) {
-      ContextWriter writer(reader);
-      {
-        Transaction transaction(writer.context(), "Set Layer Properties");
-
-        if (newName != layer->name())
-          transaction.execute(new cmd::SetLayerName(writer.layer(), newName));
-
-        if (newOpacity != layer->opacity())
-          transaction.execute(new cmd::SetLayerOpacity(static_cast<LayerImage*>(writer.layer()), newOpacity));
-
-        if (newBlendMode != layer->blendMode())
-          transaction.execute(new cmd::SetLayerBlendMode(static_cast<LayerImage*>(writer.layer()), newBlendMode));
-
-        transaction.commit();
-      }
-    }
-  }
-
-  update_screen_for_document(reader.document());
+  g_window->setLayer(layer);
+  g_window->openWindow();
 }
 
 Command* CommandFactory::createLayerPropertiesCommand()

src/app/ui/timeline.cpp

@@ -1032,6 +1032,11 @@ void Timeline::onSelectionChanged(doc::DocumentEvent& ev)
   invalidate();
 }
 
+void Timeline::onLayerNameChange(doc::DocumentEvent& ev)
+{
+  invalidate();
+}
+
 void Timeline::onStateChanged(Editor* editor)
 {
   m_aniControls.updateUsingEditor(editor);

src/app/ui/timeline.h

@@ -111,6 +111,7 @@ namespace app {
     void onAddFrame(doc::DocumentEvent& ev) override;
     void onRemoveFrame(doc::DocumentEvent& ev) override;
     void onSelectionChanged(doc::DocumentEvent& ev) override;
+    void onLayerNameChange(doc::DocumentEvent& ev) override;
 
     // app::Context slots.
     void onAfterCommandExecution(CommandExecutionEvent& ev);

src/doc/document_observer.h

@@ -40,6 +40,9 @@ namespace doc {
     virtual void onSpriteSizeChanged(DocumentEvent& ev) { }
     virtual void onSpriteTransparentColorChanged(DocumentEvent& ev) { }
 
+    virtual void onLayerNameChange(DocumentEvent& ev) { }
+    virtual void onLayerOpacityChange(DocumentEvent& ev) { }
+    virtual void onLayerBlendModeChange(DocumentEvent& ev) { }
     virtual void onLayerRestacked(DocumentEvent& ev) { }
     virtual void onLayerMergedDown(DocumentEvent& ev) { }