code.grnet.gr Git - pithos/blob - src/gr/ebs/gss/client/Folders.java

   1 /*\r
   2  * Copyright 2007, 2008, 2009 Electronic Business Systems Ltd.\r
   3  *\r
   4  * This file is part of GSS.\r
   5  *\r
   6  * GSS is free software: you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation, either version 3 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * GSS is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with GSS.  If not, see <http://www.gnu.org/licenses/>.\r
  18  */\r
  19 package gr.ebs.gss.client;\r
  20 \r
  21 import gr.ebs.gss.client.dnd.DnDTreeItem;\r
  22 import gr.ebs.gss.client.rest.resource.FolderResource;\r
  23 import gr.ebs.gss.client.rest.resource.OtherUserResource;\r
  24 import gr.ebs.gss.client.rest.resource.RestResource;\r
  25 import gr.ebs.gss.client.tree.FolderSubtree;\r
  26 import gr.ebs.gss.client.tree.MyShareSubtree;\r
  27 import gr.ebs.gss.client.tree.OthersSharesSubtree;\r
  28 import gr.ebs.gss.client.tree.TrashSubtree;\r
  29 \r
  30 import java.util.ArrayList;\r
  31 import java.util.List;\r
  32 \r
  33 import com.google.gwt.user.client.Command;\r
  34 import com.google.gwt.user.client.DeferredCommand;\r
  35 import com.google.gwt.user.client.ui.AbstractImagePrototype;\r
  36 import com.google.gwt.user.client.ui.Composite;\r
  37 import com.google.gwt.user.client.ui.TreeImages;\r
  38 import com.google.gwt.user.client.ui.TreeItem;\r
  39 \r
  40 /**\r
  41  * A tree displaying the folders in the user's file space.\r
  42  */\r
  43 public class Folders extends Composite {\r
  44 \r
  45         /**\r
  46          * A constant that denotes the completion of an IncrementalCommand.\r
  47          */\r
  48         public static final boolean DONE = false;\r
  49 \r
  50         /**\r
  51          * Specifies the images that will be bundled for this Composite and other\r
  52          * inherited images that will be included in the same bundle.\r
  53          */\r
  54         public interface Images extends TreeImages, FolderContextMenu.Images {\r
  55 \r
  56                 @Resource("gr/ebs/gss/resources/folder_home.png")\r
  57                 AbstractImagePrototype home();\r
  58 \r
  59                 @Resource("gr/ebs/gss/resources/folder_yellow.png")\r
  60                 AbstractImagePrototype folderYellow();\r
  61 \r
  62                 @Resource("gr/ebs/gss/resources/mimetypes/document.png")\r
  63                 AbstractImagePrototype document();\r
  64 \r
  65                 @Resource("gr/ebs/gss/resources/internet.png")\r
  66                 AbstractImagePrototype othersShared();\r
  67 \r
  68                 @Resource("gr/ebs/gss/resources/edit_user.png")\r
  69                 AbstractImagePrototype myShared();\r
  70 \r
  71                 @Resource("gr/ebs/gss/resources/folder_user.png")\r
  72                 AbstractImagePrototype sharedFolder();\r
  73 \r
  74                 @Resource("gr/ebs/gss/resources/trashcan_empty.png")\r
  75                 AbstractImagePrototype trash();\r
  76         }\r
  77 \r
  78         /**\r
  79          * The widget's image bundle.\r
  80          */\r
  81         private final Images images;\r
  82 \r
  83         /**\r
  84          * The tree widget that displays the folder namespace.\r
  85          */\r
  86         private PopupTree tree;\r
  87 \r
  88         /**\r
  89          * A cached copy of the currently selected folder widget.\r
  90          */\r
  91         private FolderSubtree folderSubtree;\r
  92 \r
  93         private TrashSubtree trashSubtree;\r
  94 \r
  95         private MyShareSubtree myShareSubtree;\r
  96 \r
  97         private OthersSharesSubtree othersSharesSubtree;\r
  98 \r
  99         /**\r
 100          * Constructs a new folders widget with a bundle of images.\r
 101          *\r
 102          * @param _images a bundle that provides the images for this widget\r
 103          */\r
 104         public Folders(final Images _images) {\r
 105                 images = _images;\r
 106                 tree = new PopupTree(images);\r
 107                 tree.setAnimationEnabled(true);\r
 108                 initWidget(tree);\r
 109                 folderSubtree = new FolderSubtree(tree, images);\r
 110                 myShareSubtree = new MyShareSubtree(tree, images);\r
 111                 trashSubtree = new TrashSubtree(tree, images);\r
 112                 othersSharesSubtree = new OthersSharesSubtree(tree, images);\r
 113         }\r
 114 \r
 115         public Images getImages() {\r
 116                 return images;\r
 117         }\r
 118 \r
 119         public void select(TreeItem item) {\r
 120                 tree.processItemSelected(item, true);\r
 121         }\r
 122 \r
 123         public void clearSelection() {\r
 124                 tree.clearSelection();\r
 125         }\r
 126 \r
 127         public void update(TreeItem item) {\r
 128                 if (isFileItem(item))\r
 129                         folderSubtree.updateSubfolders((DnDTreeItem) item);\r
 130                 else if (isTrash(item))\r
 131                         trashSubtree.update();\r
 132                 else if (isMySharedItem(item))\r
 133                         myShareSubtree.update((DnDTreeItem) item);\r
 134                 else if (isOthersSharedItem(item))\r
 135                         othersSharesSubtree.update((DnDTreeItem) item);\r
 136         }\r
 137 \r
 138         public void updateFolder(final DnDTreeItem folderItem) {\r
 139                 if (isFileItem(folderItem)) {\r
 140                         folderSubtree.updateFolderAndSubfolders(folderItem);\r
 141                         myShareSubtree.updateFolderAndSubfolders((DnDTreeItem) getMySharesItem());\r
 142                 } else if (isMySharedItem(folderItem)) {\r
 143                         myShareSubtree.updateFolderAndSubfolders(folderItem);\r
 144                         if (folderItem.getFolderResource() != null) {\r
 145                                 DnDTreeItem fitem = (DnDTreeItem) getUserItem(getRootItem(), folderItem.getFolderResource().getUri());\r
 146                                 if (fitem != null)\r
 147                                         folderSubtree.updateFolderAndSubfolders(fitem);\r
 148                         } else\r
 149                                 folderSubtree.updateFolderAndSubfolders((DnDTreeItem) getRootItem());\r
 150                 } else if (isTrashItem(folderItem))\r
 151                         trashSubtree.update();\r
 152                 else if (isOthersShared(folderItem))\r
 153                         othersSharesSubtree.updateFolderAndSubfolders(folderItem);\r
 154         }\r
 155 \r
 156         /**\r
 157          * Retrieve the current.\r
 158          *\r
 159          * @return the current\r
 160          */\r
 161         public TreeItem getCurrent() {\r
 162                 return tree.getTreeSelectedItem();\r
 163         }\r
 164 \r
 165         /**\r
 166          * Modify the current.\r
 167          *\r
 168          * @param _current the current to set\r
 169          */\r
 170         void setCurrent(final TreeItem _current) {\r
 171                 tree.setTreeSelectedItem(_current);\r
 172         }\r
 173 \r
 174         /**\r
 175          * Checks whether a TreeItem is contained in the root folder structure\r
 176          *\r
 177          * @param item The TreeItem to check\r
 178          */\r
 179         public boolean isFileItem(TreeItem item) {\r
 180                 if (getRootOfItem(item).equals(getRootItem()))\r
 181                         return true;\r
 182                 return false;\r
 183         }\r
 184 \r
 185         /**\r
 186          * Checks whether a TreeItem is contained in the trash folder structure\r
 187          *\r
 188          * @param item The TreeItem to check\r
 189          */\r
 190         public boolean isTrashItem(TreeItem item) {\r
 191                 if (getRootOfItem(item).equals(getTrashItem()))\r
 192                         return true;\r
 193                 return false;\r
 194         }\r
 195 \r
 196         /**\r
 197          * Checks whether a TreeItem is contained in the trash folder structure\r
 198          *\r
 199          * @param item The TreeItem to check\r
 200          */\r
 201         public boolean isOthersSharedItem(TreeItem item) {\r
 202                 if (getRootOfItem(item).equals(getSharesItem()))\r
 203                         return true;\r
 204                 return false;\r
 205         }\r
 206 \r
 207         /**\r
 208          * Checks whether a TreeItem is contained in the trash folder structure\r
 209          *\r
 210          * @param item The TreeItem to check\r
 211          */\r
 212         public boolean isMySharedItem(TreeItem item) {\r
 213                 if (getRootOfItem(item).equals(getMySharesItem()))\r
 214                         return true;\r
 215                 return false;\r
 216         }\r
 217 \r
 218         private TreeItem getRootOfItem(TreeItem item) {\r
 219                 if (item.getParentItem() == null)\r
 220                         return item;\r
 221                 TreeItem toCheck = item;\r
 222                 while (toCheck.getParentItem() != null) {\r
 223                         toCheck = toCheck.getParentItem();\r
 224                         toCheck = getRootOfItem(toCheck);\r
 225                 }\r
 226                 return toCheck;\r
 227         }\r
 228 \r
 229         public TreeItem getUserOfSharedItem(TreeItem item) {\r
 230                 if (item.getUserObject() instanceof OtherUserResource)\r
 231                         return item;\r
 232                 TreeItem test = item;\r
 233                 while (test.getParentItem() != null) {\r
 234                         test = test.getParentItem();\r
 235                         if (test.getUserObject() instanceof OtherUserResource)\r
 236                                 return test;\r
 237                 }\r
 238                 return null;\r
 239         }\r
 240 \r
 241         public boolean isTrash(TreeItem item) {\r
 242                 return item.equals(getTrashItem());\r
 243         }\r
 244 \r
 245         public boolean isMyShares(TreeItem item) {\r
 246                 return item.equals(getMySharesItem());\r
 247         }\r
 248 \r
 249         public boolean isOthersShared(TreeItem item) {\r
 250                 return item.equals(getSharesItem());\r
 251         }\r
 252 \r
 253         /*\r
 254          * Returns the Tree Item corresponding to the FolderDTO object\r
 255          * since we need to update main file structure for untrashed folders\r
 256          */\r
 257         public TreeItem getUserItem(FolderResource folder) {\r
 258                 return getUserItem(getRootItem(), folder);\r
 259         }\r
 260 \r
 261         public TreeItem getOtherSharedItem(FolderResource folder) {\r
 262                 return getUserItem(getSharesItem(), folder);\r
 263         }\r
 264 \r
 265         private TreeItem getUserItem(TreeItem parent, FolderResource folder) {\r
 266                 TreeItem tmp = null;\r
 267                 if (parent.getUserObject() instanceof FolderResource &&\r
 268                                         (parent.getUserObject().equals(folder) ||\r
 269                                         ((FolderResource) parent.getUserObject()).getUri().equals(folder.getUri())))\r
 270                         return parent;\r
 271                 for (int i = 0; i < parent.getChildCount(); i++) {\r
 272                         TreeItem child = parent.getChild(i);\r
 273                         if (child.getUserObject() instanceof FolderResource) {\r
 274                                 FolderResource dto = (FolderResource) child.getUserObject();\r
 275                                 if (dto.equals(folder) || dto.getUri().equals(folder.getUri()))\r
 276                                         return child;\r
 277                         }\r
 278                         tmp = getUserItem(child, folder);\r
 279                         if (tmp != null)\r
 280                                 return tmp;\r
 281                 }\r
 282                 return null;\r
 283         }\r
 284 \r
 285         /**\r
 286          * Retrieve the trashItem.\r
 287          *\r
 288          * @return the trashItem\r
 289          */\r
 290         public TreeItem getTrashItem() {\r
 291                 return trashSubtree.getRootItem();\r
 292         }\r
 293 \r
 294         /**\r
 295          * Retrieve the rootItem.\r
 296          *\r
 297          * @return the rootItem\r
 298          */\r
 299         public TreeItem getRootItem() {\r
 300                 return folderSubtree.getRootItem();\r
 301         }\r
 302 \r
 303         /**\r
 304          * Retrieve the mySharesItem.\r
 305          *\r
 306          * @return the mySharesItem\r
 307          */\r
 308         public TreeItem getMySharesItem() {\r
 309                 return myShareSubtree.getRootItem();\r
 310         }\r
 311 \r
 312         /**\r
 313          * Retrieve the sharesItem.\r
 314          *\r
 315          * @return the sharesItem\r
 316          */\r
 317         public TreeItem getSharesItem() {\r
 318                 return othersSharesSubtree.getRootItem();\r
 319         }\r
 320 \r
 321         public void onFolderTrash(TreeItem folder) {\r
 322                 if (folder.getParentItem().getUserObject() instanceof FolderResource) {\r
 323                         FolderResource folderDTO = (FolderResource) folder.getParentItem().getUserObject();\r
 324                         updateFileAndShareNodes(folderDTO);\r
 325                 } else\r
 326                         update(getMySharesItem());\r
 327                 update(getTrashItem());\r
 328                 clearSelection();\r
 329                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 330         }\r
 331 \r
 332         public void onFolderDelete(TreeItem folder) {\r
 333                 if (folder.getParentItem().getUserObject() instanceof FolderResource) {\r
 334                         FolderResource folderDTO = (FolderResource) folder.getParentItem().getUserObject();\r
 335                         updateFileAndShareNodes(folderDTO);\r
 336                 } else\r
 337                         update(getMySharesItem());\r
 338                 GSS.get().getStatusPanel().updateStats();\r
 339                 clearSelection();\r
 340                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 341         }\r
 342 \r
 343         public void onFolderCopy(TreeItem folder) {\r
 344                 if (!updateFileAndShareNodes((FolderResource) folder.getUserObject()))\r
 345                         update(folder);\r
 346                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 347                 GSS.get().getStatusPanel().updateStats();\r
 348         }\r
 349 \r
 350         public void onFolderMove(TreeItem folder, FolderResource initialParent) {\r
 351                 updateFileAndShareNodes(initialParent);\r
 352                 updateFileAndShareNodes((FolderResource) folder.getUserObject());\r
 353                 update(folder);\r
 354                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 355                 GSS.get().getStatusPanel().updateStats();\r
 356                 clearSelection();\r
 357         }\r
 358 \r
 359         private boolean updateFileAndShareNodes(FolderResource folder) {\r
 360                 boolean updated = false;\r
 361                 TreeItem sharesFolder = getUserItem(getMySharesItem(), folder);\r
 362                 if (sharesFolder != null) {\r
 363                         update(sharesFolder);\r
 364                         updated = true;\r
 365                 }\r
 366                 TreeItem fileFolder = getUserItem(getRootItem(), folder);\r
 367                 if (fileFolder != null) {\r
 368                         update(fileFolder);\r
 369                         updated = true;\r
 370                 }\r
 371                 return updated;\r
 372         }\r
 373 \r
 374         public void initialize() {\r
 375                 DeferredCommand.addCommand(new Command() {\r
 376 \r
 377                         public void execute() {\r
 378                                 GSS.get().showLoadingIndicator();\r
 379                                 folderSubtree.getRootItem().removeItems();\r
 380                                 trashSubtree.getRootItem().removeItems();\r
 381                                 myShareSubtree.getRootItem().removeItems();\r
 382                                 othersSharesSubtree.getRootItem().removeItems();\r
 383                                 update(folderSubtree.getRootItem());\r
 384                                 update(trashSubtree.getRootItem());\r
 385                                 update(myShareSubtree.getRootItem());\r
 386                                 update(othersSharesSubtree.getRootItem());\r
 387                                 GSS.get().setCurrentSelection(null);\r
 388                                 clearSelection();\r
 389                                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 390                                 GSS.get().hideLoadingIndicator();\r
 391                         }\r
 392 \r
 393                 });\r
 394         }\r
 395 \r
 396         /* NEW HANDLING METHODS */\r
 397         public TreeItem getUserItem(TreeItem parent, String path) {\r
 398                 TreeItem tmp = null;\r
 399                 if (parent.getUserObject() instanceof RestResource && ((RestResource) parent.getUserObject()).getUri().equals(path))\r
 400                         return parent;\r
 401                 for (int i = 0; i < parent.getChildCount(); i++) {\r
 402                         TreeItem child = parent.getChild(i);\r
 403                         if (child.getUserObject() instanceof RestResource) {\r
 404                                 RestResource dto = (RestResource) child.getUserObject();\r
 405                                 if (dto.getUri().equals(path))\r
 406                                         return child;\r
 407                         }\r
 408                         tmp = getUserItem(child, path);\r
 409                         if (tmp != null)\r
 410                                 return tmp;\r
 411                 }\r
 412                 return null;\r
 413         }\r
 414 \r
 415         public List<TreeItem> getItemsOfTreeForPath(String path) {\r
 416                 List<TreeItem> result = new ArrayList<TreeItem>();\r
 417                 TreeItem item = null;\r
 418                 item = getUserItem(getRootItem(), path);\r
 419                 if (item != null)\r
 420                         result.add(item);\r
 421                 item = getUserItem(getMySharesItem(), path);\r
 422                 if (item != null)\r
 423                         result.add(item);\r
 424                 item = getUserItem(getTrashItem(), path);\r
 425                 if (item != null)\r
 426                         result.add(item);\r
 427                 item = getUserItem(getSharesItem(), path);\r
 428                 if (item != null)\r
 429                         result.add(item);\r
 430                 return result;\r
 431         }\r
 432 }\r