service/simulator/java/eclipse-plugin/ClientControllerPlugin/src/oic/simulator/clientcontroller/view/ResourceManagerView.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.clientcontroller.view;
  18
  19 import java.util.List;
  20 import java.util.Set;
  21
  22 import oic.simulator.clientcontroller.Activator;
  23 import oic.simulator.clientcontroller.listener.IFindResourceUIListener;
  24 import oic.simulator.clientcontroller.manager.ResourceManager;
  25 import oic.simulator.clientcontroller.remoteresource.RemoteResource;
  26 import oic.simulator.clientcontroller.utils.Constants;
  27 import oic.simulator.clientcontroller.view.dialogs.FindResourceWizard;
  28 import oic.simulator.clientcontroller.view.dialogs.LoadRAMLDialog;
  29 import oic.simulator.clientcontroller.view.dialogs.ResourceWizardDialog;
  30
  31 import org.eclipse.jface.dialogs.MessageDialog;
  32 import org.eclipse.jface.viewers.ISelectionChangedListener;
  33 import org.eclipse.jface.viewers.IStructuredSelection;
  34 import org.eclipse.jface.viewers.ITreeContentProvider;
  35 import org.eclipse.jface.viewers.LabelProvider;
  36 import org.eclipse.jface.viewers.SelectionChangedEvent;
  37 import org.eclipse.jface.viewers.TreeViewer;
  38 import org.eclipse.jface.viewers.Viewer;
  39 import org.eclipse.jface.window.Window;
  40 import org.eclipse.jface.wizard.WizardDialog;
  41 import org.eclipse.swt.SWT;
  42 import org.eclipse.swt.custom.CTabFolder;
  43 import org.eclipse.swt.custom.CTabItem;
  44 import org.eclipse.swt.events.MenuAdapter;
  45 import org.eclipse.swt.events.MenuEvent;
  46 import org.eclipse.swt.events.SelectionAdapter;
  47 import org.eclipse.swt.events.SelectionEvent;
  48 import org.eclipse.swt.graphics.Color;
  49 import org.eclipse.swt.graphics.Image;
  50 import org.eclipse.swt.layout.GridData;
  51 import org.eclipse.swt.layout.GridLayout;
  52 import org.eclipse.swt.widgets.Button;
  53 import org.eclipse.swt.widgets.Composite;
  54 import org.eclipse.swt.widgets.Display;
  55 import org.eclipse.swt.widgets.Group;
  56 import org.eclipse.swt.widgets.Menu;
  57 import org.eclipse.swt.widgets.MenuItem;
  58 import org.eclipse.swt.widgets.Tree;
  59 import org.eclipse.ui.PlatformUI;
  60 import org.eclipse.ui.dialogs.FilteredTree;
  61 import org.eclipse.ui.dialogs.PatternFilter;
  62 import org.eclipse.ui.part.ViewPart;
  63
  64 /**
  65  * This class manages and shows the resource manager view in the perspective.
  66  */
  67 public class ResourceManagerView extends ViewPart {
  68
  69     public static final String      VIEW_ID = "oic.simulator.clientcontroller.view.resourcemanager";
  70
  71     private Button                  findResButton;
  72     private Button                  refreshButton;
  73
  74     private TreeViewer              treeViewer;
  75     private TreeViewer              favTreeViewer;
  76
  77     private CTabFolder              folder;
  78     private CTabItem                foundResTab;
  79     private CTabItem                favResTab;
  80
  81     private ResourceManager         resourceManager;
  82
  83     private IFindResourceUIListener findListener;
  84
  85     private Boolean                 foundResource;
  86
  87     private MessageDialog           findDialog;
  88
  89     private MessageDialog           refreshDialog;
  90
  91     private Thread                  sleepThreadHandle;
  92
  93     public ResourceManagerView() {
  94         resourceManager = Activator.getDefault().getResourceManager();
  95
  96         findListener = new IFindResourceUIListener() {
  97
  98             @Override
  99             public void onNewResourceFound(final RemoteResource resource) {
 100                 System.out.println("View: onNewResourceFound");
 101                 if (null == resource) {
 102                     return;
 103                 }
 104                 // Changing the status of the find operation.
 105                 setFoundResource(true);
 106
 107                 // Interrupt the sleep thread.
 108                 if (null != sleepThreadHandle && sleepThreadHandle.isAlive()) {
 109                     sleepThreadHandle.interrupt();
 110                 }
 111
 112                 // Update the tree viewer
 113                 Display.getDefault().asyncExec(new Runnable() {
 114                     @Override
 115                     public void run() {
 116                         if (!treeViewer.getControl().isDisposed()) {
 117                             treeViewer.refresh();
 118                         }
 119
 120                         if (!favTreeViewer.getControl().isDisposed()) {
 121                             favTreeViewer.refresh();
 122                         }
 123
 124                         // Close the find dialog
 125                         if (null != findDialog) {
 126                             boolean status = findDialog.close();
 127                             System.out
 128                                     .println("dialog close status: " + status);
 129                         }
 130
 131                         // Close the refresh dialog
 132                         if (null != refreshDialog) {
 133                             boolean status = refreshDialog.close();
 134                             System.out
 135                                     .println("dialog close status: " + status);
 136                         }
 137                     }
 138                 });
 139             }
 140         };
 141     }
 142
 143     @Override
 144     public void createPartControl(Composite parent) {
 145         Composite compContent = new Composite(parent, SWT.NONE);
 146         compContent.setLayout(new GridLayout());
 147         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 148         compContent.setLayoutData(gd);
 149
 150         Composite buttonComp = new Composite(compContent, SWT.NONE);
 151         buttonComp.setLayout(new GridLayout(2, false));
 152
 153         gd = new GridData();
 154         gd.horizontalAlignment = SWT.FILL;
 155         gd.grabExcessHorizontalSpace = true;
 156
 157         buttonComp.setLayoutData(gd);
 158
 159         findResButton = new Button(buttonComp, SWT.PUSH);
 160         findResButton.setText("Find Resources");
 161         findResButton.setToolTipText("Find OIC resources");
 162
 163         gd = new GridData();
 164         gd.widthHint = 130;
 165         findResButton.setLayoutData(gd);
 166
 167         refreshButton = new Button(buttonComp, SWT.PUSH);
 168         refreshButton.setText("Refresh");
 169         refreshButton.setToolTipText("Restart the search once again");
 170
 171         gd = new GridData();
 172         gd.widthHint = 90;
 173         refreshButton.setLayoutData(gd);
 174
 175         // Create a Tab Folder.
 176         folder = new CTabFolder(compContent, SWT.BORDER);
 177         gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 178         folder.setLayoutData(gd);
 179         folder.setSimple(false);
 180         folder.setUnselectedCloseVisible(false);
 181         folder.setUnselectedImageVisible(false);
 182         folder.addSelectionListener(new SelectionAdapter() {
 183             @Override
 184             public void widgetSelected(SelectionEvent e) {
 185                 /*
 186                  * CTabItem selectedTab = folder.getSelection(); if(selectedTab
 187                  * == foundResTab) { System.out.println("Found resources tab");
 188                  * } else { System.out.println("Favorite resources tab"); }
 189                  */
 190                 // Tab is switched.
 191                 treeViewer.setSelection(null);
 192                 favTreeViewer.setSelection(null);
 193                 resourceManager.resourceSelectionChanged(null);
 194             }
 195         });
 196
 197         createFoundResourcesArea();
 198
 199         createFavoriteResourcesArea();
 200
 201         folder.setSelection(foundResTab);
 202
 203         findDialog = new MessageDialog(Display.getDefault().getActiveShell(),
 204                 "Finding Servers", null,
 205                 "Finding the requested servers\nPlease wait...",
 206                 MessageDialog.INFORMATION, new String[] { "Cancel" }, 0);
 207         // findDialog.setBlockOnOpen(false);
 208
 209         refreshDialog = new MessageDialog(
 210                 Display.getDefault().getActiveShell(),
 211                 "Finding Servers",
 212                 null,
 213                 "Refreshing the search and finding the requested servers once again\nPlease wait...",
 214                 MessageDialog.INFORMATION, new String[] { "Cancel" }, 0);
 215         // refreshDialog.setBlockOnOpen(false);
 216
 217         addUIListeners();
 218
 219         addManagerListeners();
 220
 221         // Setting the initial visibility of refresh based on the last known
 222         // search operation.
 223         Set<String> prevSearchTypes = resourceManager.getLastKnownSearchTypes();
 224         if (null == prevSearchTypes || prevSearchTypes.size() < 1) {
 225             refreshButton.setEnabled(false);
 226         } else {
 227             refreshButton.setEnabled(true);
 228         }
 229     }
 230
 231     private void createFoundResourcesArea() {
 232         foundResTab = new CTabItem(folder, SWT.NULL);
 233         foundResTab.setText("Found Resources");
 234
 235         // Create a group to show all the discovered resources.
 236         // Adding the group to the folder.
 237         Group resourceGroup = new Group(folder, SWT.NONE);
 238         // resourceGroup.setText("Discovered Resources");
 239
 240         Color color = Display.getDefault().getSystemColor(SWT.COLOR_WHITE);
 241         resourceGroup.setBackground(color);
 242
 243         resourceGroup.setLayout(new GridLayout(1, false));
 244         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 245         resourceGroup.setLayoutData(gd);
 246
 247         PatternFilter filter = new PatternFilter();
 248         FilteredTree filteredTree = new FilteredTree(resourceGroup,
 249                 SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE, filter, true);
 250         treeViewer = filteredTree.getViewer();
 251         treeViewer.getTree().setLayoutData(
 252                 new GridData(SWT.FILL, SWT.FILL, true, true));
 253         treeViewer.setContentProvider(new TreeContentProvider());
 254         treeViewer.setLabelProvider(new TreeLabelProvider());
 255         treeViewer.setInput(new Object());
 256
 257         addMenuToFoundResources();
 258
 259         foundResTab.setControl(resourceGroup);
 260     }
 261
 262     private void addMenuToFoundResources() {
 263
 264         if (null != treeViewer) {
 265             final Tree resourceTreeHead = treeViewer.getTree();
 266             if (null != resourceTreeHead) {
 267                 // Below code creates menu entries and shows them on right
 268                 // clicking a resource
 269                 final Menu menu = new Menu(resourceTreeHead);
 270                 resourceTreeHead.setMenu(menu);
 271                 menu.addMenuListener(new MenuAdapter() {
 272                     @Override
 273                     public void menuShown(MenuEvent e) {
 274                         // Clear existing menu items
 275                         MenuItem[] items = menu.getItems();
 276                         for (int index = 0; index < items.length; index++) {
 277                             items[index].dispose();
 278                         }
 279                         MenuItem uploadRAMLItem = new MenuItem(menu, SWT.NONE);
 280                         uploadRAMLItem.setText("Upload RAML Configuration");
 281                         uploadRAMLItem
 282                                 .addSelectionListener(new SelectionAdapter() {
 283                                     @Override
 284                                     public void widgetSelected(SelectionEvent e) {
 285                                         // Open the RAML configuration dialog if
 286                                         // RAML file is not yet uploaded for the
 287                                         // currently selected resource
 288                                         RemoteResource resource = resourceManager
 289                                                 .getCurrentResourceInSelection();
 290                                         if (null == resource) {
 291                                             return;
 292                                         }
 293                                         if (!resource.isConfigUploaded()) {
 294                                             // Open the dialog in a separate
 295                                             // UI thread.
 296                                             PlatformUI.getWorkbench()
 297                                                     .getDisplay()
 298                                                     .syncExec(new Thread() {
 299                                                         @Override
 300                                                         public void run() {
 301                                                             LoadRAMLDialog ramlDialog = new LoadRAMLDialog(
 302                                                                     Display.getDefault()
 303                                                                             .getActiveShell());
 304                                                             if (ramlDialog
 305                                                                     .open() != Window.OK) {
 306                                                                 return;
 307                                                             }
 308                                                             String configFilePath = ramlDialog
 309                                                                     .getConfigFilePath();
 310                                                             if (null == configFilePath
 311                                                                     || configFilePath
 312                                                                             .length() < 1) {
 313                                                                 MessageDialog
 314                                                                         .openInformation(
 315                                                                                 Display.getDefault()
 316                                                                                         .getActiveShell(),
 317                                                                                 "Invalid RAML Config path",
 318                                                                                 "Configuration file path is invalid.");
 319                                                                 return;
 320                                                             }
 321                                                             resourceManager
 322                                                                     .setConfigFilePath(
 323                                                                             resourceManager
 324                                                                                     .getCurrentResourceInSelection(),
 325                                                                             configFilePath);
 326                                                         }
 327                                                     });
 328                                         } else {
 329                                             MessageDialog
 330                                                     .openInformation(Display
 331                                                             .getDefault()
 332                                                             .getActiveShell(),
 333                                                             "Already Uploaded",
 334                                                             "Configuration file for the selected resource is already uploaded");
 335                                         }
 336                                     }
 337                                 });
 338
 339                         RemoteResource resource = resourceManager
 340                                 .getCurrentResourceInSelection();
 341                         if (null == resource) {
 342                             return;
 343                         }
 344                         String menuText = !resource.isFavorite() ? "Add to favorites"
 345                                 : "Remove from favorites";
 346                         MenuItem addToFavMenuItem = new MenuItem(menu, SWT.NONE);
 347                         addToFavMenuItem.setText(menuText);
 348                         addToFavMenuItem
 349                                 .addSelectionListener(new SelectionAdapter() {
 350                                     @Override
 351                                     public void widgetSelected(SelectionEvent e) {
 352                                         RemoteResource resource = (RemoteResource) ((IStructuredSelection) treeViewer
 353                                                 .getSelection())
 354                                                 .getFirstElement();
 355                                         if (null == resource) {
 356                                             return;
 357                                         }
 358                                         System.out.println("Selected resource:"
 359                                                 + resource.getResourceURI());
 360                                         if (!resource.isFavorite()) {
 361                                             resourceManager
 362                                                     .addResourcetoFavorites(resource);
 363                                         } else {
 364                                             resourceManager
 365                                                     .removeResourceFromFavorites(resource);
 366                                             resourceManager
 367                                                     .removeResourceURIFromFavorites(resource);
 368                                         }
 369                                         favTreeViewer.refresh();
 370                                     }
 371                                 });
 372                     }
 373                 });
 374             }
 375         }
 376     }
 377
 378     private void createFavoriteResourcesArea() {
 379         favResTab = new CTabItem(folder, SWT.NULL);
 380         favResTab.setText("Favorite Resources");
 381
 382         // Create a group to show all the discovered resources.
 383         // Adding the group to the folder.
 384         Group resourceGroup = new Group(folder, SWT.NONE);
 385         // resourceGroup.setText("Discovered Resources");
 386
 387         Color color = Display.getDefault().getSystemColor(SWT.COLOR_WHITE);
 388         resourceGroup.setBackground(color);
 389
 390         resourceGroup.setLayout(new GridLayout(1, false));
 391         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 392         resourceGroup.setLayoutData(gd);
 393
 394         PatternFilter filter = new PatternFilter();
 395         FilteredTree filteredTree = new FilteredTree(resourceGroup,
 396                 SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE, filter, true);
 397         favTreeViewer = filteredTree.getViewer();
 398         favTreeViewer.getTree().setLayoutData(
 399                 new GridData(SWT.FILL, SWT.FILL, true, true));
 400         favTreeViewer.setContentProvider(new FavTreeContentProvider());
 401         favTreeViewer.setLabelProvider(new TreeLabelProvider());
 402         favTreeViewer.setInput(new Object());
 403
 404         favResTab.setControl(resourceGroup);
 405
 406         addMenuToFavResources();
 407     }
 408
 409     private void addMenuToFavResources() {
 410         if (null != favTreeViewer) {
 411             final Tree resourceTreeHead = favTreeViewer.getTree();
 412             if (null != resourceTreeHead) {
 413                 // Below code creates menu entries and shows them on right
 414                 // clicking a resource
 415                 final Menu menu = new Menu(resourceTreeHead);
 416                 resourceTreeHead.setMenu(menu);
 417                 menu.addMenuListener(new MenuAdapter() {
 418                     @Override
 419                     public void menuShown(MenuEvent e) {
 420                         // Clear existing menu items
 421                         MenuItem[] items = menu.getItems();
 422                         for (int index = 0; index < items.length; index++) {
 423                             items[index].dispose();
 424                         }
 425                         MenuItem addToFavMenuItem = new MenuItem(menu, SWT.NONE);
 426                         addToFavMenuItem.setText("Remove from favorites");
 427                         addToFavMenuItem
 428                                 .addSelectionListener(new SelectionAdapter() {
 429                                     @Override
 430                                     public void widgetSelected(SelectionEvent e) {
 431                                         RemoteResource resource = (RemoteResource) ((IStructuredSelection) favTreeViewer
 432                                                 .getSelection())
 433                                                 .getFirstElement();
 434                                         if (null == resource) {
 435                                             return;
 436                                         }
 437                                         resourceManager
 438                                                 .removeResourceFromFavorites(resource);
 439                                         resourceManager
 440                                                 .removeResourceURIFromFavorites(resource);
 441                                         favTreeViewer.refresh();
 442                                     }
 443                                 });
 444                     }
 445                 });
 446             }
 447         }
 448     }
 449
 450     private void addUIListeners() {
 451         findResButton.addSelectionListener(new SelectionAdapter() {
 452             @Override
 453             public void widgetSelected(SelectionEvent e) {
 454                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 455
 456                     @Override
 457                     public void run() {
 458                         FindResourceWizard findWizard = new FindResourceWizard();
 459                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 460                                 PlatformUI.getWorkbench().getDisplay()
 461                                         .getActiveShell(), findWizard);
 462                         int open = wizardDialog.open();
 463                         if (open == WizardDialog.OK) {
 464                             // Setting initial value on starting the find
 465                             // operation.
 466                             setFoundResource(false);
 467
 468                             Set<String> searchTypes = findWizard
 469                                     .getSearchTypes();
 470                             if (null != searchTypes) {
 471                                 System.out.println(searchTypes);
 472                                 // Call native method to clear existing
 473                                 // resources of
 474                                 // the given search types.
 475                                 resourceManager.deleteResources(searchTypes);
 476
 477                                 // Update the tree
 478                                 treeViewer.refresh();
 479                                 favTreeViewer.refresh();
 480
 481                                 // Call native method to find Resources
 482                                 boolean result = resourceManager
 483                                         .findResourceRequest(searchTypes);
 484                                 if (result) {
 485                                     searchUIOperation(false);
 486                                 } else {
 487                                     MessageDialog
 488                                             .openError(Display.getDefault()
 489                                                     .getActiveShell(),
 490                                                     "Find Resource status",
 491                                                     "Operation failed due to some problems in core layer.");
 492                                 }
 493
 494                                 // Store this information for refresh
 495                                 // functionality
 496                                 resourceManager
 497                                         .setLastKnownSearchTypes(searchTypes);
 498
 499                                 // Change the refresh visibility
 500                                 refreshButton.setEnabled(true);
 501                             }
 502                         }
 503                     }
 504                 });
 505             }
 506         });
 507
 508         refreshButton.addSelectionListener(new SelectionAdapter() {
 509             @Override
 510             public void widgetSelected(SelectionEvent e) {
 511                 Set<String> searchTypes = resourceManager
 512                         .getLastKnownSearchTypes();
 513                 if (null == searchTypes) {
 514                     return;
 515                 }
 516                 setFoundResource(false);
 517
 518                 // Call native method to clear existing resources of the given
 519                 // search types.
 520                 resourceManager.deleteResources(searchTypes);
 521
 522                 // Update the tree
 523                 treeViewer.refresh();
 524                 favTreeViewer.refresh();
 525
 526                 // Call native method to find Resources
 527                 boolean result = resourceManager
 528                         .findResourceRequest(searchTypes);
 529                 if (result) {
 530                     searchUIOperation(true);
 531                 } else {
 532                     MessageDialog
 533                             .openError(Display.getDefault().getActiveShell(),
 534                                     "Find Resource status",
 535                                     "Operation failed due to some problems in core layer.");
 536                 }
 537             }
 538         });
 539
 540         // Below code adds a listener to the tree for selection changes
 541         // and notifies the resource manager
 542         ISelectionChangedListener treeSelectionListener = new ISelectionChangedListener() {
 543
 544             @Override
 545             public void selectionChanged(SelectionChangedEvent e) {
 546                 if (e.getSelection().isEmpty()) {
 547                     return;
 548                 }
 549                 if (e.getSelection() instanceof IStructuredSelection) {
 550                     IStructuredSelection selection = (IStructuredSelection) e
 551                             .getSelection();
 552                     RemoteResource resource = (RemoteResource) selection
 553                             .getFirstElement();
 554                     if (null == resource) {
 555                         return;
 556                     }
 557                     System.out.println("Selected resource: "
 558                             + resource.getResourceURI());
 559                     resourceManager.resourceSelectionChanged(resource);
 560                 }
 561             }
 562         };
 563
 564         treeViewer.addSelectionChangedListener(treeSelectionListener);
 565         favTreeViewer.addSelectionChangedListener(treeSelectionListener);
 566     }
 567
 568     // If refresh is true, then Refresh Dialog else Find Dialog will be shown.
 569     private void searchUIOperation(boolean refresh) {
 570         final MessageDialog targetDialog;
 571         if (refresh) {
 572             targetDialog = refreshDialog;
 573         } else {
 574             targetDialog = findDialog;
 575         }
 576         // Open the dialog in a new thread.
 577         PlatformUI.getWorkbench().getDisplay().syncExec(new Thread() {
 578
 579             @Override
 580             public void run() {
 581                 if (isFoundResource()) {
 582                     setFoundResource(false);
 583                     return;
 584                 }
 585
 586                 PlatformUI.getWorkbench().getDisplay().asyncExec(new Thread() {
 587                     @Override
 588                     public void run() {
 589                         targetDialog.open(); // This method returns once the
 590                         // cancel button is pressed.
 591
 592                         // Interrupt the sleep thread.
 593                         if (null != sleepThreadHandle
 594                                 && sleepThreadHandle.isAlive()) {
 595                             sleepThreadHandle.interrupt();
 596                         }
 597
 598                         // Set the status of find.
 599                         setFoundResource(false);
 600                     }
 601                 });
 602
 603                 // Thread for find time-out.
 604                 sleepThreadHandle = new Thread() {
 605                     Thread child;
 606
 607                     public void run() {
 608                         try {
 609                             Thread.sleep(Constants.FIND_RESOURCES_TIMEOUT * 1000);
 610                         } catch (InterruptedException e) {
 611                             System.out.println("Interrupted during sleep.");
 612                             return;
 613                         }
 614
 615                         child = new Thread() {
 616                             @Override
 617                             public void run() {
 618                                 if (null != targetDialog) {
 619                                     targetDialog.close();
 620
 621                                     // Check if any new resources are
 622                                     // discovered.
 623                                     // Is no new resources, then display a
 624                                     // message box.
 625                                     if (!isFoundResource()) {
 626                                         MessageDialog
 627                                                 .openInformation(
 628                                                         Display.getDefault()
 629                                                                 .getActiveShell(),
 630                                                         "No servers found",
 631                                                         "No servers are available as of now.\n"
 632                                                                 + "Please check the servers' status and press"
 633                                                                 + "'Refresh' button to restart the search.");
 634                                     } else {
 635                                         // Resetting the status to false for
 636                                         // ensuring safety.
 637                                         setFoundResource(false);
 638                                     }
 639                                 }
 640                             }
 641                         };
 642
 643                         PlatformUI.getWorkbench().getDisplay().syncExec(child);
 644                     }
 645                 };
 646                 sleepThreadHandle.start();
 647             }
 648         });
 649     }
 650
 651     private void addManagerListeners() {
 652         resourceManager.addFindresourceUIListener(findListener);
 653     }
 654
 655     @Override
 656     public void dispose() {
 657         // Unregister the listener
 658         if (null != findListener) {
 659             resourceManager.removeFindresourceUIListener(findListener);
 660             resourceManager.resourceSelectionChanged(null);
 661         }
 662         super.dispose();
 663     }
 664
 665     @Override
 666     public void setFocus() {
 667         // TODO Auto-generated method stub
 668
 669     }
 670
 671     public synchronized void setFoundResource(boolean value) {
 672         foundResource = value;
 673     }
 674
 675     public synchronized boolean isFoundResource() {
 676         return foundResource;
 677     }
 678 }
 679
 680 class TreeContentProvider implements ITreeContentProvider {
 681
 682     @Override
 683     public void dispose() {
 684     }
 685
 686     @Override
 687     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 688
 689     }
 690
 691     @Override
 692     public Object[] getChildren(Object parent) {
 693         return null;
 694     }
 695
 696     @Override
 697     public Object[] getElements(Object parent) {
 698         System.out.println("Inside getElements()");
 699         List<RemoteResource> resourceList = Activator.getDefault()
 700                 .getResourceManager().getResourceList();
 701         return resourceList.toArray();
 702     }
 703
 704     @Override
 705     public Object getParent(Object child) {
 706         return null;
 707     }
 708
 709     @Override
 710     public boolean hasChildren(Object parent) {
 711         return false;
 712     }
 713
 714 }
 715
 716 class FavTreeContentProvider implements ITreeContentProvider {
 717
 718     @Override
 719     public void dispose() {
 720     }
 721
 722     @Override
 723     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 724
 725     }
 726
 727     @Override
 728     public Object[] getChildren(Object parent) {
 729         return null;
 730     }
 731
 732     @Override
 733     public Object[] getElements(Object parent) {
 734         System.out.println("Inside getElements()");
 735         List<RemoteResource> resourceList = Activator.getDefault()
 736                 .getResourceManager().getFavResourceList();
 737         return resourceList.toArray();
 738     }
 739
 740     @Override
 741     public Object getParent(Object child) {
 742         return null;
 743     }
 744
 745     @Override
 746     public boolean hasChildren(Object parent) {
 747         return false;
 748     }
 749
 750 }
 751
 752 class TreeLabelProvider extends LabelProvider {
 753     @Override
 754     public String getText(Object element) {
 755         RemoteResource resource = (RemoteResource) element;
 756         return resource.getResourceURI();
 757     }
 758
 759     @Override
 760     public Image getImage(Object element) {
 761         RemoteResource resource = (RemoteResource) element;
 762         ResourceManager resourceManager = Activator.getDefault()
 763                 .getResourceManager();
 764         return resourceManager.getImage(resource.getResourceURI());
 765     }
 766 }