aws-cfn-stacker 0.0.5 → 0.0.6

data/ui/src/com/dldinternet/aws/cfn/stacker/desktop/client/widget/WindowManager.java

@@ -0,0 +1,226 @@
+/**
+ * Sencha GXT 3.1.1 - Sencha for GWT
+ * Copyright(c) 2007-2014, Sencha, Inc.
+ * licensing@sencha.com
+ *
+ * http://www.sencha.com/products/gxt/license/
+ */
+package com.dldinternet.aws.cfn.stacker.desktop.client.widget;
+
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.ui.Widget;
+import com.sencha.gxt.widget.core.client.Window;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Provides state management for a list of windows.
+ */
+public class WindowManager {
+
+  private static class HandlerRegistrations {
+
+    private List<HandlerRegistration> handlerRegistrations = new LinkedList<HandlerRegistration>();
+
+    private void addHandlerRegistration(HandlerRegistration handlerRegistration) {
+      handlerRegistrations.add(handlerRegistration);
+    }
+
+    private void removeRegisteredHandlers() {
+      for (HandlerRegistration handlerRegistration : handlerRegistrations) {
+        handlerRegistration.removeHandler();
+      }
+      handlerRegistrations.clear();
+    }
+
+  }
+
+  private class WindowDescriptor {
+
+    private boolean isMinimized;
+    private TaskButton taskButton;
+    private HandlerRegistrations handlerRegistrations;
+
+    private HandlerRegistrations getHandlerRegistrations() {
+      if (handlerRegistrations == null) {
+        handlerRegistrations = new HandlerRegistrations();
+      }
+      return handlerRegistrations;
+    }
+
+    private TaskButton getTaskButton() {
+      return taskButton;
+    }
+
+    private boolean isMinimized() {
+      return isMinimized;
+    }
+
+    private void setMinimized(boolean isMinimized) {
+      this.isMinimized = isMinimized;
+    }
+
+    private void setTaskButton(TaskButton taskButton) {
+      this.taskButton = taskButton;
+    }
+
+  }
+
+  private Map<Window, WindowDescriptor> windows = new LinkedHashMap<Window, WindowDescriptor>();
+
+  /**
+   * Adds a window to the list of managed windows
+   * 
+   * @param window the window to add
+   * @return true if the window was not already in the list
+   */
+  public boolean add(Window window) {
+    boolean isAdded;
+    if (contains(window)) {
+      isAdded = false;
+    } else {
+      windows.put(window, new WindowDescriptor());
+      isAdded = true;
+    }
+    return isAdded;
+  }
+
+  /**
+   * Adds a handler registration for the specified window. The handler
+   * registrations for a window may be removed using
+   * {@link #removeRegisteredHandlers(com.sencha.gxt.widget.core.client.Window)}.
+   * 
+   * @param window the window
+   * @param handlerRegistration a handler association for the window
+   * 
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public void addHandlerRegistration(Window window, HandlerRegistration handlerRegistration) {
+    getWindowDescriptor(window).getHandlerRegistrations().addHandlerRegistration(handlerRegistration);
+  }
+
+  /**
+   * Returns true if the specified window is in the list of managed windows.
+   * 
+   * @param window the window to check
+   * @return true if the specified window is in the list of managed windows
+   */
+  public boolean contains(Window window) {
+    return windows.containsKey(window);
+  }
+
+  /**
+   * Returns the window that contains the specified widget as its top level
+   * widget, or null if no window contains the widget.
+   * 
+   * @param widget the widget to search for
+   * @return the window containing the widget as its top level wiget, or null if
+   *         no windows contains the widget
+   */
+  public Window find(Widget widget) {
+    for (Window window : getWindows()) {
+      if (window.getWidget() == widget) {
+        return window;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns the task button associated with the specified window.
+   * 
+   * @param window the window
+   * @return the task button associated with the window
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public TaskButton getTaskButton(Window window) {
+    return getWindowDescriptor(window).getTaskButton();
+  }
+
+  /**
+   * Returns an iterable of managed windows.
+   * 
+   * @return an iterable of managed windows
+   */
+  public Iterable<Window> getWindows() {
+    return windows.keySet();
+  }
+
+  /**
+   * Returns true if the specified window is minimized.
+   * 
+   * @param window the window
+   * @return true if the specified window is minimized.
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public boolean isMinimized(Window window) {
+    return getWindowDescriptor(window).isMinimized();
+  }
+
+  /**
+   * Removes the specified window from the list of managed windows.
+   * 
+   * @param window the window
+   */
+  public void remove(Window window) {
+    windows.remove(window);
+  }
+
+  /**
+   * Removes the handlers registered against the specified window.
+   * 
+   * @param window the window
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public void removeRegisteredHandlers(Window window) {
+    getWindowDescriptor(window).getHandlerRegistrations().removeRegisteredHandlers();
+  }
+
+  /**
+   * Sets the minimized state of the specified window.
+   * 
+   * @param window the window
+   * @param isMinimized true if the window is minimized
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public void setMinimized(Window window, boolean isMinimized) {
+    getWindowDescriptor(window).setMinimized(isMinimized);
+  }
+
+  /**
+   * Sets the task button associated with the specified window.
+   * 
+   * @param window the window
+   * @param taskButton the task button associated with the window
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  public void setTaskButton(Window window, TaskButton taskButton) {
+    getWindowDescriptor(window).setTaskButton(taskButton);
+  }
+
+  /**
+   * Returns the descriptor for the specified window.
+   * 
+   * @param window the window
+   * @return the descriptor
+   * @throws IllegalArgumentException if the window is not in the list of
+   *           managed windows
+   */
+  private WindowDescriptor getWindowDescriptor(Window window) {
+    WindowDescriptor windowDescriptor = windows.get(window);
+    if (windowDescriptor == null) {
+      throw new IllegalArgumentException("window is not in list of managed windows");
+    }
+    return windowDescriptor;
+  }
+
+}

data/ui/src/com/dldinternet/aws/cfn/stacker/desktopapp/DesktopApp.gwt.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Sencha GXT 3.1.1 - Sencha for GWT
+    Copyright(c) 2007-2014, Sencha, Inc.
+    licensing@sencha.com
+
+    http://www.sencha.com/products/gxt/license/
+
+-->
+<module rename-to='desktopapp'>
+  <inherits name='com.dldinternet.aws.cfn.stacker.desktop.Desktop' />
+  <inherits name="com.google.gwt.logging.Logging" />
+  <inherits name='com.sencha.gxt.chart.Chart' />
+
+  <set-property name="gxt.logging.enabled" value="false" />
+  <set-property name="gwt.logging.logLevel" value="INFO" />
+  <set-property name="gwt.logging.consoleHandler" value="ENABLED" />
+  <set-property name="gwt.logging.popupHandler" value="DISABLED" />
+
+  <!-- Comment out the following line to disable readable style names -->
+  <!-- <set-configuration-property name='CssResource.style' value='pretty' /> -->
+
+  <entry-point class='com.dldinternet.aws.cfn.stacker.desktopapp.client.DesktopApp' />
+
+  <add-linker name="xsiframe" />
+</module>

data/ui/src/com/dldinternet/aws/cfn/stacker/desktopapp/client/DesktopApp.java

@@ -0,0 +1,304 @@
+/**
+ * Sencha GXT 3.1.1 - Sencha for GWT
+ * Copyright(c) 2007-2014, Sencha, Inc.
+ * licensing@sencha.com
+ *
+ * http://www.sencha.com/products/gxt/license/
+ */
+package com.dldinternet.aws.cfn.stacker.desktopapp.client;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StorageProvider;
+import com.google.gwt.core.client.EntryPoint;
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.GWT.UncaughtExceptionHandler;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.user.client.History;
+import com.google.gwt.user.client.ui.HasWidgets;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.google.gwt.user.client.ui.UIObject;
+import com.dldinternet.aws.cfn.stacker.desktop.client.layout.DesktopLayoutType;
+import com.dldinternet.aws.cfn.stacker.desktop.client.widget.ShortcutCell.ShortcutCellAppearance;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LoginEvent;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LoginEvent.LoginHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LogoutEvent;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LogoutEvent.LogoutHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.LoginServiceProvider;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.ProfileServiceProvider;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.utility.Prompt;
+import com.sencha.gxt.widget.core.client.box.AlertMessageBox;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A sample application that provides a basic desktop capability in a browser
+ * window. This includes a start menu, shortcuts and a task bar with buttons for
+ * each active application, as well as support for multiple users, each with
+ * their own profile settings. Desktop applications include:
+ * <dl>
+ * <dt>File Manager</dt>
+ * <dd>Uses a {@link com.sencha.gxt.widget.core.client.treegrid.TreeGrid} to provides access to a hierarchical,
+ * browser-based file system, which is persistent on browsers that support HTML5
+ * Local Storage. Users may create folders, documents, browser shortcuts, and
+ * other files, rename files and drag and drop to move files in the file system.
+ * As file operations occur, open applications respond appropriately (e.g. to
+ * indicate renamed or moved files).</dd>
+ * <dt>Word Processor</dt>
+ * <dd>Uses a {@link com.sencha.gxt.widget.core.client.form.HtmlEditor} to provides a simple rich editing capability
+ * with documents that can be stored locally in the browser based file system.
+ * Automatically propagates saved changes to other Word Processor windows,
+ * closes if the document is deleted in File Manager, as well as handling
+ * documents that are renamed or moved using File Manager.</dd>
+ * <dt>Browser</dt>
+ * <dd>Uses a {@link com.google.gwt.user.client.ui.Frame} to provide a browser-within-a-browser that displays
+ * a browser web page within the desktop. Although this may sound like a
+ * gimmick, it's amazing how useful it can be to display multiple web pages
+ * simultaneously in conjunction with the {@link DesktopLayoutType#TILE}
+ * feature.</dd>
+ * <dt>Spreadsheet</dt>
+ * <dd>Uses a {@link com.sencha.gxt.widget.core.client.grid.Grid} to provide a simple spreadsheet capability, including
+ * sorting, column and row move, insert and delete as well as formulas and
+ * charts.</dd>
+ * <dt>Program</dt>
+ * <dd>Uses <code>JSNI</code> to provide a simple JavaScript snippet
+ * interpreter, including use of references to the page's window object and
+ * call-backs to a Java method.</dd>
+ * </dl>
+ * In addition to highlighting the capability of the GXT components and
+ * providing useful, reusable function, the desktop application illustrates a
+ * number of best practices for creating complex, interactive real-world
+ * applications.
+ * <p/>
+ * <ul>
+ * <li>Use of an enhanced Model View Presenter (MVP) pattern to improve
+ * separation of concerns and simplify testing.</li>
+ * <ul>
+ * <li>Model - the structured data used by the application</li>
+ * <li>View - the components that display information and receive user input.
+ * The View receives data and commands from the Presenter via the View interface
+ * and sends Events to the Presenter using the Presenter interface. The actual
+ * widgets the View uses to display the data are hidden from the Presenter. To
+ * paraphrase Einstein, "The View is as simple as possible, but no simpler."</li>
+ * <li>Presenter - the components that prepare Models for display and act on
+ * events from the user. The Presenter sends commands and data to the View via
+ * the View interface. The Presenter receives events from the View via the
+ * Presenter interface. The Presenter is generally responsible for creating the
+ * View and connecting it to the application's user interface.</li>
+ * </ul>
+ * <li>Use of a Bus to decouple providers and consumers</li>
+ * <ul>
+ * <li>Event Bus - broadcast application level events from one producer to zero
+ * or more consumers</li>
+ * <li>Service Bus - request a service (with optional response) from one and
+ * only one provider</li>
+ * </ul>
+ * <li>Use of encapsulated field access in declaring type to support lazy
+ * instantiation and initialization as well as implicit order of execution</li>
+ * </ul>
+ * <p/>
+ * In addition, this application illustrates the use of a number of GWT and
+ * Sencha technologies, including:
+ * <ul>
+ * <li>GWT Editor / Driver Framework - {@link LoginView}</li>
+ * <li>GWT AutoBeans - {@link ProfileModel} and {@link ProfileFactory}</li>
+ * <li>GWT / Sencha Appearances - {@link ShortcutCellAppearance}</li>
+ * </ul>
+ * <p/>
+ * If the browser does not support HTML5 Local Storage, or it is not configured
+ * for use with the application, this application will prompt the user whether
+ * to degrade gracefully to temporary (in-memory) storage that will be freed
+ * when the browser terminates or the the browser window is refreshed.
+ * <p/>
+ * To request that the desktop application prompt the user to clear all local
+ * storage for all users of this application, add <code>#clear</code> to the
+ * application URL.
+ * <p/>
+ * This sample application is under continuing development. The API is subject
+ * to change without notice.
+ */
+public class DesktopApp implements EntryPoint {
+
+  private DesktopBus desktopBus;
+  private DesktopAppPresenter desktopAppPresenter;
+  private LoginHandler loginHandler;
+  private LoginServiceProvider loginServiceProvider;
+  private ProfileServiceProvider profileServiceProvider;
+  private LogoutHandler logoutHandler;
+  private LoginPresenter loginPresenter;
+  private ProfilePresenter profilePresenter;
+
+  public void loadModule(HasWidgets hasWidgets) {
+    setBackground(hasWidgets);
+    initializeDesktopBus(hasWidgets);
+    if (!getDesktopAppPresenter().isLocalStorageSupported()) {
+      loadApplicationAfterAlertingUser(hasWidgets);
+    } else {
+      loadApplication(hasWidgets);
+    }
+  }
+
+  @Override
+  public void onModuleLoad() {
+    // Set the FINEST logging to inspect storage ...
+    Logger logger = Logger.getLogger(StorageProvider.class.getName());
+    logger.setLevel(Level.FINEST);
+
+    setUncaughtExceptionHandler();
+    loadModule(RootPanel.get());
+
+      Element body = RootPanel.getBodyElement();
+      @SuppressWarnings("GwtToHtmlReferences") Element loading = RootPanel.get("loading").getElement();
+      body.removeChild(loading);
+      // DOM.removeChild(RootPanel.getBodyElement(), DOM.getElementById("loading"));
+  }
+
+  private void checkForLogin(HasWidgets hasWidgets) {
+    if (getDesktopAppPresenter().isLoggedIn()) {
+      displayView(hasWidgets);
+    } else {
+      getDesktopBus().invokeLoginService();
+    }
+  }
+
+  private void displayView(HasWidgets hasWidgets) {
+    getDesktopAppPresenter().go(hasWidgets);
+  }
+
+  private DesktopAppPresenter getDesktopAppPresenter() {
+    if (desktopAppPresenter == null) {
+      desktopAppPresenter = new DesktopAppPresenterImpl(getDesktopBus());
+    }
+    return desktopAppPresenter;
+  }
+
+  private DesktopBus getDesktopBus() {
+    if (desktopBus == null) {
+      desktopBus = new DesktopBus();
+    }
+    return desktopBus;
+  }
+
+  private LoginHandler getLoginHandler(final HasWidgets hasWidgets) {
+    if (loginHandler == null) {
+      loginHandler = new LoginHandler() {
+        @Override
+        public void onLogin(LoginEvent loginEvent) {
+          displayView(hasWidgets);
+          if (loginEvent.isNewUser()) {
+            getDesktopBus().invokeProfileService();
+          }
+        }
+      };
+    }
+    return loginHandler;
+  }
+
+  private LoginPresenter getLoginPresenter() {
+    if (loginPresenter == null) {
+      loginPresenter = new LoginPresenterImpl(getDesktopAppPresenter());
+    }
+    return loginPresenter;
+  }
+
+  private LoginServiceProvider getLoginServiceProvider(HasWidgets rootPanel) {
+    if (loginServiceProvider == null) {
+      loginServiceProvider = new LoginServiceProvider(getLoginPresenter(), rootPanel);
+    }
+    return loginServiceProvider;
+  }
+
+  private LogoutHandler getLogoutHandler() {
+    if (logoutHandler == null) {
+      logoutHandler = new LogoutHandler() {
+        @Override
+        public void onLogout(LogoutEvent logoutEvent) {
+          com.google.gwt.user.client.Window.Location.reload();
+        }
+      };
+    }
+    return logoutHandler;
+  }
+
+  private ProfilePresenter getProfilePresenter() {
+    if (profilePresenter == null) {
+      profilePresenter = new ProfilePresenterImpl(getDesktopAppPresenter());
+    }
+    return profilePresenter;
+  }
+
+  private ProfileServiceProvider getProfileServiceProvider(HasWidgets hasWidgets) {
+    if (profileServiceProvider == null) {
+      profileServiceProvider = new ProfileServiceProvider(getProfilePresenter(), hasWidgets);
+    }
+    return profileServiceProvider;
+  }
+
+  private void initializeDesktopBus(HasWidgets hasWidgets) {
+    getDesktopBus().registerLoginService(getLoginServiceProvider(hasWidgets));
+    getDesktopBus().registerProfileService(getProfileServiceProvider(hasWidgets));
+    getDesktopBus().addLoginHandler(getLoginHandler(hasWidgets));
+    getDesktopBus().addLogoutHandler(getLogoutHandler());
+  }
+
+  private void loadApplication(HasWidgets hasWidgets) {
+    if ("clear".equals(History.getToken())) {
+      promptToClearStorage(hasWidgets);
+    } else {
+      checkForLogin(hasWidgets);
+    }
+  }
+
+  private void loadApplicationAfterAlertingUser(final HasWidgets hasWidgets) {
+    Prompt.get().alert(
+        "Local Storage is Not Supported",
+        "Either your browser does not support HTML5 Local Storage or it is not configured for use by this application.<br/><br/>This application will continue to run, but anything you create will be discarded when the browser terminates or the browser window is refreshed.",
+        new Runnable() {
+          @Override
+          public void run() {
+            loadApplication(hasWidgets);
+          }
+        });
+  }
+
+  private void promptToClearStorage(final HasWidgets hasWidgets) {
+    Prompt.get().confirm("Desktop", "Would you like to clear this domain's local storage before continuing?",
+        new Runnable() {
+          @Override
+          public void run() {
+            getDesktopAppPresenter().clearLocalStorage();
+            checkForLogin(hasWidgets);
+          }
+        }, new Runnable() {
+          @Override
+          public void run() {
+            checkForLogin(hasWidgets);
+          }
+        });
+  }
+
+  private void setBackground(HasWidgets hasWidgets) {
+    if (hasWidgets instanceof UIObject) {
+      ((UIObject) hasWidgets).addStyleName("x-desktop");
+    }
+  }
+
+  private void setUncaughtExceptionHandler() {
+    GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+      @Override
+      public void onUncaughtException(Throwable e) {
+        e.printStackTrace();
+        Throwable rootCause = getRootCause(e);
+        new AlertMessageBox("Exception", rootCause.toString()).show();
+      }
+    });
+  }
+
+  private Throwable getRootCause(Throwable e) {
+    Throwable lastCause;
+    do {
+      lastCause = e;
+    } while ((e = e.getCause()) != null);
+    return lastCause;
+  }
+
+}