aws-cfn-stacker 0.0.5 → 0.0.6

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

@@ -0,0 +1,33 @@
+/**
+ * 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.google.gwt.user.client.ui.HasWidgets;
+import com.google.gwt.user.client.ui.IsWidget;
+import com.dldinternet.aws.cfn.stacker.desktop.client.layout.DesktopLayoutType;
+
+/**
+ * Provides a desktop application view.
+ */
+public interface DesktopAppView extends IsWidget, HasWidgets {
+
+  /**
+   * Sets the type of desktop layout to use when opening subsequent windows.
+   * 
+   * @param desktopLayoutType the layout to use when opening subsequent windows
+   */
+  void setDesktopLayoutType(DesktopLayoutType desktopLayoutType);
+
+  /**
+   * Sets whether the desktop should scale the position and size of desktop windows when the browser window is resized.
+   * 
+   * @param isScaleOnResize true if the desktop should scale desktop windows when the browser window is resized
+   */
+  void setScaleOnResize(boolean scaleOnResize);
+
+}

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

@@ -0,0 +1,263 @@
+/**
+ * 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.google.gwt.event.logical.shared.SelectionEvent;
+import com.google.gwt.event.logical.shared.SelectionHandler;
+import com.google.gwt.user.client.ui.Widget;
+import com.dldinternet.aws.cfn.stacker.desktop.client.layout.DesktopLayoutType;
+import com.dldinternet.aws.cfn.stacker.desktop.client.widget.Desktop;
+import com.dldinternet.aws.cfn.stacker.desktop.client.widget.Shortcut;
+import com.dldinternet.aws.cfn.stacker.desktop.client.widget.StartMainMenuItem;
+import com.dldinternet.aws.cfn.stacker.desktop.client.widget.StartToolMenuItem;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.images.DesktopImages;
+import com.sencha.gxt.widget.core.client.event.SelectEvent;
+import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
+import com.sencha.gxt.widget.core.client.menu.Item;
+
+import java.util.Iterator;
+
+/**
+ * Provides a desktop application view.
+ * 
+ * @see DesktopAppView
+ */
+public class DesktopAppViewImpl implements DesktopAppView {
+
+  private Desktop desktop;
+  private Shortcut fileManagerShortcut;
+  private Shortcut stackManagerShortcut;
+  private StartMainMenuItem fileManagerStartMenuItem;
+  private StartMainMenuItem stackManagerStartMenuItem;
+  private StartToolMenuItem cascadeToolMenuItem;
+  private StartToolMenuItem tileToolMenuItem;
+  private StartToolMenuItem updateProfileToolMenuItem;
+  private StartToolMenuItem logoutToolMenuItem;
+  private SelectionHandler<Item> fileManagerStartMenuListener;
+  private SelectionHandler<Item> stackManagerStartMenuListener;
+  private SelectHandler fileManagerShortcutListener;
+  private SelectHandler stackManagerShortcutListener;
+  private DesktopAppPresenter desktopAppPresenter;
+
+  /**
+   * Creates a desktop application view that interacts with the rest of the application using the specified presenter.
+   * 
+   * @param desktopAppPresenter the source of commands and data and the target of user initiated events.
+   */
+  public DesktopAppViewImpl(DesktopAppPresenter desktopAppPresenter) {
+    this.desktopAppPresenter = desktopAppPresenter;
+  }
+
+  @Override
+  public void add(Widget widget) {
+    getDesktop().activate(widget);
+  }
+
+  @Override
+  public Widget asWidget() {
+    return getDesktop().asWidget();
+  }
+
+  @Override
+  public void clear() {
+    // TODO: implement
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Iterator<Widget> iterator() {
+    // TODO: implement
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean remove(Widget w) {
+    // TODO: implement
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void setDesktopLayoutType(DesktopLayoutType desktopLayoutType) {
+    getDesktop().setDesktopLayoutType(desktopLayoutType);
+  }
+
+  @Override
+  public void setScaleOnResize(boolean scaleOnResize) {
+    getDesktop().setScaleOnResize(scaleOnResize);
+  }
+
+  private StartToolMenuItem getCascadeToolMenuItem() {
+    if (cascadeToolMenuItem == null) {
+      cascadeToolMenuItem = new StartToolMenuItem("Cascade");
+      cascadeToolMenuItem.setIcon(DesktopImages.INSTANCE.application_cascade());
+      cascadeToolMenuItem.addSelectionHandler(new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getDesktop().layout(DesktopLayoutType.CASCADE);
+        }
+      });
+    }
+    return cascadeToolMenuItem;
+  }
+
+  private Desktop getDesktop() {
+    if (desktop == null) {
+      desktop = new Desktop();
+      desktop.addShortcut(getFileManagerShortcut());
+      desktop.addShortcut(getStackManagerShortcut());
+      desktop.addStartMenuItem(getFileManagerStartMenuItem());
+      desktop.addStartMenuItem(getStackManagerStartMenuItem());
+      desktop.setStartMenuHeading(getPresenter().getCurrentUser());
+      desktop.setStartMenuIcon(DesktopImages.INSTANCE.user());
+      desktop.addToolMenuItem(getCascadeToolMenuItem());
+      desktop.addToolMenuItem(getTileToolMenuItem());
+      desktop.addToolSeparator();
+      desktop.addToolMenuItem(getUpdateProfileToolMenuItem());
+      desktop.addToolSeparator();
+      desktop.addToolMenuItem(getLogoutToolMenuItem());
+    }
+    return desktop;
+  }
+
+  private DesktopAppPresenter getDesktopAppPresenter() {
+    return desktopAppPresenter;
+  }
+
+  private Shortcut getFileManagerShortcut() {
+    if (fileManagerShortcut == null) {
+      fileManagerShortcut = new Shortcut();
+      fileManagerShortcut.setText("File Manager");
+      fileManagerShortcut.setIcon(DesktopImages.INSTANCE.folder_shortcut());
+      fileManagerShortcut.addSelectHandler(getFileManagerShortcutListener());
+    }
+    return fileManagerShortcut;
+  }
+
+  private Shortcut getStackManagerShortcut() {
+    if (stackManagerShortcut == null) {
+      stackManagerShortcut = new Shortcut();
+      stackManagerShortcut.setText("Stack Manager");
+      stackManagerShortcut.setIcon(DesktopImages.INSTANCE.stack_shortcut());
+      stackManagerShortcut.addSelectHandler(getStackManagerShortcutListener());
+    }
+    return stackManagerShortcut;
+  }
+
+  private SelectHandler getFileManagerShortcutListener() {
+    if (fileManagerShortcutListener == null) {
+      fileManagerShortcutListener = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getDesktopAppPresenter().onOpenFileManager();
+        }
+      };
+    }
+    return fileManagerShortcutListener;
+  }
+
+  private SelectHandler getStackManagerShortcutListener() {
+    if (stackManagerShortcutListener == null) {
+      stackManagerShortcutListener = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getDesktopAppPresenter().onOpenStackManager();
+        }
+      };
+    }
+    return stackManagerShortcutListener;
+  }
+
+  private StartMainMenuItem getFileManagerStartMenuItem() {
+    if (fileManagerStartMenuItem == null) {
+      fileManagerStartMenuItem = new StartMainMenuItem("File Manager");
+      fileManagerStartMenuItem.setIcon(DesktopImages.INSTANCE.folder());
+      fileManagerStartMenuItem.addSelectionHandler(getFileManagerStartMenuListener());
+    }
+    return fileManagerStartMenuItem;
+  }
+
+  private StartMainMenuItem getStackManagerStartMenuItem() {
+    if (stackManagerStartMenuItem == null) {
+      stackManagerStartMenuItem = new StartMainMenuItem("Stack Manager");
+      stackManagerStartMenuItem.setIcon(DesktopImages.INSTANCE.stack());
+      stackManagerStartMenuItem.addSelectionHandler(getStackManagerStartMenuListener());
+    }
+    return stackManagerStartMenuItem;
+  }
+
+  private SelectionHandler<Item> getFileManagerStartMenuListener() {
+    if (fileManagerStartMenuListener == null) {
+      fileManagerStartMenuListener = new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getDesktopAppPresenter().onOpenFileManager();
+        }
+      };
+    }
+    return fileManagerStartMenuListener;
+  }
+
+  private SelectionHandler<Item> getStackManagerStartMenuListener() {
+    if (stackManagerStartMenuListener == null) {
+      stackManagerStartMenuListener = new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getDesktopAppPresenter().onOpenStackManager();
+        }
+      };
+    }
+    return stackManagerStartMenuListener;
+  }
+
+  private StartToolMenuItem getLogoutToolMenuItem() {
+    if (logoutToolMenuItem == null) {
+      logoutToolMenuItem = new StartToolMenuItem("Logout");
+      logoutToolMenuItem.setIcon(DesktopImages.INSTANCE.door_out());
+      logoutToolMenuItem.addSelectionHandler(new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getPresenter().onLogout();
+        }
+      });
+    }
+    return logoutToolMenuItem;
+  }
+
+  private DesktopAppPresenter getPresenter() {
+    return desktopAppPresenter;
+  }
+
+  private StartToolMenuItem getTileToolMenuItem() {
+    if (tileToolMenuItem == null) {
+      tileToolMenuItem = new StartToolMenuItem("Tile");
+      tileToolMenuItem.setIcon(DesktopImages.INSTANCE.application_tile_horizontal());
+      tileToolMenuItem.addSelectionHandler(new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getDesktop().layout(DesktopLayoutType.TILE);
+        }
+      });
+    }
+    return tileToolMenuItem;
+  }
+
+  private StartToolMenuItem getUpdateProfileToolMenuItem() {
+    if (updateProfileToolMenuItem == null) {
+      updateProfileToolMenuItem = new StartToolMenuItem("Settings");
+      updateProfileToolMenuItem.setIcon(DesktopImages.INSTANCE.user_edit());
+      updateProfileToolMenuItem.addSelectionHandler(new SelectionHandler<Item>() {
+        @Override
+        public void onSelection(SelectionEvent<Item> event) {
+          getDesktopAppPresenter().onOpenProfile();
+        }
+      });
+    }
+    return updateProfileToolMenuItem;
+  }
+
+}

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

