aws-cfn-stacker 0.0.5 → 0.0.6

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

@@ -0,0 +1,59 @@
+/**
+ * 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.core.client.GWT;
+import com.sencha.gxt.cell.core.client.TextButtonCell;
+import com.dldinternet.aws.cfn.stacker.desktop.client.theme.base.shortcut.ShortcutCellDefaultAppearance;
+
+/**
+ * Provides the unique appearance of a desktop shortcut cell. A cell is a
+ * lightweight representation of a renderable object. A shortcut cell inherits
+ * many of the properties of a text button cell.
+ * <p/>
+ * For more information on the use of the appearance pattern, see <a
+ * href='http://www.sencha.com/blog/ext-gwt-3-appearance-design'>Sencha GXT 3.0
+ * Appearance Design</a>
+ */
+public class ShortcutCell extends TextButtonCell {
+
+  /**
+   * Defines the appearance interface for a shortcut cell.
+   * <p/>
+   * The appearance interface defines the interaction between the widget and an
+   * appearance instance. The concrete implementation of the appearance
+   * interface typically incorporates the external HTML and CSS source using the
+   * {@link com.sencha.gxt.core.client.XTemplates} and {@link com.google.gwt.resources.client.CssResource} interfaces.
+   * 
+   * @param <T> the type that this Cell represents
+   */
+  public interface ShortcutCellAppearance<T> extends ButtonCellAppearance<T> {
+  }
+
+  /**
+   * Creates a shortcut cell with the default appearance.
+   * <p/>
+   * The GWT module file contains a replace-with directive that maps the
+   * appearance interface (specified as the argument to the create method) to a
+   * concrete implementation class, e.g. {@link ShortcutCellDefaultAppearance}. See
+   * {@code Desktop.gwt.xml} for more information.
+   */
+  public ShortcutCell() {
+    this(GWT.<ShortcutCellAppearance<String>> create(ShortcutCellAppearance.class));
+  }
+
+  /**
+   * Creates a shortcut cell with the specified appearance.
+   * 
+   * @param appearance the appearance of the shortcut cell.
+   */
+  public ShortcutCell(ShortcutCellAppearance<String> appearance) {
+    super(appearance);
+  }
+
+}

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

