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.resources.client.ClientBundle;\r
  34 import com.google.gwt.resources.client.ImageResource;\r
  35 import com.google.gwt.user.client.Command;\r
  36 import com.google.gwt.user.client.DeferredCommand;\r
  37 import com.google.gwt.user.client.ui.Composite;\r
  38 import com.google.gwt.user.client.ui.Tree;\r
  39 import com.google.gwt.user.client.ui.TreeItem;\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 ClientBundle,Tree.Resources, FolderContextMenu.Images {\r
  55 \r
  56                 @Source("gr/ebs/gss/resources/folder_home.png")\r
  57                 ImageResource home();\r
  58 \r
  59                 @Source("gr/ebs/gss/resources/folder_yellow.png")\r
  60                 ImageResource folderYellow();\r
  61 \r
  62                 @Source("gr/ebs/gss/resources/mimetypes/document.png")\r
  63                 ImageResource document();\r
  64 \r
  65                 @Source("gr/ebs/gss/resources/internet.png")\r
  66                 ImageResource othersShared();\r
  67 \r
  68                 @Source("gr/ebs/gss/resources/edit_user.png")\r
  69                 ImageResource myShared();\r
  70 \r
  71                 @Source("gr/ebs/gss/resources/folder_user.png")\r
  72                 ImageResource sharedFolder();\r
  73 \r
  74                 @Source("gr/ebs/gss/resources/trashcan_empty.png")\r
  75                 ImageResource 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);\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                 }\r
 143                 else if (isMySharedItem(folderItem)){\r
 144                         myShareSubtree.updateFolderAndSubfolders(folderItem);\r
 145                         if (folderItem.getFolderResource() != null) {\r
 146                                 DnDTreeItem fitem = (DnDTreeItem) getUserItem(getRootItem(), folderItem.getFolderResource().getUri());\r
 147                                 if (fitem != null)\r
 148                                         folderSubtree.updateFolderAndSubfolders(fitem);\r
 149                                 else\r
 150                                         folderSubtree.updateFolderAndSubfolders((DnDTreeItem) getRootItem());\r
 151                         }\r
 152 \r
 153                 }\r
 154                 else if (isTrashItem(folderItem))\r
 155                         trashSubtree.update();\r
 156                 else if (isOthersSharedItem(folderItem))\r
 157                         othersSharesSubtree.updateFolderAndSubfolders(folderItem);\r
 158         }\r
 159 \r
 160         /**\r
 161          * Retrieve the current.\r
 162          *\r
 163          * @return the current\r
 164          */\r
 165         public TreeItem getCurrent() {\r
 166                 return tree.getTreeSelectedItem();\r
 167         }\r
 168 \r
 169         /**\r
 170          * Modify the current.\r
 171          *\r
 172          * @param _current the current to set\r
 173          */\r
 174         void setCurrent(final TreeItem _current) {\r
 175                 tree.setTreeSelectedItem(_current);\r
 176         }\r
 177 \r
 178         /**\r
 179          * Checks whether a TreeItem is contained in the root folder structure\r
 180          *\r
 181          * @param item The TreeItem to check\r
 182          */\r
 183         public boolean isFileItem(TreeItem item) {\r
 184                 if (getRootOfItem(item).equals(getRootItem()))\r
 185                         return true;\r
 186                 return false;\r
 187         }\r
 188 \r
 189         /**\r
 190          * Checks whether a TreeItem is contained in the trash folder structure\r
 191          *\r
 192          * @param item The TreeItem to check\r
 193          */\r
 194         public boolean isTrashItem(TreeItem item) {\r
 195                 if (getRootOfItem(item).equals(getTrashItem()))\r
 196                         return true;\r
 197                 return false;\r
 198         }\r
 199 \r
 200         /**\r
 201          * Checks whether a TreeItem is contained in the trash folder structure\r
 202          *\r
 203          * @param item The TreeItem to check\r
 204          */\r
 205         public boolean isOthersSharedItem(TreeItem item) {\r
 206                 if (getRootOfItem(item).equals(getSharesItem()))\r
 207                         return true;\r
 208                 return false;\r
 209         }\r
 210 \r
 211         /**\r
 212          * Checks whether a TreeItem is contained in the trash folder structure\r
 213          *\r
 214          * @param item The TreeItem to check\r
 215          */\r
 216         public boolean isMySharedItem(TreeItem item) {\r
 217                 if (getRootOfItem(item).equals(getMySharesItem()))\r
 218                         return true;\r
 219                 return false;\r
 220         }\r
 221 \r
 222         private TreeItem getRootOfItem(TreeItem item) {\r
 223                 if (item.getParentItem() == null)\r
 224                         return item;\r
 225                 TreeItem toCheck = item;\r
 226                 while (toCheck.getParentItem() != null) {\r
 227                         toCheck = toCheck.getParentItem();\r
 228                         toCheck = getRootOfItem(toCheck);\r
 229                 }\r
 230                 return toCheck;\r
 231         }\r
 232 \r
 233         public TreeItem getUserOfSharedItem(TreeItem item) {\r
 234                 if (item.getUserObject() instanceof OtherUserResource)\r
 235                         return item;\r
 236                 TreeItem test = item;\r
 237                 while (test.getParentItem() != null) {\r
 238                         test = test.getParentItem();\r
 239                         if (test.getUserObject() instanceof OtherUserResource)\r
 240                                 return test;\r
 241                 }\r
 242                 return null;\r
 243         }\r
 244 \r
 245         public boolean isTrash(TreeItem item) {\r
 246                 return item.equals(getTrashItem());\r
 247         }\r
 248 \r
 249         public boolean isMyShares(TreeItem item) {\r
 250                 return item.equals(getMySharesItem());\r
 251         }\r
 252 \r
 253         public boolean isOthersShared(TreeItem item) {\r
 254                 return item.equals(getSharesItem());\r
 255         }\r
 256 \r
 257         /*\r
 258          * Returns the Tree Item corresponding to the FolderDTO object\r
 259          * since we need to update main file structure for untrashed folders\r
 260          */\r
 261         public TreeItem getUserItem(FolderResource folder) {\r
 262                 return getUserItem(getRootItem(), folder);\r
 263         }\r
 264 \r
 265         public TreeItem getOtherSharedItem(FolderResource folder) {\r
 266                 return getUserItem(getSharesItem(), folder);\r
 267         }\r
 268 \r
 269         private TreeItem getUserItem(TreeItem parent, FolderResource folder) {\r
 270                 TreeItem tmp = null;\r
 271                 if (parent.getUserObject() instanceof FolderResource &&\r
 272                                         (parent.getUserObject().equals(folder) ||\r
 273                                         ((FolderResource) parent.getUserObject()).getUri().equals(folder.getUri())))\r
 274                         return parent;\r
 275                 for (int i = 0; i < parent.getChildCount(); i++) {\r
 276                         TreeItem child = parent.getChild(i);\r
 277                         if (child.getUserObject() instanceof FolderResource) {\r
 278                                 FolderResource dto = (FolderResource) child.getUserObject();\r
 279                                 if (dto.equals(folder) || dto.getUri().equals(folder.getUri()))\r
 280                                         return child;\r
 281                         }\r
 282                         tmp = getUserItem(child, folder);\r
 283                         if (tmp != null)\r
 284                                 return tmp;\r
 285                 }\r
 286                 return null;\r
 287         }\r
 288 \r
 289         /**\r
 290          * Retrieve the trashItem.\r
 291          *\r
 292          * @return the trashItem\r
 293          */\r
 294         public TreeItem getTrashItem() {\r
 295                 return trashSubtree.getRootItem();\r
 296         }\r
 297 \r
 298         /**\r
 299          * Retrieve the rootItem.\r
 300          *\r
 301          * @return the rootItem\r
 302          */\r
 303         public TreeItem getRootItem() {\r
 304                 return folderSubtree.getRootItem();\r
 305         }\r
 306 \r
 307         /**\r
 308          * Retrieve the mySharesItem.\r
 309          *\r
 310          * @return the mySharesItem\r
 311          */\r
 312         public TreeItem getMySharesItem() {\r
 313                 return myShareSubtree.getRootItem();\r
 314         }\r
 315 \r
 316         /**\r
 317          * Retrieve the sharesItem.\r
 318          *\r
 319          * @return the sharesItem\r
 320          */\r
 321         public TreeItem getSharesItem() {\r
 322                 return othersSharesSubtree.getRootItem();\r
 323         }\r
 324 \r
 325         public void onFolderTrash(TreeItem folder) {\r
 326                 if (folder.getParentItem().getUserObject() instanceof FolderResource) {\r
 327                         FolderResource folderDTO = (FolderResource) folder.getParentItem().getUserObject();\r
 328                         updateFileAndShareNodes(folderDTO);\r
 329                 } else\r
 330                         update(getMySharesItem());\r
 331                 update(getTrashItem());\r
 332                 clearSelection();\r
 333                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 334         }\r
 335 \r
 336         public void onFolderDelete(TreeItem folder) {\r
 337                 if (folder.getParentItem().getUserObject() instanceof FolderResource) {\r
 338                         FolderResource folderDTO = (FolderResource) folder.getParentItem().getUserObject();\r
 339                         updateFileAndShareNodes(folderDTO);\r
 340                 } else\r
 341                         update(getMySharesItem());\r
 342                 GSS.get().getStatusPanel().updateStats();\r
 343                 clearSelection();\r
 344                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 345         }\r
 346 \r
 347         public void onFolderCopy(TreeItem folder) {\r
 348                 if (!updateFileAndShareNodes((FolderResource) folder.getUserObject()))\r
 349                         update(folder);\r
 350                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 351                 GSS.get().getStatusPanel().updateStats();\r
 352         }\r
 353 \r
 354         public void onFolderMove(TreeItem folder, FolderResource initialParent) {\r
 355                 updateFileAndShareNodes(initialParent);\r
 356                 updateFileAndShareNodes((FolderResource) folder.getUserObject());\r
 357                 update(folder);\r
 358                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 359                 GSS.get().getStatusPanel().updateStats();\r
 360                 clearSelection();\r
 361         }\r
 362 \r
 363         private boolean updateFileAndShareNodes(FolderResource folder) {\r
 364                 boolean updated = false;\r
 365                 TreeItem sharesFolder = getUserItem(getMySharesItem(), folder);\r
 366                 if (sharesFolder != null) {\r
 367                         update(sharesFolder);\r
 368                         updated = true;\r
 369                 }\r
 370                 TreeItem fileFolder = getUserItem(getRootItem(), folder);\r
 371                 if (fileFolder != null) {\r
 372                         update(fileFolder);\r
 373                         updated = true;\r
 374                 }\r
 375                 return updated;\r
 376         }\r
 377 \r
 378         public void initialize() {\r
 379                 DeferredCommand.addCommand(new Command() {\r
 380 \r
 381                         public void execute() {\r
 382                                 GSS.get().showLoadingIndicator();\r
 383                                 folderSubtree.getRootItem().removeItems();\r
 384                                 trashSubtree.getRootItem().removeItems();\r
 385                                 myShareSubtree.getRootItem().removeItems();\r
 386                                 othersSharesSubtree.getRootItem().removeItems();\r
 387                                 update(folderSubtree.getRootItem());\r
 388                                 update(trashSubtree.getRootItem());\r
 389                                 update(myShareSubtree.getRootItem());\r
 390                                 update(othersSharesSubtree.getRootItem());\r
 391                                 GSS.get().setCurrentSelection(null);\r
 392                                 clearSelection();\r
 393                                 GSS.get().getFileList().updateFileCache(false, true /*clear selection*/);\r
 394                                 GSS.get().hideLoadingIndicator();\r
 395                         }\r
 396 \r
 397                 });\r
 398         }\r
 399 \r
 400         /* NEW HANDLING METHODS */\r
 401         public TreeItem getUserItem(TreeItem parent, String path) {\r
 402                 TreeItem tmp = null;\r
 403                 if (parent.getUserObject() instanceof RestResource && ((RestResource) parent.getUserObject()).getUri().equals(path))\r
 404                         return parent;\r
 405                 for (int i = 0; i < parent.getChildCount(); i++) {\r
 406                         TreeItem child = parent.getChild(i);\r
 407                         if (child.getUserObject() instanceof RestResource) {\r
 408                                 RestResource dto = (RestResource) child.getUserObject();\r
 409                                 if (dto.getUri().equals(path))\r
 410                                         return child;\r
 411                         }\r
 412                         tmp = getUserItem(child, path);\r
 413                         if (tmp != null)\r
 414                                 return tmp;\r
 415                 }\r
 416                 return null;\r
 417         }\r
 418 \r
 419         public List<TreeItem> getItemsOfTreeForPath(String path) {\r
 420                 List<TreeItem> result = new ArrayList<TreeItem>();\r
 421                 TreeItem item = null;\r
 422                 item = getUserItem(getRootItem(), path);\r
 423                 if (item != null)\r
 424                         result.add(item);\r
 425                 item = getUserItem(getMySharesItem(), path);\r
 426                 if (item != null)\r
 427                         result.add(item);\r
 428                 item = getUserItem(getTrashItem(), path);\r
 429                 if (item != null)\r
 430                         result.add(item);\r
 431                 item = getUserItem(getSharesItem(), path);\r
 432                 if (item != null)\r
 433                         result.add(item);\r
 434                 return result;\r
 435         }\r
 436         /**\r
 437          *\r
 438          * @return the popuptree\r
 439          */\r
 440         public PopupTree getPopupTree(){\r
 441                 return tree;\r
 442         }\r
 443 }\r