taverna-workbench-perspective-myexperiment/src/main/java/net/sf/taverna/t2/ui/perspectives/myexperiment/ResourcePreviewBrowser.java

package net.sf.taverna.t2.ui.perspectives.myexperiment;

import java.awt.BorderLayout;
import java.awt.Desktop;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.net.URI;
import java.util.ArrayList;
import java.util.EventListener;
import java.util.List;

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;

import net.sf.taverna.t2.ui.perspectives.myexperiment.model.Base64;
import net.sf.taverna.t2.ui.perspectives.myexperiment.model.MyExperimentClient;
import net.sf.taverna.t2.ui.perspectives.myexperiment.model.Resource;
import net.sf.taverna.t2.workbench.file.FileManager;
import net.sf.taverna.t2.workbench.icons.WorkbenchIcons;

import org.apache.log4j.Logger;

/**
 * @author Sergejs Aleksejevs, Emmanuel Tagarira
 */
public class ResourcePreviewBrowser extends JFrame implements ActionListener, HyperlinkListener, ComponentListener {
  // CONSTANTS
  protected static final int PREFERRED_WIDTH = 750;
  protected static final int PREFERRED_HEIGHT = 600;
  protected static final int PREFERRED_SCROLL = 10;
  protected static final int PREVIEW_HISTORY_LENGTH = 50;

  // navigation data
  private int iCurrentHistoryIdx; // index within the current history
  private final ArrayList<String> alCurrentHistory; // current history - e.g. if one
  // opens Page1, then Page2; goes back and opens Page3 - current preview would hold only [Page1, Page3]
  private ArrayList<Resource> alFullHistory; // all resources that were
  // previewed since application started (will be used by ResourcePreviewHistoryBrowser)

  // components for accessing application's main elements
  private final MainComponent pluginMainComponent;
  private final MyExperimentClient myExperimentClient;
  private final Logger logger;

  // holder of the data about currently previewed item
  private ResourcePreviewContent rpcContent;
  private Resource resource;

  // components of the preview window
  private JPanel jpMain;
  private JPanel jpStatusBar;
  private JLabel lSpinnerIcon;
  private JButton bBack;
  private JButton bForward;
  private JButton bRefresh;
  private JButton bOpenInMyExp;
  private JButton bDownload;
  private JButton bOpenInTaverna;
  private JButton bImportIntoTaverna;
  private JButton bAddComment;
  private JButton bAddRemoveFavourite;
  private JButton bUpload;
  private JButton bEditMetadata;
  private JScrollPane spContentScroller;