@@ -0,0 +1,297 @@
+/**
+ * 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.google.web.bindery.event.shared.HandlerRegistration;
+import com.google.web.bindery.event.shared.SimpleEventBus;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.*;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.AddFileModelEvent.AddFileModelHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LoginEvent.LoginHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.LogoutEvent.LogoutHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.OpenFileModelEvent.OpenFileModelHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.RemoveFileModelEvent.RemoveFileModelHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.SelectFileModelEvent.SelectFileModelHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.UpdateFileModelEvent.UpdateFileModelHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.event.UpdateProfileEvent.UpdateProfileHandler;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.LoginServiceProvider;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.LoginServiceRequest;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.ProfileServiceProvider;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.service.ProfileServiceRequest;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.servicebus.ServiceBus;
+
+/**
+ * Provides a mechanism for decoupling producers and consumers. Handles both
+ * events and services.
+ * <p/>
+ * An event is distinguished from a service in that it typically has zero or
+ * more consumer that may be invoked in any order and have no official means of
+ * returning information to the invoking entity. Event handlers are added to the
+ * event bus using {@code add} methods. Events are broadcast using {@code fire}
+ * methods.
+ * <p/>
+ * A service is distinguished from an event in that it has one and only one
+ * consumer that may optionally return information to the invoking entity.
+ * Service providers are added to the service bus using {@code register}
+ * methods. Services are requested using {@code invoke} methods. An
+ * {@link IllegalStateException} is thrown if an attempt is made to add a
+ * specified service more than once, or if a service is invoked and no
+ * corresponding service provider has been registered.
+ * <p/>
+ * To make it clear which events and services the application supports, this
+ * class explicitly advertises them using strongly typed methods instead of the
+ * generic {@link com.google.web.bindery.event.shared.EventBus#fireEvent} or {@link ServiceBus#invoke}.
+ */
+public class DesktopBus {
+
+  private SimpleEventBus eventBus = new SimpleEventBus();
+  private ServiceBus serviceBus = new ServiceBus();
+
+  /**
+   * Adds a handler that is invoked when a new file is created.
+   * 
+   * @param handler the add file model handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addAddFileModelHandler(AddFileModelHandler handler) {
+    return eventBus.addHandler(AddFileModelEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked after a new user successfully logs in.
+   * 
+   * @param handler the login handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addLoginHandler(LoginHandler handler) {
+    return eventBus.addHandler(LoginEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked after a user logs out.
+   * 
+   * @param handler the logout handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addLogoutHandler(LogoutHandler handler) {
+    return eventBus.addHandler(LogoutEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked when a request is made to launch the
+   * application associated with a file.
+   * 
+   * @param handler the open file handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addOpenFileModelHandler(OpenFileModelHandler handler) {
+    return eventBus.addHandler(OpenFileModelEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked after a file is removed.
+   * 
+   * @param handler the file remove handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addRemoveFileModelHandler(RemoveFileModelHandler handler) {
+    return eventBus.addHandler(RemoveFileModelEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked when a user selects a file in the file
+   * manager without opening it.
+   * 
+   * @param handler the file select handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addSelectFileModelHandler(SelectFileModelHandler handler) {
+    return eventBus.addHandler(SelectFileModelEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked when a file (or it's meta-information) is
+   * updated.
+   * 
+   * @param handler the file update handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addUpdateFileModelHandler(UpdateFileModelHandler handler) {
+    return eventBus.addHandler(UpdateFileModelEvent.TYPE, handler);
+  }
+
+  /**
+   * Adds a handler that is invoked when the user has updated their profile, or
+   * cancelled the profile update operation.
+   * 
+   * @param handler the profile update handler
+   * @return a registration that can be used to remove the handler
+   */
+  public HandlerRegistration addUpdateProfileHandler(UpdateProfileHandler handler) {
+    return eventBus.addHandler(UpdateProfileEvent.TYPE, handler);
+  }
+
+  /**
+   * Fires an event indicating a new file has been created.
+   * 
+   * @param event the file add event
+   */
+  public void fireAddFileModelEvent(AddFileModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a new stack has been created.
+   *
+   * @param event the stack add event
+   */
+  public void fireAddStackModelEvent(AddStackModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a user has logged in.
+   * 
+   * @param event the login event
+   */
+  public void fireLoginEvent(LoginEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a user has logged out.
+   * 
+   * @param event the logout event
+   */
+  public void fireLogoutEvent(LogoutEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a user wishes to launch the application
+   * associated with a file.
+   * 
+   * @param event the file open event
+   */
+  public void fireOpenFileModelEvent(OpenFileModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a user wishes to launch the application
+   * associated with a stack.
+   *
+   * @param event the stack open event
+   */
+  public void fireOpenStackModelEvent(OpenStackModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a file has been removed.
+   * 
+   * @param event the file remove event
+   */
+  public void fireRemoveFileModelEvent(RemoveFileModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a stack has been removed.
+   *
+   * @param event the stack remove event
+   */
+  public void fireRemoveStackModelEvent(RemoveStackModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating the user has selected a file without opening it.
+   * 
+   * @param event the file select event
+   */
+  public void fireSelectFileModelEvent(SelectFileModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating the user has selected a stack without opening it.
+   *
+   * @param event the stack select event
+   */
+  public void fireSelectStackModelEvent(SelectStackModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a file (or its meta-information) has been
+   * updated.
+   * 
+   * @param event the file update event
+   */
+  public void fireUpdateFileModelEvent(UpdateFileModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating a stack (or its meta-information) has been
+   * updated.
+   *
+   * @param event the stack update event
+   */
+  public void fireUpdateStackModelEvent(UpdateStackModelEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Fires an event indicating the user's profile has been updated, or the
+   * update operation has been cancelled.
+   * 
+   * @param event the profile update event
+   */
+  public void fireUpdateProfileEvent(UpdateProfileEvent event) {
+    eventBus.fireEvent(event);
+  }
+
+  /**
+   * Invokes a service capable of giving the user an opportunity to log in.
+   */
+  public void invokeLoginService() {
+    serviceBus.invoke(new LoginServiceRequest());
+  }
+
+  /**
+   * Invokes a service capable of giving the user an opportunity to update
+   * profile settings.
+   */
+  public void invokeProfileService() {
+    serviceBus.invoke(new ProfileServiceRequest());
+  }
+
+  /**
+   * Registers a service provider capable of giving the user an opportunity to
+   * log in. A login service provider generally collects login parameters and
+   * invokes {@link DesktopAppPresenter#onLogin(LoginModel)}.
+   * 
+   * @param provider the login service provider
+   */
+  public void registerLoginService(LoginServiceProvider provider) {
+    serviceBus.registerServiceProvider(LoginServiceRequest.class, provider);
+  }
+
+  /**
+   * Registers a service provider capable of giving the user an opportunity to
+   * update profile settings. A profile service provider generally displays
+   * current profile settings, allows the user to update them and invokes
+   * {@link DesktopAppPresenter#onUpdateProfile(ProfileModel)}.
+   * 
+   * @param provider the profile service provider
+   */
+  public void registerProfileService(ProfileServiceProvider provider) {
+    serviceBus.registerServiceProvider(ProfileServiceRequest.class, provider);
+  }
+}