Assign IDs to windows.

This allows windows to be uniquely identified and shared with
clients that are running outside of the DMDirc process (e.g.
a web UI, or a remote instance).

src/com/dmdirc/FrameContainer.java

     private Optional<InputModel> inputModel = Optional.empty();
     /** The connection associated with this model. */
     private Optional<Connection> connection = Optional.empty();
+    /** The ID for this window. */
+    @Nullable private String id = null;
 
     /**
      * Instantiate new frame container.
         backBuffer.startAddingEvents();
     }
 
+    @Override
+    public String getId() {
+        if (this.id == null) {
+            throw new IllegalStateException("ID has not been set");
+        }
+        return id;
+    }
+
+    @Override
+    public void setId(@Nullable final String id) {
+        if (this.id != null) {
+            throw new IllegalStateException("ID already set");
+        }
+        this.id = id;
+    }
+
     @Override
     public String getIcon() {
         return icon;

src/com/dmdirc/interfaces/WindowModel.java

  */
 public interface WindowModel {
 
+    /**
+     * Gets a unique ID that identifies this window.
+     *
+     * @return This window's unique ID.
+     */
+    String getId();
+
+    /**
+     * Sets the ID for this window. This may only be called once; attempting to overwrite a
+     * previous ID will throw an exception.
+     *
+     * @param id The new ID for this window.
+     */
+    void setId(String id);
+
     String getIcon();
 
     String getName();

src/com/dmdirc/ui/WindowManager.java

 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicLong;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
     private final Map<WindowModel, WindowModel> parents = new HashMap<>();
     /** Mapping of parents to their children. */
     private final Multimap<WindowModel, WindowModel> children = ArrayListMultimap.create();
+    /** Mapping of IDs to windows. */
+    private final Map<String, WindowModel> windowsById = new HashMap<>();
     /** A list of frame listeners. */
     private final ListenerList listeners = new ListenerList();
+    /** Counter to use for ID assignments. */
+    private final AtomicLong nextId = new AtomicLong(0L);
 
     /**
      * Creates a new instance of {@link WindowManager}.
         checkArgument(!rootWindows.contains(window));
 
         rootWindows.add(window);
-
+        assignId(window);
         fireAddWindow(window, focus);
     }
 
 
         parents.put(child, parent);
         children.put(parent, child);
-
+        assignId(child);
         fireAddWindow(parent, child, focus);
     }
 
 
         children.get(window).forEach(WindowModel::close);
         children.removeAll(window);
+        windowsById.remove(window.getId());
 
         if (rootWindows.contains(window)) {
             fireDeleteWindow(window);
         return Collections.unmodifiableCollection(rootWindows);
     }
 
+    /**
+     * Retrieves the window with the specified ID.
+     *
+     * @param id The ID of the window to retrieve
+     * @return The window with the given ID, if it exists.
+     */
+    public Optional<WindowModel> getWindowById(final String id) {
+        return Optional.ofNullable(windowsById.get(id));
+    }
+
+    /**
+     * Assigns a unique ID to the given window.
+     *
+     * @param window The window to assign an ID to.
+     */
+    private void assignId(final WindowModel window) {
+        final String id = "WINDOW/" + nextId.getAndIncrement();
+        window.setId(id);
+        windowsById.put(id, window);
+    }
+
     /**
      * Fires the addWindow(Window) callback.
      *

test/com/dmdirc/ui/WindowManagerTest.java

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyObject;
     @Mock private WindowModel child;
     @Mock private WindowModel grandchild;
     @Mock private DMDircMBassador eventBus;
+    @Captor private ArgumentCaptor<String> idCaptor;
     private WindowManager manager;
 
     @Before
 
         assertNull(manager.findCustomWindow(customContainer, "test"));
     }
+
+    @Test
+    public void testAssignId() {
+        manager.addWindow(container);
+        manager.addWindow(container, child);
+
+        verify(container).setId(idCaptor.capture());
+        final String parentId = idCaptor.getValue();
+
+        verify(child).setId(idCaptor.capture());
+        final String childId = idCaptor.getValue();
+
+        assertNotEquals(parentId, childId);
+    }
+
+    @Test
+    public void testGetById() {
+        manager.addWindow(container);
+        manager.addWindow(container, child);
+
+        verify(container).setId(idCaptor.capture());
+        final String parentId = idCaptor.getValue();
+
+        verify(child).setId(idCaptor.capture());
+        final String childId = idCaptor.getValue();
+
+        assertSame(container, manager.getWindowById(parentId).get());
+        assertSame(child, manager.getWindowById(childId).get());
+        assertEquals(Optional.empty(), manager.getWindowById("invalid"));
+    }
+
 }