  // icons
  private final ImageIcon iconOpenInMyExp = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("open_in_my_experiment_icon"));
  private final ImageIcon iconAddFavourite = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("add_favourite_icon"));
  private final ImageIcon iconDeleteFavourite = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("delete_favourite_icon"));
  private final ImageIcon iconAddComment = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("add_comment_icon"));
  private final ImageIcon iconSpinner = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("spinner"));
  private final ImageIcon iconSpinnerStopped = new ImageIcon(MyExperimentPerspective.getLocalResourceURL("spinner_stopped"));
  private final FileManager fileManager;

  public ResourcePreviewBrowser(MainComponent component, MyExperimentClient client, Logger logger, FileManager fileManager) {
	super();

	// set main variables to ensure access to myExperiment, logger and the
	// parent component
	this.pluginMainComponent = component;
	this.myExperimentClient = client;
	this.logger = logger;
	this.fileManager = fileManager;

	// initialise previewed items history
	String strPreviewedItemsHistory = (String) myExperimentClient.getSettings().get(MyExperimentClient.INI_PREVIEWED_ITEMS_HISTORY);
	if (strPreviewedItemsHistory != null) {
	  Object oPreviewedItemsHistory = Base64.decodeToObject(strPreviewedItemsHistory);
	  this.alFullHistory = (ArrayList<Resource>) oPreviewedItemsHistory;
	} else {
	  this.alFullHistory = new ArrayList<Resource>();
	}

	// no navigation history at loading
	this.iCurrentHistoryIdx = -1;
	this.alCurrentHistory = new ArrayList<String>();

	// set options of the preview dialog box
	this.setIconImage(new ImageIcon(MyExperimentPerspective.getLocalResourceURL("myexp_icon")).getImage());
	this.addComponentListener(this);

	this.initialiseUI();
  }

  /**
   * Accessor method for getting a full history of previewed resources as a
   * list.
   */
  public ArrayList<Resource> getPreviewHistory() {
	return (this.alFullHistory);
  }

  /**
   * As opposed to getPreviewHistory() which returns full history of previewed
   * resources, this helper method only retrieves the current history stack.
   *
   * Example: if a user was to view the following items - A -> B -> C B <- C B
   * -> D, the full history would be [A,C,B,D]; current history stack would be
   * [A,B,D] - note how item C was "forgotten" (this works the same way as all
   * web browsers do)
   */
  public List<String> getCurrentPreviewHistory() {
	return (this.alCurrentHistory);
  }

  /**
   * Deletes both 'current history' (the latest preview history stack) and the
   * 'full preview history'. Also, resets the index in the current history, so
   * that the preview browser would not allow using Back-Forward buttons until
   * some new previews are opened.
   */
  public void clearPreviewHistory() {
	this.iCurrentHistoryIdx = -1;
	this.alCurrentHistory.clear();
	this.alFullHistory.clear();
  }

  /**
   * This method is a launcher for the real worker method ('createPreview()')
   * that does all the job.
   *
   * The purpose of having this method is to manage history. This method is to
   * be called every time when a "new" preview is requested. This will add a new
   * link to the CurrentHistory stack.
   *
   * Clicks on "Back" and "Forward" buttons will only need to advance the
   * counter of the current position in the CurrentHistory. Therefore, these
   * will directly call 'createPreview()'.
   */
  public void preview(String action) {
	// *** History Update ***
	// if this is not the "newest" page in current history, remove all newer
	// ones
	// (that is if the user went "back" and opened some new link from on of the
	// older pages)
	while (alCurrentHistory.size() > iCurrentHistoryIdx + 1) {
	  alCurrentHistory.remove(alCurrentHistory.size() - 1);
	}

	boolean bPreviewNotTheSameAsTheLastOne = true;
	if (alCurrentHistory.size() > 0) {
	  // will add new page to the history only if it's not the same as the last
	  // one!
	  if (action.equals(alCurrentHistory.get(alCurrentHistory.size() - 1))) {
		bPreviewNotTheSameAsTheLastOne = false;
	  }

	  // this is not the first page in the history, enable "Back" button (if
	  // only this isn't the same page as was the first one);
	  // (this, however, is the last page in the history now - so disable
	  // "Forward" button)
	  bBack.setEnabled(bPreviewNotTheSameAsTheLastOne
		  || alCurrentHistory.size() > 1);
	  bForward.setEnabled(false);
	} else if (alCurrentHistory.size() == 0) {
	  // this is the first preview after application has loaded or since the
	  // preview history was cleared - disable both Back and Forward buttons
	  bBack.setEnabled(false);
	  bForward.setEnabled(false);
	}

	// add current preview URI to the history
	if (bPreviewNotTheSameAsTheLastOne) {
	  iCurrentHistoryIdx++;
	  alCurrentHistory.add(action);
	}

	// *** Launch Preview ***
	createPreview(action);
  }

  private void createPreview(String action) {
	// JUST FOR TESTING THE CURRENT_HISTORY OPERATION
	// javax.swing.JOptionPane.showMessageDialog(null, "History idx: " +
	// this.iCurrentHistoryIdx + "\n" + alCurrentHistory.toString());

	// show that loading is in progress
	this.setTitle("Loading preview...");
	this.lSpinnerIcon.setIcon(this.iconSpinner);

	// disable all action buttons while loading is in progress
	bOpenInMyExp.setEnabled(false);
	bDownload.setEnabled(false);
	bOpenInTaverna.setEnabled(false);
	bImportIntoTaverna.setEnabled(false);
	bAddRemoveFavourite.setEnabled(false);
	bAddComment.setEnabled(false);
	bUpload.setEnabled(false);
	bEditMetadata.setEnabled(false);

	// Make call to myExperiment API in a different thread
	// (then use SwingUtilities.invokeLater to update the UI when ready).
	final String strAction = action;
	final EventListener self = this;

	new Thread("Load myExperiment resource preview content") {
	  @Override
	  public void run() {
		logger.debug("Starting to fetch the preview content data");

		try {
		  // *** Fetch Data and Create Preview Content ***
		  rpcContent = pluginMainComponent.getPreviewFactory().createPreview(strAction, self);

		  // as all the details about the previewed resource are now known, can
		  // store this into full preview history
		  // (before that make sure that if the this item was viewed before,
		  // it's removed and re-added at the "top" of the list)
		  // (also make sure that the history size doesn't exceed the pre-set
		  // value)
		  alFullHistory.remove(rpcContent.getResource());
		  alFullHistory.add(rpcContent.getResource());
		  if (alFullHistory.size() > PREVIEW_HISTORY_LENGTH)
			alFullHistory.remove(0);
		  pluginMainComponent.getHistoryBrowser().refreshHistoryBox(HistoryBrowserTabContentPanel.PREVIEWED_ITEMS_HISTORY);

		  // *** Update the Preview Dialog Box when everything is ready ***
		  SwingUtilities.invokeLater(new Runnable() {
			public void run() {
			  // 'stop' loading action in the status bar and window title
			  setTitle(Resource.getResourceTypeName(rpcContent.getResourceType())
				  + ": " + rpcContent.getResourceTitle());
			  lSpinnerIcon.setIcon(iconSpinnerStopped);

			  // update the state of action buttons in the button bar
			  updateButtonBarState(rpcContent);

			  // wrap received content into a ScrollPane
			  spContentScroller = new JScrollPane(rpcContent.getContent());
			  spContentScroller.setBorder(BorderFactory.createEmptyBorder());
			  spContentScroller.getVerticalScrollBar().setUnitIncrement(ResourcePreviewBrowser.PREFERRED_SCROLL);

			  // remove everything from the preview and re-add all components
			  // (NB! Removing only CENTER component didn't work properly)
			  jpMain.removeAll();
			  jpMain.add(redrawStatusBar(), BorderLayout.NORTH);
			  jpMain.add(spContentScroller, BorderLayout.CENTER);
			  validate();
			  repaint();
			}
		  });
		} catch (Exception ex) {
		  logger.error("Exception on attempt to login to myExperiment:\n", ex);
		}
	  }
	}.start();

	// show the dialog box
	this.setVisible(true);
  }

  private void initialiseUI() {
	// create the STATUS BAR of the preview window
	createButtonsForStatusBar();

	// put everything together
	jpMain = new JPanel();
	jpMain.setOpaque(true);
	jpMain.setLayout(new BorderLayout());
	jpMain.add(redrawStatusBar(), BorderLayout.NORTH);

	// add all content into the main dialog
	this.getContentPane().add(jpMain);

  }

  private void createButtonsForStatusBar() {
	// navigation buttons => far left of status bar
	bBack = new JButton(new ImageIcon(MyExperimentPerspective.getLocalResourceURL("back_icon")));
	bBack.setToolTipText("Back");
	bBack.addActionListener(this);
	bBack.setEnabled(false);

	bForward = new JButton(new ImageIcon(MyExperimentPerspective.getLocalResourceURL("forward_icon")));
	bForward.setToolTipText("Forward");
	bForward.addActionListener(this);
	bForward.setEnabled(false);

	// refresh buttons => far right of status bar
	bRefresh = new JButton(new ImageIcon(MyExperimentPerspective.getLocalResourceURL("refresh_icon")));
	bRefresh.setToolTipText("Refresh");
	bRefresh.addActionListener(this);

	lSpinnerIcon = new JLabel(this.iconSpinner);

	// ACTION BUTTONS
	// 'open in myExperiment' button is the only one that is always available,
	// still will be set available during loading of the preview for consistency of the UI

	// myExperiment "webby" functions
	bOpenInMyExp = new JButton(iconOpenInMyExp);
	bOpenInMyExp.setEnabled(false);
	bOpenInMyExp.addActionListener(this);

	bAddRemoveFavourite = new JButton(iconAddFavourite);
	bAddRemoveFavourite.setEnabled(false);
	bAddRemoveFavourite.addActionListener(this);

	bAddComment = new JButton(iconAddComment);
	bAddComment.setEnabled(false);
	bAddComment.addActionListener(this);

	bEditMetadata = new JButton("Update", WorkbenchIcons.editIcon);
	bEditMetadata.setEnabled(false);
	bEditMetadata.addActionListener(this);

	bUpload = new JButton("Upload", WorkbenchIcons.upArrowIcon);
	bUpload.setEnabled(false);
	bUpload.addActionListener(this);

	// functions more specific to taverna
	bOpenInTaverna = new JButton(WorkbenchIcons.openIcon);
	bOpenInTaverna.setEnabled(false);
	bOpenInTaverna.addActionListener(this);

	bImportIntoTaverna = new JButton();
	bImportIntoTaverna.setEnabled(false);
	bImportIntoTaverna.addActionListener(this);

	bDownload = new JButton(WorkbenchIcons.saveIcon);
	bDownload.setEnabled(false);
	bDownload.addActionListener(this);
  }

  private JPanel redrawStatusBar() {
	// far left of button bar
	JPanel jpNavigationButtons = new JPanel();
	jpNavigationButtons.add(bBack);
	jpNavigationButtons.add(bForward);

	// far right of button bar
	JPanel jpRefreshButtons = new JPanel();
	jpRefreshButtons.add(bRefresh);
	jpRefreshButtons.add(lSpinnerIcon);

	// myExperiment buttons: second left of the button bar
	JPanel jpMyExperimentButtons = new JPanel();
	jpMyExperimentButtons.add(bOpenInMyExp);
	jpMyExperimentButtons.add(bAddRemoveFavourite);
	jpMyExperimentButtons.add(bAddComment);
	jpMyExperimentButtons.add(bEditMetadata);
	jpMyExperimentButtons.add(bUpload);

	// taverna buttons: second right of the button bar
	JPanel jpTavernaButtons = new JPanel();
	jpTavernaButtons.add(bOpenInTaverna);
	jpTavernaButtons.add(bImportIntoTaverna);
	jpTavernaButtons.add(bDownload);

	// put all action buttons into a button bar
	JPanel jpStatusBar = new JPanel();
	jpStatusBar.setLayout(new GridBagLayout());
	int spaceBetweenSections = 40;

	GridBagConstraints c = new GridBagConstraints();
	c.insets = new Insets(0, spaceBetweenSections, 0, spaceBetweenSections / 2);
	c.anchor = GridBagConstraints.WEST;
	c.fill = GridBagConstraints.HORIZONTAL;
	c.gridx = 0;
	c.gridy = 0;
	jpStatusBar.add(jpNavigationButtons, c);

	c.gridx++;
	c.insets = new Insets(0, spaceBetweenSections / 2, 0, spaceBetweenSections / 2);
	jpStatusBar.add(jpMyExperimentButtons, c);

	c.gridx++;
	jpStatusBar.add(jpTavernaButtons, c);

	c.gridx++;
	c.insets = new Insets(0, spaceBetweenSections / 2, 0, spaceBetweenSections);
	jpStatusBar.add(jpRefreshButtons, c);

	return jpStatusBar;

	//	// put all action buttons into a button bar
	//	JPanel jpActionButtons = new JPanel();
	//	jpActionButtons.setLayout(new GridBagLayout());
	//	GridBagConstraints c = new GridBagConstraints();
	//	double spacing = ResourcePreviewBrowser.PREFERRED_WIDTH * 0.1;
	//	c.insets = new Insets(0, (int) spacing, 0, (int) spacing / 2);
	//	c.gridx = 0;
	//	c.gridy = 0;
	//	jpActionButtons.add(jpMyExperimentButtons, c);
	//
	//	c.gridx++;
	//	c.insets = new Insets(0, (int) spacing / 2, 0, (int) spacing);
	//	jpActionButtons.add(jpTavernaButtons, c);
	//
	//	jpStatusBar = new JPanel();
	//	jpStatusBar.setLayout(new BorderLayout());
	//	jpStatusBar.add(jpNavigationButtons, BorderLayout.WEST);
	//	jpStatusBar.add(jpActionButtons, BorderLayout.CENTER);
	//	jpStatusBar.add(jpRefreshButtons, BorderLayout.EAST);
  }

  private void updateButtonBarState(ResourcePreviewContent content) {
	// get the visible type name of the resource
	Resource r = this.rpcContent.getResource();
	String strResourceType = Resource.getResourceTypeName(r.getItemType()).toLowerCase();

	// "Open in myExperiment" is always available for every item type
	this.bOpenInMyExp.setEnabled(true);
	this.bOpenInMyExp.setToolTipText("Open this " + strResourceType
		+ " in myExperiment");

	// "edit metadata" to myExperiment is only available for logged in
	// users who are the owners of the workflow
	String strTooltip = "It is currently not possible to edit the metadata for this workflow";
	boolean bUpdateMetaAvailable = false;

	if (myExperimentClient.isLoggedIn()
		&& (myExperimentClient.getCurrentUser().equals(r.getUploader()))
		&& (r.getItemTypeName().equals("Workflow"))) {
	  strTooltip = "Update the metadata of this workflow.";
	  bUpdateMetaAvailable = true;
	} else {
	  strTooltip = "Only the owners of workflows can change the metadata of workflows.";
	}
	this.bEditMetadata.setToolTipText(strTooltip);
	this.bEditMetadata.setEnabled(bUpdateMetaAvailable);

	// "upload new version" to myExperiment is only available for logged in
	// users who are the owners of the workflow
	strTooltip = "It is currently not possible to upload a new version of this workflow.";
	boolean bUploadAvailable = false;

	if (myExperimentClient.isLoggedIn()
		&& (myExperimentClient.getCurrentUser().equals(r.getUploader()))
		&& (r.getItemTypeName().equals("Workflow"))) {
	  strTooltip = "Upload a new version of this workflow.";
	  bUploadAvailable = true;
	} else {
	  strTooltip = "Only the owners of workflows can upload new versions of workflows.";
	}
	this.bUpload.setToolTipText(strTooltip);
	this.bUpload.setEnabled(bUploadAvailable);

	// "Download" - only for selected types and based on current user's
	// permissions (these conditions are checked within the action)
	this.bDownload.setAction(pluginMainComponent.new DownloadResourceAction(r, false));

	// "Open in Taverna" - only for Taverna workflows and when download is
	// allowed for current user (these checks are carried out inside the action)
	this.bOpenInTaverna.setAction(pluginMainComponent.new LoadResourceInTavernaAction(r, true));

	// "Import into Taverna" - only for Taverna workflows and when download is
	// allowed for current user (these checks are carried out inside the action)
	// the import button
	this.bImportIntoTaverna.setAction(pluginMainComponent.new ImportIntoTavernaAction(r));

	// "Add to Favourites" - for all types, but only for logged in users
	strTooltip = "It is currently not possible to add " + strResourceType
		+ "s to favourites";
	boolean bFavouritingAvailable = false;
	if (r.isFavouritable()) {
	  if (myExperimentClient.isLoggedIn()) {
		if (r.isFavouritedBy(myExperimentClient.getCurrentUser())) {
		  strTooltip = "Remove this " + strResourceType
			  + " from your favourites";
		  this.bAddRemoveFavourite.setIcon(iconDeleteFavourite);
		} else {
		  strTooltip = "Add this " + strResourceType + " to your favourites";
		  this.bAddRemoveFavourite.setIcon(iconAddFavourite);
		}
		bFavouritingAvailable = true;
	  } else {
		// TODO should be changed to display login box first, then favouriting option
		strTooltip = "Only logged in users can add items to favourites";
	  }
	}
	this.bAddRemoveFavourite.setToolTipText(strTooltip);
	this.bAddRemoveFavourite.setEnabled(bFavouritingAvailable);

	// "Add Comment" - for all types besides users and only for logged in users
	strTooltip = "It is currently not possible to comment on "
		+ strResourceType + "s";
	boolean bCommentingAvailable = false;
	if (r.isCommentableOn()) {
	  if (myExperimentClient.isLoggedIn()) {
		strTooltip = "Add a comment on this " + strResourceType;
		bCommentingAvailable = true;
	  } else {
		// TODO should be changed to display login box first, then commenting option
		strTooltip = "Only logged in users can make comments";
	  }
	}
	this.bAddComment.setToolTipText(strTooltip);
	this.bAddComment.setEnabled(bCommentingAvailable);
  }

  public void hyperlinkUpdate(HyperlinkEvent e) {
	if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
	  String strAction = e.getDescription().toString();

	  if (strAction.startsWith("preview:")) {
		this.preview(strAction);
	  } else {
		try {
		    Desktop.getDesktop().browse(new URI(strAction));
		} catch (Exception ex) {
		  logger.error("Failed while trying to open the URL in a standard browser; URL was: "
			  + strAction + "\nException was: " + ex);
		}
	  }
	}
  }

  public void actionPerformed(ActionEvent e) {
	if (e.getSource().equals(this.bBack)) {
	  // "Back" button clicked

	  // update position in the history
	  iCurrentHistoryIdx--;

	  // enable or disable "back"/"forward" buttons as appropriate
	  bBack.setEnabled(iCurrentHistoryIdx > 0);
	  bForward.setEnabled(iCurrentHistoryIdx < alCurrentHistory.size() - 1);

	  // open requested preview from the history
	  this.createPreview(alCurrentHistory.get(iCurrentHistoryIdx));
	} else if (e.getSource().equals(this.bForward)) {
	  // "Forward" button clicked

	  // update position in the history
	  iCurrentHistoryIdx++;

	  // enable or disable "back"/"forward" buttons as appropriate
	  bBack.setEnabled(iCurrentHistoryIdx > 0);
	  bForward.setEnabled(iCurrentHistoryIdx < alCurrentHistory.size() - 1);

	  // open requested preview from the history
	  this.createPreview(alCurrentHistory.get(iCurrentHistoryIdx));
	} else if (e.getSource().equals(this.bRefresh)) {
	  // "Refresh" button clicked

	  // simply reload the same preview
	  this.createPreview(alCurrentHistory.get(iCurrentHistoryIdx));
	} else if (e.getSource().equals(this.bOpenInMyExp)) {
	  // "Open in myExperiment" button clicked
	  try {
	      Desktop.getDesktop().browse(new URI(this.rpcContent.getResourceURL()));
	  } catch (Exception ex) {
		logger.error("Failed while trying to open the URL in a standard browser; URL was: "
			+ this.rpcContent.getResourceURL() + "\nException was: " + ex);
	  }
	} else if (e.getSource().equals(this.bUpload)) {
	  /* ************************************************************************* */
	  Resource resource = this.rpcContent.getResource();
	  if (resource.getItemTypeName().equals("Workflow")) {
		UploadWorkflowDialog uploadWorkflowDialog = new UploadWorkflowDialog(this, true, resource, fileManager);

		if (uploadWorkflowDialog.launchUploadDialogAndPostIfRequired()) {
		  // "true" has been returned so update the resource
		  this.actionPerformed(new ActionEvent(this.bRefresh, 0, ""));
		}
	  }
	} else if (e.getSource().equals(this.bEditMetadata)) {
	  Resource resource = this.rpcContent.getResource();
	  if (resource.getItemTypeName().equals("Workflow")) {
		UploadWorkflowDialog uploadWorkflowDialog = new UploadWorkflowDialog(this, false, resource, fileManager);

		if (uploadWorkflowDialog.launchUploadDialogAndPostIfRequired()) {
		  // "true" has been returned so update the resource
		  this.actionPerformed(new ActionEvent(this.bRefresh, 0, ""));
		}
	  }
	  /* ************************************************************************* */
	} else if (e.getSource().equals(this.bAddComment)) {
	  // "Add Comment" button was clicked
	  String strComment = null;
	  AddCommentDialog commentDialog = new AddCommentDialog(this, this.rpcContent.getResource(), pluginMainComponent, myExperimentClient, logger);
	  if ((strComment = commentDialog.launchAddCommentDialogAndPostCommentIfRequired()) != null) {
		// comment was added because return value is not null;
		// a good option now would be to reload only the comments tab, but
		// for now we refresh the whole of the preview
		this.actionPerformed(new ActionEvent(this.bRefresh, 0, ""));

		// update history of the items that were commented on, making sure that:
		// - there's only one occurrence of this item in the history;
		// - if this item was in the history before, it is moved to the 'top' now;
		// - predefined history size is not exceeded
		this.pluginMainComponent.getHistoryBrowser().getCommentedOnItemsHistoryList().remove(this.rpcContent.getResource());
		this.pluginMainComponent.getHistoryBrowser().getCommentedOnItemsHistoryList().add(this.rpcContent.getResource());
		if (this.pluginMainComponent.getHistoryBrowser().getCommentedOnItemsHistoryList().size() > HistoryBrowserTabContentPanel.COMMENTED_ON_ITEMS_HISTORY) {
		  this.pluginMainComponent.getHistoryBrowser().getCommentedOnItemsHistoryList().remove(0);
		}

		// now update the history of the items that were commented on in 'History' tab
		if (this.pluginMainComponent.getHistoryBrowser() != null) {
		  this.pluginMainComponent.getHistoryBrowser().refreshHistoryBox(HistoryBrowserTabContentPanel.COMMENTED_ON_ITEMS_HISTORY);
		}
	  }
	} else if (e.getSource().equals(this.bAddRemoveFavourite)) {
	  boolean bItemIsFavourited = this.rpcContent.getResource().isFavouritedBy(this.myExperimentClient.getCurrentUser());

	  AddRemoveFavouriteDialog favouriteDialog = new AddRemoveFavouriteDialog(this, !bItemIsFavourited, this.rpcContent.getResource(), pluginMainComponent, myExperimentClient, logger);
	  int iFavouritingStatus = favouriteDialog.launchAddRemoveFavouriteDialogAndPerformNecessaryActionIfRequired();

	  // if the operation wasn't cancelled, update status of the
	  // "add/remove favourite" button and the list of favourites in the user profile
	  if (iFavouritingStatus != AddRemoveFavouriteDialog.OPERATION_CANCELLED) {
		this.updateButtonBarState(this.rpcContent);
		this.pluginMainComponent.getMyStuffTab().getSidebar().repopulateFavouritesBox();
		this.pluginMainComponent.getMyStuffTab().getSidebar().revalidate();
	  }
	} else if (e.getSource() instanceof JClickableLabel) {
	  // clicked somewhere on a JClickableLabel; if that's a 'preview' request - launch preview
	  if (e.getActionCommand().startsWith("preview:")) {
		this.preview(e.getActionCommand());
	  } else if (e.getActionCommand().startsWith("tag:")) {
		// pass this event onto the Tag Browser tab
		this.pluginMainComponent.getTagBrowserTab().actionPerformed(e);
		this.pluginMainComponent.getMainTabs().setSelectedComponent(this.pluginMainComponent.getTagBrowserTab());
	  } else {
		// show the link otherwise
		try {
		    Desktop.getDesktop().browse(new URI(e.getActionCommand()));
		} catch (Exception ex) {
		  logger.error("Failed while trying to open the URL in a standard browser; URL was: "
			  + e.getActionCommand() + "\nException was: " + ex);
		}
	  }
	} else if (e.getSource() instanceof TagCloudPanel
		&& e.getActionCommand().startsWith("tag:")) {
	  // close the window and pass this event onto the Tag Browser tab
	  this.setVisible(false);
	  this.pluginMainComponent.getTagBrowserTab().actionPerformed(e);
	  this.pluginMainComponent.getMainTabs().setSelectedComponent(this.pluginMainComponent.getTagBrowserTab());
	}
  }

  // *** Callbacks for ComponentListener interface ***

  public void componentShown(ComponentEvent e) {
	// every time the preview browser window is shown, it will start loading a preview
	// - this state is set in the preview() method; (so this won't have to be done here)

	// remove everything from the preview and re-add only the status bar
	// (this is done so that newly opened preview window won't show the old
	// preview)
	jpMain.removeAll();
	jpMain.add(redrawStatusBar(), BorderLayout.NORTH);
	repaint();

	// set the size of the dialog box (NB! Size needs to be set before the position!)
	this.setSize(ResourcePreviewBrowser.PREFERRED_WIDTH, ResourcePreviewBrowser.PREFERRED_HEIGHT);
	this.setMinimumSize(new Dimension(ResourcePreviewBrowser.PREFERRED_WIDTH, ResourcePreviewBrowser.PREFERRED_HEIGHT));

	// make sure that the dialog box appears centered horizontally relatively to
	// the main component; also, pad by 30px vertically from the top of the main component
	int iMainComponentCenterX = (int) Math.round(this.pluginMainComponent.getLocationOnScreen().getX()
		+ (this.pluginMainComponent.getWidth() / 2));
	int iPosX = iMainComponentCenterX - (this.getWidth() / 2);
	int iPosY = ((int) this.pluginMainComponent.getLocationOnScreen().getY()) + 30;
	this.setLocation(iPosX, iPosY);

	myExperimentClient.storeHistoryAndSettings();
  }

  public void componentHidden(ComponentEvent e) {
	myExperimentClient.storeHistoryAndSettings();
  }

  public void componentResized(ComponentEvent e) {
	// do nothing
  }

  public void componentMoved(ComponentEvent e) {
	// do nothing
  }

  public Resource getResource() {
	return resource;
  }

}