aws-cfn-stacker 0.0.5 → 0.0.6

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

@@ -0,0 +1,47 @@
+/**
+ * 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.stackmanager;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackPile;
+import com.google.gwt.cell.client.AbstractCell;
+import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
+
+public class StackManagerSizeCell extends AbstractCell<Long> {
+  private StackPile fileSystem;
+
+  public StackManagerSizeCell(StackPile fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+
+  @Override
+  public void render(Context context, Long size, SafeHtmlBuilder sb) {
+    if (size == null) {
+      size = Long.valueOf(0);
+    }
+    sb.append(size);
+    String key = (String) context.getKey();
+    StackModel fileModel = fileSystem.getTreeStore().findModelWithKey(key);
+    switch (fileModel.getStackType()) {
+      case FOLDER:
+        if (size == 1) {
+          sb.appendEscaped(" Stack");
+        } else {
+          sb.appendEscaped(" Stacks");
+        }
+        break;
+      default:
+        if (size == 1) {
+          sb.appendEscaped(" Resource");
+        } else {
+          sb.appendEscaped(" Resources");
+        }
+        break;
+    }
+  }
+}

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

@@ -0,0 +1,234 @@
+/**
+ * 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.stackmanager;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel.StackType;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.stackmanager.images.Images;
+import com.google.gwt.user.client.ui.IsWidget;
+import com.google.gwt.user.client.ui.Widget;
+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;
+import com.sencha.gxt.widget.core.client.toolbar.SeparatorToolItem;
+import com.sencha.gxt.widget.core.client.toolbar.ToolBar;
+
+public class StackManagerToolBar implements IsWidget {
+
+  private static final String STACK_TYPE = "stackType";
+
+  private StackManagerPresenter stackManagerPresenter;
+
+  private ToolBar toolBar;
+  private TextButton createFolderTextButton;
+  private TextButton createDocumentTextButton;
+  private TextButton createSpreadsheetTextButton;
+  private TextButton createProgramTextButton;
+  private TextButton createBookmarkTextButton;
+  private TextButton collapseTextButton;
+  private TextButton expandTextButton;
+  private TextButton editNameTextButton;
+  private TextButton openTextButton;
+  private TextButton deleteTextButton;
+  private SelectHandler createSelectHandler;
+  private SelectHandler expandSelectHandler;
+  private SelectHandler collapseSelectHandler;
+  private SelectHandler editNameSelectHandler;
+  private SelectHandler openSelectHandler;
+  private SelectHandler deleteSelectHandler;
+
+  public StackManagerToolBar(StackManagerPresenter stackManagerPresenter) {
+    this.stackManagerPresenter = stackManagerPresenter;
+  }
+
+  public Widget asWidget() {
+    return getToolBar();
+  }
+
+  public void setButtonEnabledState() {
+    boolean isEnableCreate = getPresenter().isEnableCreate();
+    boolean isEnableOpen = getPresenter().isEnableOpen();
+    boolean isEnableDelete = getPresenter().isEnableDelete();
+    boolean isEnableEditName = getPresenter().isEnableEditName();
+    getCreateFolderTextButton().setEnabled(isEnableCreate);
+    getCreateStackTextButton().setEnabled(isEnableCreate);
+    getExpandTextButton().setEnabled(isEnableCreate);
+    getCollapseTextButton().setEnabled(isEnableCreate);
+    getEditNameTextButton().setEnabled(isEnableEditName);
+    getOpenTextButton().setEnabled(isEnableOpen);
+    getDeleteTextButton().setEnabled(isEnableDelete);
+  }
+
+  protected StackManagerPresenter getPresenter() {
+    return stackManagerPresenter;
+  }
+
+  private SelectHandler getCollapseSelectHandler() {
+    if (collapseSelectHandler == null) {
+      collapseSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getPresenter().onCollapse();
+        }
+      };
+    }
+    return collapseSelectHandler;
+  }
+
+  private TextButton getCollapseTextButton() {
+    if (collapseTextButton == null) {
+      collapseTextButton = new TextButton();
+      collapseTextButton.setToolTip("Collapse");
+      collapseTextButton.setIcon(Images.getImageResources().arrow_in());
+      collapseTextButton.addSelectHandler(getCollapseSelectHandler());
+    }
+    return collapseTextButton;
+  }
+
+  private TextButton getCreateStackTextButton() {
+    if (createDocumentTextButton == null) {
+      createDocumentTextButton = new TextButton();
+      createDocumentTextButton.setToolTip("New Document");
+      createDocumentTextButton.setIcon(Images.getImageResources().stack_add());
+      createDocumentTextButton.setData(STACK_TYPE, StackType.STACK);
+      createDocumentTextButton.addSelectHandler(getCreateSelectHandler());
+    }
+    return createDocumentTextButton;
+  }
+
+  private TextButton getCreateFolderTextButton() {
+    if (createFolderTextButton == null) {
+      createFolderTextButton = new TextButton();
+      createFolderTextButton.setToolTip("New Folder");
+      createFolderTextButton.setIcon(Images.getImageResources().folder_add());
+      createFolderTextButton.setData(STACK_TYPE, StackType.FOLDER);
+      createFolderTextButton.addSelectHandler(getCreateSelectHandler());
+    }
+    return createFolderTextButton;
+  }
+
+  private SelectHandler getCreateSelectHandler() {
+    if (createSelectHandler == null) {
+      createSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          StackType fileType = ((TextButton) event.getSource()).<StackType> getData(STACK_TYPE);
+          getPresenter().onCreate(fileType);
+        }
+      };
+    }
+    return createSelectHandler;
+  }
+
+  private SelectHandler getDeleteSelectHandler() {
+    if (deleteSelectHandler == null) {
+      deleteSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getPresenter().onDelete();
+        }
+      };
+    }
+    return deleteSelectHandler;
+  }
+
+  private TextButton getDeleteTextButton() {
+    if (deleteTextButton == null) {
+      deleteTextButton = new TextButton();
+      deleteTextButton.setToolTip("Delete");
+      deleteTextButton.setIcon(Images.getImageResources().bin_closed());
+      deleteTextButton.addSelectHandler(getDeleteSelectHandler());
+    }
+    return deleteTextButton;
+  }
+
+  private SelectHandler getEditNameSelectHandler() {
+    if (editNameSelectHandler == null) {
+      editNameSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getPresenter().onEditName();
+        }
+      };
+    }
+    return editNameSelectHandler;
+  }
+
+  private TextButton getEditNameTextButton() {
+    if (editNameTextButton == null) {
+      editNameTextButton = new TextButton();
+      editNameTextButton.setToolTip("Edit Name");
+      editNameTextButton.setIcon(Images.getImageResources().textfield_rename());
+      editNameTextButton.addSelectHandler(getEditNameSelectHandler());
+    }
+    return editNameTextButton;
+  }
+
+  private SelectHandler getExpandSelectHandler() {
+    if (expandSelectHandler == null) {
+      expandSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getPresenter().onExpand();
+        }
+      };
+    }
+    return expandSelectHandler;
+  }
+
+  private TextButton getExpandTextButton() {
+    if (expandTextButton == null) {
+      expandTextButton = new TextButton();
+      expandTextButton.setToolTip("Expand");
+      expandTextButton.addSelectHandler(getExpandSelectHandler());
+      expandTextButton.setIcon(Images.getImageResources().arrow_out());
+    }
+    return expandTextButton;
+  }
+
+  private SelectHandler getOpenSelectHandler() {
+    if (openSelectHandler == null) {
+      openSelectHandler = new SelectHandler() {
+        @Override
+        public void onSelect(SelectEvent event) {
+          getPresenter().onOpen();
+        }
+      };
+    }
+    return openSelectHandler;
+  }
+
+  private TextButton getOpenTextButton() {
+    if (openTextButton == null) {
+      openTextButton = new TextButton();
+      openTextButton.setToolTip("Open");
+      openTextButton.setIcon(Images.getImageResources().bullet_go());
+      openTextButton.addSelectHandler(getOpenSelectHandler());
+    }
+    return openTextButton;
+  }
+
+  private Widget getToolBar() {
+    if (toolBar == null) {
+      toolBar = new ToolBar();
+      toolBar.add(getCreateFolderTextButton());
+      toolBar.add(new SeparatorToolItem());
+      toolBar.add(getCreateStackTextButton());
+      toolBar.add(new SeparatorToolItem());
+      toolBar.add(getExpandTextButton());
+      toolBar.add(getCollapseTextButton());
+      toolBar.add(new SeparatorToolItem());
+      toolBar.add(getEditNameTextButton());
+      toolBar.add(new SeparatorToolItem());
+      toolBar.add(getOpenTextButton());
+      toolBar.add(new SeparatorToolItem());
+      toolBar.add(getDeleteTextButton());
+    }
+    return toolBar;
+  }
+
+}

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

@@ -0,0 +1,49 @@
+/**
+ * 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.stackmanager;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel.StackType;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.dom.client.EventTarget;
+import com.google.gwt.user.client.Event;
+import com.sencha.gxt.data.shared.TreeStore;
+import com.sencha.gxt.widget.core.client.grid.ColumnConfig;
+import com.sencha.gxt.widget.core.client.grid.ColumnModel;
+import com.sencha.gxt.widget.core.client.treegrid.TreeGrid;
+
+public class StackManagerTreeGrid extends TreeGrid<StackModel> {
+
+  public StackManagerTreeGrid(TreeStore<StackModel> store, ColumnModel<StackModel> cm,
+                              ColumnConfig<StackModel, ?> treeColumn) {
+    super(store, cm, treeColumn);
+  }
+
+  @Override
+  public boolean isLeaf(StackModel model) {
+    return model.getStackType() != StackType.FOLDER;
+  }
+
+  public void unbind() {
+    if (storeHandlerRegistration != null) {
+      storeHandlerRegistration.removeHandler();
+    }
+  }
+
+  @Override
+  protected void onClick(Event event) {
+    super.onClick(event);
+    EventTarget eventTarget = event.getEventTarget();
+    if (Element.is(eventTarget)) {
+      StackModel m = store.get(getView().findRowIndex(Element.as(eventTarget)));
+      if (m == null) {
+        getSelectionModel().deselectAll();
+      }
+    }
+  }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * 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.stackmanager;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel;
+import com.google.gwt.user.client.ui.IsWidget;
+
+import java.util.List;
+
+public interface StackManagerView extends IsWidget {
+
+  public void collapse();
+
+  public void editName(StackModel childStackModel);
+
+  public void expand();
+
+  public StackModel getSelectedItem();
+
+  public List<StackModel> getSelectedItems();
+
+  public void selectStackModel(StackModel fileModel);
+
+}

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

@@ -0,0 +1,379 @@
+/**
+ * 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.stackmanager;
+
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.filemanager.images.Images;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModel.StackType;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackModelProperties;
+import com.dldinternet.aws.cfn.stacker.desktopapp.client.persistence.StackPile;
+import com.google.gwt.cell.client.DateCell;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.core.client.Scheduler.RepeatingCommand;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.i18n.client.DateTimeFormat;
+import com.google.gwt.i18n.client.DateTimeFormat.PredefinedFormat;
+import com.google.gwt.user.client.ui.Widget;
+import com.sencha.gxt.data.shared.IconProvider;
+import com.sencha.gxt.dnd.core.client.DND.Feedback;
+import com.sencha.gxt.dnd.core.client.TreeGridDragSource;
+import com.sencha.gxt.dnd.core.client.TreeGridDropTarget;
+import com.sencha.gxt.widget.core.client.Window;
+import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer;
+import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData;
+import com.sencha.gxt.widget.core.client.event.CancelEditEvent;
+import com.sencha.gxt.widget.core.client.event.CancelEditEvent.CancelEditHandler;
+import com.sencha.gxt.widget.core.client.event.CompleteEditEvent;
+import com.sencha.gxt.widget.core.client.event.CompleteEditEvent.CompleteEditHandler;
+import com.sencha.gxt.widget.core.client.event.HideEvent;
+import com.sencha.gxt.widget.core.client.event.HideEvent.HideHandler;
+import com.sencha.gxt.widget.core.client.event.RowDoubleClickEvent;
+import com.sencha.gxt.widget.core.client.event.RowDoubleClickEvent.RowDoubleClickHandler;
+import com.sencha.gxt.widget.core.client.grid.ColumnConfig;
+import com.sencha.gxt.widget.core.client.grid.ColumnModel;
+import com.sencha.gxt.widget.core.client.grid.Grid.GridCell;
+import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent;
+import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent.SelectionChangedHandler;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class StackManagerViewImpl implements StackManagerView, HideHandler {
+
+  private static final String TITLE = "Stack Manager";
+
+  private StackPile                             stackPile;
+  private StackManagerPresenter                 stackManagerPresenter;
+
+  private Window                                window;
+  private VerticalLayoutContainer               verticalLayoutContainer;
+  private StackManagerTreeGrid                  treeGrid;
+  private ColumnConfig<StackModel, StackType>   typeConfig;
+  private ColumnConfig<StackModel, String>      nameConfig;
+  private ColumnConfig<StackModel, Date>        dateConfig;
+  private ColumnConfig<StackModel, Long>        sizeConfig;
+  private ColumnModel<StackModel>               columnModel;
+  private StackManagerIconProvider              stackManagerIconProvider;
+  private StackManagerSizeCell                  stackManagerSizeCell;
+  private StackManagerGridInlineEditing         gridEditing;
+  private StackManagerToolBar                   stackManagerToolBar;
+  private StackManagerMenu                      stackManagerMenu;
+  private SelectionChangedHandler<StackModel>   selectionChangedHandler;
+  private TreeGridDragSource<StackModel>        treeGridDragSource;
+  private TreeGridDropTarget<StackModel>        treeGridDropTarget;
+  private RowDoubleClickHandler                 rowDoubleClickHandler;
+  private CompleteEditHandler<StackModel>       completeEditHandler;
+  private CancelEditHandler<StackModel>         cancelEditHandler;
+  private StackModel                            editStackModel;
+
+  public StackManagerViewImpl(StackManagerPresenter stackManagerPresenter, StackPile stackPile) {
+    this.stackManagerPresenter = stackManagerPresenter;
+    this.stackPile = stackPile;
+  }
+
+  @Override
+  public Widget asWidget() {
+    return getWindow();
+  }
+
+  @Override
+  public void collapse() {
+    StackModel fileModel = getTreeGrid().getSelectionModel().getSelectedItem();
+    if (fileModel == null) {
+      getTreeGrid().collapseAll();
+    } else {
+      getTreeGrid().setExpanded(fileModel, false, true);
+    }
+  }
+
+  @Override
+  public void editName(StackModel fileModel) {
+    editSaveStackModel(fileModel);
+    Element row = getTreeGrid().getView().getRow(fileModel);
+    int rowIndex = getTreeGrid().getView().findRowIndex(row);
+    getGridEditing().startEditing(new GridCell(rowIndex, 0));
+  }
+
+  @Override
+  public void expand() {
+    StackModel fileModel = getTreeGrid().getSelectionModel().getSelectedItem();
+    if (fileModel == null) {
+      getTreeGrid().expandAll();
+    } else {
+      getTreeGrid().setExpanded(fileModel, true, true);
+    }
+  }
+
+  @Override
+  public StackModel getSelectedItem() {
+    return getTreeGrid().getSelectionModel().getSelectedItem();
+  }
+
+  @Override
+  public List<StackModel> getSelectedItems() {
+    return getTreeGrid().getSelectionModel().getSelectedItems();
+  }
+
+  @Override
+  public void onHide(HideEvent event) {
+    getTreeGrid().unbind();
+  }
+
+  @Override
+  public void selectStackModel(StackModel fileModel) {
+    getTreeGrid().setExpanded(fileModel, true);
+    getTreeGrid().getSelectionModel().select(fileModel, false);
+  }
+
+  StackPile getStackPile() {
+    return stackPile;
+  }
+
+  /**
+   * Works around a minor issue with TreeGrid and program initiated GridEditing in which the selection is lost if the
+   * user clicks in the active EditField.
+   */
+  private void editRestoreStackModel() {
+    if (editStackModel != null) {
+      getTreeGrid().getSelectionModel().select(editStackModel, false);
+    }
+  }
+
+  private void editSaveStackModel(StackModel editStackModel) {
+    this.editStackModel = editStackModel;
+  }
+
+  private CancelEditHandler<StackModel> getCancelEditHandler() {
+    if (cancelEditHandler == null) {
+      cancelEditHandler = new CancelEditHandler<StackModel>() {
+        @Override
+        public void onCancelEdit(CancelEditEvent<StackModel> event) {
+          /*
+           * Works around a minor issue with GridInlineEditing in which any update operation that does not change the
+           * value is reported as a cancel.
+           */
+          if (gridEditing.isEnter()) {
+            completeEditing();
+          } else {
+            getStackManagerPresenter().onEditStackNameComplete(false);
+          }
+        }
+      };
+    }
+    return cancelEditHandler;
+  }
+
+  private ColumnModel<StackModel> getColumnModel() {
+    if (columnModel == null) {
+      List<ColumnConfig<StackModel, ?>> columnConfigs = new ArrayList<ColumnConfig<StackModel, ?>>();
+      columnConfigs.add(getNameConfig());
+      columnConfigs.add(getDateConfig());
+      columnConfigs.add(getTypeConfig());
+      columnConfigs.add(getSizeConfig());
+      columnModel = new ColumnModel<StackModel>(columnConfigs);
+    }
+    return columnModel;
+  }
+
+  private CompleteEditHandler<StackModel> getCompleteEditHandler() {
+    if (completeEditHandler == null) {
+      completeEditHandler = new CompleteEditHandler<StackModel>() {
+        @Override
+        public void onCompleteEdit(CompleteEditEvent<StackModel> event) {
+          completeEditing();
+        }
+      };
+    }
+    return completeEditHandler;
+  }
+
+  private ColumnConfig<StackModel, Date> getDateConfig() {
+    if (dateConfig == null) {
+      dateConfig = new ColumnConfig<StackModel, Date>(getStackModelProperties().lastModified(), 100, "Date");
+      dateConfig.setCell(new DateCell(DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_MEDIUM)));
+    }
+    return dateConfig;
+  }
+
+  private IconProvider<StackModel> getStackManagerIconProvider() {
+    if (stackManagerIconProvider == null) {
+      stackManagerIconProvider = new StackManagerIconProvider();
+    }
+    return stackManagerIconProvider;
+  }
+
+  private StackManagerMenu getStackManagerMenu() {
+    if (stackManagerMenu == null) {
+      stackManagerMenu = new StackManagerMenu(getStackManagerPresenter());
+    }
+    return stackManagerMenu;
+  }
+
+  private StackManagerPresenter getStackManagerPresenter() {
+    return stackManagerPresenter;
+  }
+
+  private StackManagerSizeCell getStackManagerSizeCell() {
+    if (stackManagerSizeCell == null) {
+      stackManagerSizeCell = new StackManagerSizeCell(getStackPile());
+    }
+    return stackManagerSizeCell;
+  }
+
+  private StackManagerToolBar getStackManagerToolBar() {
+    if (stackManagerToolBar == null) {
+      stackManagerToolBar = new StackManagerToolBar(getStackManagerPresenter());
+      stackManagerToolBar.setButtonEnabledState();
+    }
+    return stackManagerToolBar;
+  }
+
+  private StackModelProperties getStackModelProperties() {
+    return getStackPile().getStackModelProperties();
+  }
+
+  private StackManagerGridInlineEditing getGridEditing() {
+    if (gridEditing == null) {
+      gridEditing = new StackManagerGridInlineEditing(getTreeGrid());
+      gridEditing.setClicksToEdit(null);
+      gridEditing.addEditor(getNameConfig(), gridEditing.getTextField());
+      gridEditing.addCompleteEditHandler(getCompleteEditHandler());
+      gridEditing.addCancelEditHandler(getCancelEditHandler());
+    }
+    return gridEditing;
+  }
+
+  private ColumnConfig<StackModel, String> getNameConfig() {
+    if (nameConfig == null) {
+      nameConfig = new ColumnConfig<StackModel, String>(getStackModelProperties().name(), 200, "Name");
+    }
+    return nameConfig;
+  }
+
+  private RowDoubleClickHandler getRowDoubleClickHandler() {
+    if (rowDoubleClickHandler == null) {
+      rowDoubleClickHandler = new RowDoubleClickHandler() {
+        @Override
+        public void onRowDoubleClick(RowDoubleClickEvent event) {
+          getStackManagerPresenter().onOpen();
+        }
+      };
+    }
+    return rowDoubleClickHandler;
+  }
+
+  private SelectionChangedHandler<StackModel> getSelectionChangedHandler() {
+    if (selectionChangedHandler == null) {
+      selectionChangedHandler = new SelectionChangedHandler<StackModel>() {
+        @Override
+        public void onSelectionChanged(SelectionChangedEvent<StackModel> event) {
+          StackModel fileModel = treeGrid.getSelectionModel().getSelectedItem();
+          if (fileModel != null) {
+            getStackManagerPresenter().onSelect(fileModel);
+          }
+          getStackManagerToolBar().setButtonEnabledState();
+          getWindow().setHeadingText(getTitle(fileModel));
+        }
+      };
+    }
+    return selectionChangedHandler;
+  }
+
+  private ColumnConfig<StackModel, Long> getSizeConfig() {
+    if (sizeConfig == null) {
+      sizeConfig = new ColumnConfig<StackModel, Long>(getStackModelProperties().size(), 100, "Size");
+      sizeConfig.setCell(getStackManagerSizeCell());
+    }
+    return sizeConfig;
+  }
+
+  private String getTitle(StackModel fileModel) {
+    return fileModel == null ? TITLE : TITLE + " - " + getStackPile().getPath(fileModel);
+  }
+
+  private StackManagerTreeGrid getTreeGrid() {
+    if (treeGrid == null) {
+      treeGrid = new StackManagerTreeGrid(getStackPile().getTreeStore(), getColumnModel(), getNameConfig());
+      treeGrid.getView().setEmptyText("Use tool bar or context menu to create files and folders.");
+      treeGrid.setBorders(false);
+      treeGrid.getView().setTrackMouseOver(false);
+      treeGrid.getView().setForceFit(true);
+      treeGrid.getView().setAutoFill(true);
+      treeGrid.setIconProvider(getStackManagerIconProvider());
+      treeGrid.setContextMenu(getStackManagerMenu().getStackMenu());
+      treeGrid.getSelectionModel().addSelectionChangedHandler(getSelectionChangedHandler());
+      treeGrid.addRowDoubleClickHandler(getRowDoubleClickHandler());
+      getGridEditing();
+      getTreeGridDragSource();
+      getTreeGridDropTarget();
+    }
+    return treeGrid;
+  }
+
+  private TreeGridDragSource<StackModel> getTreeGridDragSource() {
+    if (treeGridDragSource == null) {
+      treeGridDragSource = new TreeGridDragSource<StackModel>(getTreeGrid());
+    }
+    return treeGridDragSource;
+  }
+
+  private TreeGridDropTarget<StackModel> getTreeGridDropTarget() {
+    if (treeGridDropTarget == null) {
+      treeGridDropTarget = new TreeGridDropTarget<StackModel>(getTreeGrid());
+      treeGridDropTarget.setAllowSelfAsSource(true);
+      treeGridDropTarget.setFeedback(Feedback.BOTH);
+    }
+    return treeGridDropTarget;
+  }
+
+  private ColumnConfig<StackModel, ?> getTypeConfig() {
+    if (typeConfig == null) {
+      typeConfig = new ColumnConfig<StackModel, StackType>(getStackModelProperties().stackType(), 100, "Type");
+    }
+    return typeConfig;
+  }
+
+  private VerticalLayoutContainer getVerticalLayoutContainer() {
+    if (verticalLayoutContainer == null) {
+      verticalLayoutContainer = new VerticalLayoutContainer();
+      verticalLayoutContainer.setBorders(true);
+      verticalLayoutContainer.add(getStackManagerToolBar(), new VerticalLayoutData(1, -1));
+      verticalLayoutContainer.add(getTreeGrid(), new VerticalLayoutData(1, 1));
+    }
+    return verticalLayoutContainer;
+  }
+
+  private Window getWindow() {
+    if (window == null) {
+      window = new Window();
+      window.setHeadingText(getTitle(null));
+      window.getHeader().setIcon(Images.getImageResources().folder());
+      window.setMinimizable(true);
+      window.setMaximizable(true);
+      window.setPixelSize(500, 400);
+      window.setOnEsc(false);
+      window.addHideHandler(this);
+      window.setWidget(getVerticalLayoutContainer());
+    }
+    return window;
+  }
+
+  private void completeEditing() {
+    editRestoreStackModel();
+    getStackManagerPresenter().onEditStackNameComplete(true);
+    // Give the change a chance to propagate to model and store
+    Scheduler.get().scheduleFixedDelay(new RepeatingCommand() {
+      @Override
+      public boolean execute() {
+        getWindow().setHeadingText(getTitle(getSelectedItem()));
+        return false;
+      }
+    }, 250);
+  }
+}