@@ -0,0 +1,75 @@
+/**
+ * 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.dom.client.Element;
+import com.google.gwt.user.client.ui.Widget;
+import com.sencha.gxt.core.client.Style.Anchor;
+import com.sencha.gxt.core.client.Style.AnchorAlignment;
+import com.sencha.gxt.widget.core.client.button.TextButton;
+import com.sencha.gxt.widget.core.client.event.SelectEvent;
+import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
+
+/**
+ * Provides a "start button" for use with the desktop. A start button is a text
+ * button with a unique cell appearance. It has a start menu associated with it.
+ * Clicking on the start button displays the start menu.
+ */
+public class StartButton extends TextButton {
+
+  private StartMenu startMenu;
+  private SelectHandler selectHandler;
+
+  /**
+   * Creates a start button using the start button cell appearance.
+   */
+  public StartButton() {
+    super(new StartButtonCell());
+    addSelectHandler(getSelectHandler());
+  }
+
+  /**
+   * Returns the start menu associated with the start button.
+   * 
+   * @return the start menu
+   */
+  public StartMenu getStartMenu() {
+    if (startMenu == null) {
+      startMenu = new StartMenu();
+    }
+    return startMenu;
+  }
+
+  private SelectHandler getSelectHandler() {
+    if (selectHandler == null) {
+      selectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          onStartButton();
+        }
+      };
+    }
+    return selectHandler;
+  }
+
+  private void onStartButton() {
+    Widget taskBar = getContainingTaskBar();
+    Element alignmentElement = taskBar == null ? getElement() : taskBar.getElement();
+    getStartMenu().show(alignmentElement, new AnchorAlignment(Anchor.BOTTOM_LEFT, Anchor.TOP_LEFT, true), 0, 0);
+  }
+
+  private Widget getContainingTaskBar() {
+    Widget parent;
+    while ((parent = getParent()) != null) {
+      if (parent instanceof TaskBar) {
+        return parent;
+      }
+    }
+    return null;
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * 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.core.client.GWT;
+import com.sencha.gxt.cell.core.client.TextButtonCell;
+import com.dldinternet.aws.cfn.stacker.desktop.client.theme.base.startbutton.StartButtonCellDefaultAppearance;
+
+/**
+ * Provides the unique appearance of a start button cell. A cell is a
+ * lightweight representation of a renderable object. A start button cell
+ * inherits many of the properties of a text button cell.
+ * <p/>
+ * For more information on the use of the appearance pattern, see <a
+ * href='http://www.sencha.com/blog/ext-gwt-3-appearance-design'>Sencha GXT 3.0
+ * Appearance Design</a>
+ */
+public class StartButtonCell extends TextButtonCell {
+
+  /**
+   * Defines the appearance interface for a start button cell.
+   * <p/>
+   * The appearance interface defines the interaction between the widget and an
+   * appearance instance. The concrete implementation of the appearance
+   * interface typically incorporates the external HTML and CSS source using the
+   * {@link com.sencha.gxt.core.client.XTemplates} and {@link com.google.gwt.resources.client.CssResource} interfaces.
+   * 
+   * @param <T> the type that this Cell represents
+   */
+  public interface StartButtonCellAppearance<T> extends ButtonCellAppearance<T> {
+  }
+
+  /**
+   * Constructs a start button cell with the default appearance.
+   * <p/>
+   * The GWT module file contains a replace-with directive that maps the
+   * appearance interface (specified as the argument to the create method) to a
+   * concrete implementation class, e.g. {@link StartButtonCellDefaultAppearance}. See
+   * {@code Desktop.gwt.xml} for more information.
+   */
+  public StartButtonCell() {
+    this(GWT.<StartButtonCellAppearance<String>> create(StartButtonCellAppearance.class));
+  }
+
+  /**
+   * Constructs a start button cell with the specified appearance.
+   * 
+   * @param appearance the appearance of the start button cell.
+   */
+  public StartButtonCell(StartButtonCellAppearance<String> appearance) {
+    super(appearance);
+  }
+
+}

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

@@ -0,0 +1,62 @@
+/**
+ * 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.resources.client.ImageResource;
+import com.dldinternet.aws.cfn.stacker.desktop.client.theme.base.startmenu.StartHeadingMenuItemAppearance;
+import com.sencha.gxt.widget.core.client.menu.MenuItem;
+
+/**
+ * Provides a heading to use with a start menu. This item is typically displayed
+ * at the top of a start menu to provide additional information (e.g. the
+ * currently logged-in user). A start heading menu item is menu item with a
+ * unique appearance that is tailored for use with a start menu.
+ */
+public class StartHeadingMenuItem extends MenuItem {
+
+  /**
+   * Creates a heading menu item with a default unique appearance tailored for
+   * use with a start menu.
+   */
+  public StartHeadingMenuItem() {
+    this(new StartHeadingMenuItemAppearance());
+  }
+
+  /**
+   * Creates a heading menu item with the specified appearance.
+   * 
+   * @param startHeadingMenuItemAppearance the appearance
+   */
+  public StartHeadingMenuItem(StartHeadingMenuItemAppearance startHeadingMenuItemAppearance) {
+    super(startHeadingMenuItemAppearance);
+  }
+
+  /**
+   * Creates a heading menu item with a default start menu item appearance and
+   * the specified text.
+   * 
+   * @param text the heading text
+   */
+  public StartHeadingMenuItem(String text) {
+    this();
+    setText(text);
+  }
+
+  /**
+   * Creates a heading menu item with a default start menu item appearance and
+   * the specified text and icon
+   * 
+   * @param text the heading text
+   * @param icon the heading icon
+   */
+  public StartHeadingMenuItem(String text, ImageResource icon) {
+    this(text);
+    setIcon(icon);
+  }
+
+}

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

@@ -0,0 +1,68 @@
+/**
+ * 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.user.client.ui.Widget;
+import com.dldinternet.aws.cfn.stacker.desktop.client.theme.base.startmenu.StartMainMenuAppearance;
+import com.sencha.gxt.widget.core.client.menu.Menu;
+
+/**
+ * Provides the "main menu" component of the start menu. The main menu is
+ * typically displayed on the left side of the start menu and contains items for
+ * desktop applications.
+ * 
+ * @see StartMainMenuItem
+ */
+public class StartMainMenu extends Menu {
+
+  private StartMenu startMenu;
+
+  /**
+   * Creates a main menu for the specified start menu.
+   * 
+   * @param startMenu the start menu that contains this main menu
+   */
+  public StartMainMenu(StartMenu startMenu) {
+    this(startMenu, new StartMainMenuAppearance());
+  }
+
+  /**
+   * Creates a main menu for the specified start menu, with the specified
+   * appearance.
+   * 
+   * @param startMenu the start menu that contains this main menu
+   * @param startMainMenuAppearance the appearance
+   */
+  public StartMainMenu(StartMenu startMenu, StartMainMenuAppearance startMainMenuAppearance) {
+    super(startMainMenuAppearance);
+    this.startMenu = startMenu;
+  }
+
+  /**
+   * {@inheritDoc}
+   * 
+   * @throws IllegalArgumentException if the specified widget is not a
+   *           {@link StartMainMenuItem}
+   */
+  @Override
+  public void add(Widget child) {
+    if (!(child instanceof StartMainMenuItem)) {
+      throw new IllegalArgumentException("Widget is not a StartMainMenuItem");
+    }
+    super.add(child);
+  }
+
+  @Override
+  public void hide(boolean deep) {
+    if (activeItem != null) {
+      ((StartMainMenuItem) activeItem).hideSubMenu();
+      activeItem = null;
+    }
+    startMenu.hide();
+  }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * 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.resources.client.ImageResource;
+import com.sencha.gxt.widget.core.client.menu.MenuItem;
+
+/**
+ * Provides a "main menu" item for a start menu. A main menu item is displayed
+ * in the main menu of the start menu, which is typically to the left of the
+ * tool menu. In it's current implementation, a main menu item has the same
+ * appearance as a menu item.
+ * 
+ * @see StartMainMenu
+ */
+public class StartMainMenuItem extends MenuItem {
+
+  /**
+   * Creates a main menu item for the start menu, with the default main menu
+   * item appearance.
+   */
+  public StartMainMenuItem() {
+  }
+
+  /**
+   * Creates a main menu item for the start menu with the default appearance and
+   * the specified text.
+   * 
+   * @param text the main menu item text
+   */
+  public StartMainMenuItem(String text) {
+    this();
+    setText(text);
+  }
+
+  /**
+   * Creates a main menu item for the start menu with the default appearance and
+   * the specified text and icon.
+   * 
+   * @param text the item text
+   * @param icon the icon
+   */
+  public StartMainMenuItem(String text, ImageResource icon) {
+    this(text);
+    setIcon(icon);
+  }
+
+  /**
+   * Hides a displayed sub-menu, if any.
+   */
+  void hideSubMenu() {
+    super.deactivate();
+  }
+
+}

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

@@ -0,0 +1,260 @@
+/**
+ * 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.core.client.GWT;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.resources.client.ImageResource;
+import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Event.NativePreviewEvent;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.sencha.gxt.core.client.Style.AnchorAlignment;
+import com.sencha.gxt.core.client.dom.XDOM;
+import com.sencha.gxt.core.client.dom.XElement;
+import com.sencha.gxt.core.client.util.BaseEventPreview;
+import com.dldinternet.aws.cfn.stacker.desktop.client.theme.base.startmenu.StartMenuDefaultAppearance;
+import com.sencha.gxt.widget.core.client.Component;
+import com.sencha.gxt.widget.core.client.ComponentHelper;
+import com.sencha.gxt.widget.core.client.event.BeforeHideEvent;
+import com.sencha.gxt.widget.core.client.event.BeforeShowEvent;
+import com.sencha.gxt.widget.core.client.event.HideEvent;
+import com.sencha.gxt.widget.core.client.event.ShowEvent;
+import com.sencha.gxt.widget.core.client.menu.Menu;
+import com.sencha.gxt.widget.core.client.menu.MenuItem;
+
+/**
+ * Provides a desktop start menu. A desktop start menu is a component with a
+ * heading, a main menu and a tool menu. The heading is typically displayed at
+ * the top of the start menu, and the main menu and tool menu are displayed side
+ * by side below the heading.
+ * <p/>
+ * For more information on the use of the appearance pattern, see <a
+ * href='http://www.sencha.com/blog/ext-gwt-3-appearance-design'>Sencha GXT 3.0
+ * Appearance Design</a>
+ * 
+ * @see StartMainMenu
+ * @see StartToolMenu
+ * @see StartHeadingMenuItem
+ */
+public class StartMenu extends Component {
+
+  /**
+   * Defines the appearance interface for a start menu.
+   * <p/>
+   * The appearance interface defines the interaction between the widget and an
+   * appearance instance. The concrete implementation of the appearance
+   * interface typically incorporates the external HTML and CSS source using the
+   * {@link com.sencha.gxt.core.client.XTemplates} and {@link com.google.gwt.resources.client.CssResource} interfaces.
+   */
+  public interface Appearance {
+
+    public void setHeading(XElement parent, MenuItem heading);
+
+    public void setMainMenu(XElement parent, Menu mainMenu);
+
+    public void setToolMenu(XElement parent, Menu toolMenu);
+
+    void render(SafeHtmlBuilder builder);
+
+  }
+
+  private StartHeadingMenuItem heading;
+  private StartMainMenu mainMenu;
+  private StartToolMenu toolMenu;
+  private BaseEventPreview eventPreview;
+  private boolean showing;
+
+  /**
+   * Creates a start menu with the default appearance.
+   */
+  public StartMenu() {
+    this(GWT.<StartMenuDefaultAppearance> create(StartMenuDefaultAppearance.class));
+  }
+
+  /**
+   * Creates a start menu with the specified appearance.
+   *
+   * @param appearance the start menu appearance
+   */
+  public StartMenu(StartMenuDefaultAppearance appearance) {
+
+    SafeHtmlBuilder builder = new SafeHtmlBuilder();
+    appearance.render(builder);
+
+    XElement element = XDOM.create(builder.toSafeHtml());
+    setElement((Element)element);
+
+    appearance.setHeading(element, getHeading());
+    appearance.setMainMenu(element, getMainMenu());
+    appearance.setToolMenu(element, getToolMenu());
+
+    sinkEvents(Event.MOUSEEVENTS | Event.ONCLICK);
+  }
+
+  /**
+   * Adds an item to the "main menu" area of the start menu. The main menu
+   * typically appears on the left side of the start menu and includes items for
+   * desktop applications.
+   *
+   * @param menuItem the item to add to the main menu area of the start menu
+   */
+  public void add(StartMainMenuItem menuItem) {
+    getMainMenu().add(menuItem);
+  }
+
+  /**
+   * Adds an item to the "tool menu" area of the start menu. The tool menu
+   * typically appears on the right side of the start menu and includes items
+   * that manage the state of the desktop.
+   *
+   * @param startToolMenuItem the item to add to the tool menu area of the start
+   *          menu
+   */
+  public void addTool(StartToolMenuItem startToolMenuItem) {
+    getToolMenu().add(startToolMenuItem);
+  }
+
+  /**
+   * Adds a separator to the "tool menu" area of the start menu.
+   */
+  public void addToolSeparator() {
+    // TODO: Provide implementation
+  }
+
+  /**
+   * Hides the start menu.
+   */
+  public void hide() {
+    if (showing) {
+      if (fireCancellableEvent(new BeforeHideEvent())) {
+        showing = false;
+        onHide();
+        RootPanel.get().remove(this);
+        eventPreview.remove();
+        fireEvent(new HideEvent());
+      }
+    }
+  }
+
+  /**
+   * Sets the text to be displayed in the start menu heading. The heading
+   * typically appears above the main menu and tool menu.
+   *
+   * @param text the start menu heading text
+   */
+  public void setHeading(String text) {
+    getHeading().setText(text);
+  }
+
+  /**
+   * Sets the icon to be displayed in the start menu heading. The heading
+   * typically appears above main menu and tool menu.
+   *
+   * @param icon the start menu heading icon
+   */
+  public void setIcon(ImageResource icon) {
+    getHeading().setIcon(icon);
+  }
+
+  /**
+   * Displays this menu relative to another element.
+   *
+   * @param elem the element to align to
+   * @param alignment the {@link com.sencha.gxt.core.client.dom.XElement#alignTo} anchor position to use in
+   *          aligning to the element (defaults to defaultAlign)
+   * @param offsetX X offset
+   * @param offsetY Y offset
+   */
+  public void show(Element elem, AnchorAlignment alignment, int offsetX, int offsetY) {
+    if (fireCancellableEvent(new BeforeShowEvent())) {
+      showing = true;
+      RootPanel.get().add(this);
+      getElement().makePositionable(true);
+      onShow();
+      getElement().updateZIndex(0);
+      doAutoSize();
+      getElement().alignTo(elem, alignment, offsetX, offsetY);
+      // TODO: Add support for scrolling as in Menu.show
+      getElement().show();
+      getEventPreview().add();
+      focus();
+      fireEvent(new ShowEvent());
+    }
+  }
+
+  @Override
+  protected void doAttachChildren() {
+    super.doAttachChildren();
+    ComponentHelper.doAttach(heading);
+    ComponentHelper.doAttach(mainMenu);
+    ComponentHelper.doAttach(toolMenu);
+  }
+
+  protected void doAutoSize() {
+    String w = getElement().getStyle().getWidth();
+    if (showing && "".equals(w)) {
+      // TODO: get main menu container from appearance as in Menu.doAutoSize
+      getMainMenu().getElement().setWidth(195, true);
+    }
+  }
+
+  @Override
+  protected void doDetachChildren() {
+    super.doDetachChildren();
+    ComponentHelper.doDetach(heading);
+    ComponentHelper.doDetach(mainMenu);
+    ComponentHelper.doDetach(toolMenu);
+  }
+
+  private BaseEventPreview getEventPreview() {
+    if (eventPreview == null) {
+      eventPreview = new BaseEventPreview() {
+
+        protected boolean onAutoHide(NativePreviewEvent pe) {
+          // TODO: Add support for sub-menus as in Menu.onAutoHide
+          hide();
+          return true;
+        }
+
+        @Override
+        protected void onPreviewKeyPress(NativePreviewEvent pe) {
+          if (pe.getNativeEvent().getKeyCode() == KeyCodes.KEY_ESCAPE) {
+            hide();
+          }
+        }
+
+      };
+      eventPreview.getIgnoreList().add(getMainMenu().getElement());
+      eventPreview.getIgnoreList().add(getToolMenu().getElement());
+    }
+    return eventPreview;
+  }
+
+  private StartHeadingMenuItem getHeading() {
+    if (heading == null) {
+      heading = new StartHeadingMenuItem();
+    }
+    return heading;
+  }
+
+  private StartMainMenu getMainMenu() {
+    if (mainMenu == null) {
+      mainMenu = new StartMainMenu(this);
+    }
+    return mainMenu;
+  }
+
+  private StartToolMenu getToolMenu() {
+    if (toolMenu == null) {
+      toolMenu = new StartToolMenu(this);
+    }
+    return toolMenu;
+  }
+}