import org.eclipse.rse.core.model.ISystemViewInputProvider;

/********************************************************************************

 * Copyright (c) 2004, 2007 IBM Corporation and others. All rights reserved.

 * This program and the accompanying materials are made available under the terms

 * of the Eclipse Public License v1.0 which accompanies this distribution, and is 

 * available at http://www.eclipse.org/legal/epl-v10.html

 * 

 * Initial Contributors:

 * The following IBM employees contributed to the Remote System Explorer

 * component that contains this file: David McKnight, Kushal Munir, 

 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 

 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.

 * 

 * Contributors:

 * Martin Oberhuber (Wind River) - [184095] Replace systemTypeName by IRSESystemType

 * Martin Oberhuber (Wind River) - [186773] split ISystemRegistryUI from ISystemRegistry

 * Martin Oberhuber (Wind River) - [202866] Fix exceptions in RSE browse dialog when SystemRegistry is not yet fully initialized

 ********************************************************************************/

package org.eclipse.rse.internal.ui.view;

import org.eclipse.rse.core.IRSESystemType;

import org.eclipse.rse.core.RSECorePlugin;

import org.eclipse.rse.core.model.IHost;

import org.eclipse.rse.core.model.ISystemRegistry;

import org.eclipse.rse.core.subsystems.ISubSystem;

public abstract class SystemResourceSelectionInputProvider extends SystemAbstractAPIProvider

{		

	private IHost _connection = null;

	private boolean _onlyConnection = false;

	private boolean _allowNew = true;

	private IRSESystemType[] _systemTypes;

	private String _category = null;

	public SystemResourceSelectionInputProvider(IHost connection)

	{

		_connection = connection;

	}

	public SystemResourceSelectionInputProvider()

	{

		// choose random host

		ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();

		IHost[] hosts = registry.getHosts();

		if (hosts != null && hosts.length>0) {

			_connection = hosts[0];

		}

	}

	public IHost getSystemConnection()

	{

		return _connection;

	}

	public boolean allowMultipleConnections()

	{

		return !_onlyConnection;

	}

	public void setAllowNewConnection(boolean flag)

	{

		_allowNew = flag;

	}

	public boolean allowNewConnection()

	{

		return _allowNew;

	}

	public void setSystemConnection(IHost connection, boolean onlyConnection)

	{

		_connection = connection;

		_onlyConnection = onlyConnection;

	}

	public IRSESystemType[] getSystemTypes()

	{

		return _systemTypes;

	}

	public void setSystemTypes(IRSESystemType[] types)

	{

		_systemTypes = types;

	}

	public Object[] getSystemViewRoots()

	{

		if (_connection == null)

		{

			ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();

			IHost[] hosts = registry.getHosts();

			if (hosts!=null && hosts.length!=0) {

				_connection = registry.getHosts()[0];

			}

		}

		return getConnectionChildren(_connection);

	}

	public boolean hasSystemViewRoots()

	{

		return false;

	}

	public Object[] getConnectionChildren(IHost selectedConnection)

	{

		if (selectedConnection != null)

		{

			ISubSystem ss = getSubSystem(selectedConnection);

			if (ss!=null) {

				return ss.getChildren();

			}

		}

		return new Object[0];

	}

	public boolean hasConnectionChildren(IHost selectedConnection)

	{

		if (selectedConnection != null)

		{

			ISubSystem ss = getSubSystem(selectedConnection);

			if (ss!=null) {

				return ss.hasChildren();

			}

		}

		return false;

	}

	protected abstract ISubSystem getSubSystem(IHost selectedConnection);

	public void setCategory(String category)

	{

		_category = category;

	}

	public String getCategory()

	{

		return _category;

	}

}

/********************************************************************************

 * Copyright (c) 2006, 2007 IBM Corporation and others. All rights reserved.

 * This program and the accompanying materials are made available under the terms

 * of the Eclipse Public License v1.0 which accompanies this distribution, and is 

 * available at http://www.eclipse.org/legal/epl-v10.html

 * 

 * Initial Contributors:

 * The following IBM employees contributed to the Remote System Explorer

 * component that contains this file: David McKnight, Kushal Munir, 

 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 

 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.

 * 

 * Contributors:

 * Kevin Doyle (IBM) - Added getSystemViewForm()

 * Martin Oberhuber (Wind River) - [184095] Replace systemTypeName by IRSESystemType

 * Martin Oberhuber (Wind River) - [186773] split ISystemRegistryUI from ISystemRegistry

 * Martin Oberhuber (Wind River) - [190442] made SystemActionViewerFilter API

 * Martin Oberhuber (Wind River) - [202866] Fix exceptions in RSE browse dialog when SystemRegistry is not yet fully initialized

 ********************************************************************************/

package org.eclipse.rse.internal.ui.view;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.rse.core.IRSESystemType;

import org.eclipse.rse.core.RSECorePlugin;

import org.eclipse.rse.core.filters.ISystemFilterReference;

import org.eclipse.rse.core.model.IHost;

import org.eclipse.rse.core.model.ISystemRegistry;

import org.eclipse.rse.core.subsystems.ISubSystem;

import org.eclipse.rse.services.clientserver.messages.SystemMessage;

import org.eclipse.rse.ui.SystemActionViewerFilter;

import org.eclipse.rse.ui.SystemWidgetHelpers;

import org.eclipse.rse.ui.dialogs.SystemPromptDialog;

import org.eclipse.rse.ui.messages.ISystemMessageLine;

import org.eclipse.rse.ui.validators.IValidatorRemoteSelection;

import org.eclipse.rse.ui.view.ISystemRemoteElementAdapter;

import org.eclipse.rse.ui.view.ISystemViewElementAdapter;

import org.eclipse.rse.ui.view.SystemAdapterHelpers;

import org.eclipse.rse.ui.widgets.SystemHostCombo;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Text;

public class SystemResourceSelectionForm implements ISelectionChangedListener

{	

	private Shell _shell;

	private boolean _multipleSelection = true;

	protected static final int PROMPT_WIDTH = 400; // The maximum width of the dialog's prompt, in pixels.

	private SystemResourceSelectionInputProvider _inputProvider;

	private SystemHostCombo _connectionCombo;

	private SystemViewForm _systemViewForm;

	private Composite _propertySheetContainer;

    protected SystemPropertySheetForm _ps;

	private Text _pathText;

	private boolean _isValid;

	private ISystemMessageLine _msgLine;

	protected Object previousSelection = null;

	private IValidatorRemoteSelection _selectionValidator = null;

	private boolean  showPropertySheet = false;

	protected Object  caller;

	protected boolean callerInstanceOfWizardPage, callerInstanceOfSystemPromptDialog;	

	protected String    _verbiage = null;

	protected Label     verbiageLabel;

	private Composite _container;

	// history

	private HashMap _history;

	// outputs 

	protected IHost outputConnection = null;

	protected Object[] outputObjects = null;	

	public SystemResourceSelectionForm(Shell shell, Composite parent, Object caller,

			SystemResourceSelectionInputProvider inputProvider, String verbiage,

			boolean multipleSelection, 

			ISystemMessageLine msgLine)

	{

		_msgLine= msgLine;

		_history = new HashMap();

		_inputProvider = inputProvider;

		_multipleSelection = multipleSelection;

		_shell = shell;

		_verbiage = verbiage;

		this.caller = caller;

		callerInstanceOfWizardPage = (caller instanceof WizardPage);

		callerInstanceOfSystemPromptDialog = (caller instanceof SystemPromptDialog);

		createControls(parent);

	}	

	public void setMessageLine(ISystemMessageLine msgLine)

	{

		_msgLine = msgLine;

	}

	   /**

     * Return first selected object

     */	

    public Object getSelectedObject()

    {

    	if ((outputObjects != null) && (outputObjects.length>=1))

    	  return outputObjects[0];

    	else

    	  return null;

    }

    /**

     * Return all selected objects. 

     */	

    public Object[] getSelectedObjects()

    {

    	return outputObjects;

    }

    /**

     * Return the embedded System Tree object.

     * Will be null until createControls is called.

     */

    public SystemViewForm getSystemViewForm()

    {

    	return _systemViewForm;

    }

	public void createControls(Composite parent)

	{

    	_container = SystemWidgetHelpers.createComposite(parent, showPropertySheet ? 2 : 1);  

		//Composite container = new Composite(parent, SWT.NULL);

		// INNER COMPOSITE

		int gridColumns = 2;

		Composite composite_prompts = SystemWidgetHelpers.createFlushComposite(_container, gridColumns);	

        // PROPERTY SHEET COMPOSITE

		if (showPropertySheet)

		{

			createPropertySheet(_container, _shell);

		}

        // MESSAGE/VERBIAGE TEXT AT TOP

        verbiageLabel = SystemWidgetHelpers.createVerbiage(composite_prompts, _verbiage, gridColumns, false, PROMPT_WIDTH);

		boolean allowMultipleConnnections = _inputProvider.allowMultipleConnections();

		if (!allowMultipleConnnections)

		{

			//Label connectionLabel = SystemWidgetHelpers.createLabel(composite_prompts, _inputProvider.getSystemConnection().getHostName());

		}

		else

		{

			IRSESystemType[] systemTypes = _inputProvider.getSystemTypes();

			String category = _inputProvider.getCategory();

			if (systemTypes != null)

			{

				_connectionCombo = new SystemHostCombo(composite_prompts, SWT.NULL, systemTypes, _inputProvider.getSystemConnection(), _inputProvider.allowNewConnection());	

			}

			else if (category != null)

			{

				_connectionCombo = new SystemHostCombo(composite_prompts, SWT.NULL, _inputProvider.getSystemConnection(), _inputProvider.allowNewConnection(), category);	

			}

			else

			{

				_connectionCombo = new SystemHostCombo(composite_prompts, SWT.NULL, 

						SystemWidgetHelpers.getValidSystemTypes(null),

						_inputProvider.getSystemConnection(),

						_inputProvider.allowNewConnection());	

			}

			_connectionCombo.addSelectionListener(new SelectionAdapter() 

					{

				   public void widgetSelected(SelectionEvent evt) 

				   {

					   IHost connection = _connectionCombo.getHost();

					   connectionChanged(connection);

				   }}

					);	

			_connectionCombo.listenToConnectionEvents(true);

		}

		_pathText = SystemWidgetHelpers.createReadonlyTextField(composite_prompts);

		_systemViewForm = new SystemViewForm(_shell, composite_prompts, SWT.NULL, _inputProvider, !_multipleSelection, _msgLine);

		_systemViewForm.addSelectionChangedListener(this);		

		GridLayout layout = new GridLayout();

		GridData gdata = new GridData(GridData.FILL_BOTH);

		composite_prompts.setLayout(layout);

		composite_prompts.setLayoutData(gdata);

		doInitializeFields();

	}

	private void doInitializeFields()

	{

		  setPageComplete();

		  return; 

	}

	/**

	 * Create the property sheet viewer

	 */

	private void createPropertySheet(Composite outerParent, Shell shell)

	{

		_propertySheetContainer = SystemWidgetHelpers.createFlushComposite(outerParent, 1);	

		((GridData)_propertySheetContainer.getLayoutData()).grabExcessVerticalSpace = true;

		((GridData)_propertySheetContainer.getLayoutData()).verticalAlignment = GridData.FILL;

        // PROPERTY SHEET VIEWER

        _ps = new SystemPropertySheetForm(shell,_propertySheetContainer, SWT.BORDER, _msgLine);			

	}

	public Control getInitialFocusControl()

	{

		return _systemViewForm.getTreeControl();

	}

	public void applyViewerFilter(SystemActionViewerFilter filter)

	{

		if (filter != null)

		{

			_systemViewForm.getSystemView().addFilter(filter);

		}

	}

	/**

	 * Completes processing of the wizard page or dialog. If this 

	 * method returns true, the wizard/dialog will close; 

	 * otherwise, it will stay active.

	 *

	 * @return true if no errors

	 */

	public boolean verify() 

	{

		if (_isValid)

		{

			if (_msgLine != null)

			{

				_msgLine.clearErrorMessage();    		

			}

			return true;

		}

		else

		{

			return false;

		}

	}

	protected ISystemViewElementAdapter getViewAdapter(Object selection)

	{

		if (selection != null && selection instanceof IAdaptable)

		{

			return (ISystemViewElementAdapter)((IAdaptable)selection).getAdapter(ISystemViewElementAdapter.class);

		}

		return null;

	}

	protected ISystemRemoteElementAdapter getRemoteAdapter(Object selection)

	{

		if (selection != null && selection instanceof IAdaptable)

		{

			return SystemAdapterHelpers.getRemoteAdapter(selection);

		}

		return null;

	}

	protected ISystemRemoteElementAdapter[] getRemoteAdapters(ISelection selection)

	{

		Object[] selectedObjects = getSelections(selection);

		ISystemRemoteElementAdapter[] adapters = new ISystemRemoteElementAdapter[selectedObjects.length];

		for (int idx=0; idx<adapters.length; idx++)

		{

			adapters[idx] = getRemoteAdapter(selectedObjects[idx]);

		}

		return adapters;

	}

	public void connectionChanged(IHost connection)

	{

		IHost previousConnection = _inputProvider.getSystemConnection();

		 if (previousConnection != connection)

		   {				 	

			   _inputProvider.setSystemConnection(connection, false);

			   _systemViewForm.refresh();

			   Object oldSelection = _history.get(connection);	

			   if (oldSelection != null)

			   {

				   setPreSelection(oldSelection);

			   }

		   }

	}

	public void setVerbiage(String verbiage)

	{

		_verbiage = verbiage;

	}

	public boolean setPreSelection(Object selection)

	{

		ISystemViewElementAdapter adapter = getViewAdapter(selection);

		if (adapter != null)

		{

			Object parent = adapter.getParent(selection);

			ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();

			ISubSystem ss = adapter.getSubSystem(selection);

			IHost connection = ss.getHost();

			if (_inputProvider.allowMultipleConnections())

			{

				if (_connectionCombo.getHost()!= connection)

		 		{

		 			_connectionCombo.select(connection);

		 		}

			}

			List filterRefs = registry.findFilterReferencesFor(selection, ss, false);

			SystemView systemView = _systemViewForm.getSystemView();

			if (filterRefs.size() > 0)

			{

				ISystemFilterReference ref = (ISystemFilterReference)filterRefs.get(0);

				systemView.expandTo(ref, selection);

				return true;

			}

			else

			{

				if (setPreSelection(parent))

				{

					systemView.expandTo(parent, selection);

					return true;

				}				

			}

		}

		return false;

	}

    protected void setPathText(String text)

    {

    	_pathText.setText(text);

    }

    public Object[] getOutputObjects()

    {

    	return outputObjects;

    }

    /**

     * Return selected connection

     */	

    public IHost getSelectedConnection()

    {

    	return outputConnection;

    }

    /**

	 * Return first item currently selected.

	 */

	protected Object getFirstSelection(ISelection selection)

	{

		IStructuredSelection sSelection = (IStructuredSelection)selection;

		if (sSelection != null)

		{

	      Iterator selectionIterator = sSelection.iterator();

	      if (selectionIterator.hasNext())

	        return selectionIterator.next();

	      else

	        return null;

		}		

		return null;

	}	

	/**

	 * Return all items currently selected.

	 */

	protected Object[] getSelections(ISelection selection)

	{

		IStructuredSelection sSelection = (IStructuredSelection)selection;

		if (sSelection != null)

		{

		  Object[] selectedObjects = new Object[sSelection.size()]; 

	      Iterator selectionIterator = sSelection.iterator();

	      int idx = 0;

	      while (selectionIterator.hasNext())

	      	selectedObjects[idx++] = selectionIterator.next();

	      return selectedObjects;

		}		

		return null;

	}	

	private void setPathTextFromSelection(Object selection)

	{

		ISystemViewElementAdapter adapter = getViewAdapter(selection);

		String text = adapter.getAbsoluteName(selection);

		setPathText(text);

	}

	/**

	 * Show or hide the property sheet. This is called after the contents are created when the user

	 *  toggles the Details button.

	 * @param shell Use getShell() in your dialog or wizard page

	 * @param contents Use getContents() in your dialog or wizard page

	 * @return new state -> true if showing, false if hiding

	 */

	public boolean toggleShowPropertySheet(Shell shell, Control contents) 

	{

	    Point windowSize = shell.getSize();

	    Point oldSize = contents.computeSize(SWT.DEFAULT, SWT.DEFAULT);

		if (showPropertySheet) // hiding?

		{

          _ps.dispose();

          _propertySheetContainer.dispose();

         _ps = null;

         _propertySheetContainer = null;

          ((GridLayout)_container.getLayout()).numColumns = 1;

		}

		else // showing?

		{

		  //createPropertySheet((Composite)contents, shell);

          ((GridLayout)_container.getLayout()).numColumns = 2;

		  createPropertySheet(_container, shell);

		}

	    Point newSize = contents.computeSize(SWT.DEFAULT, SWT.DEFAULT);

	    shell.setSize(new Point(windowSize.x + (newSize.x - oldSize.x), windowSize.y));

		if (_ps != null)

		{

		  ISelection s = _systemViewForm.getSelection();

		  if (s != null)

		    _ps.selectionChanged(s);		  

		}

		showPropertySheet = !showPropertySheet;

		return showPropertySheet;

	}

//  ---------------------------------------------------

	// METHODS FOR SELECTION CHANGED LISTENER INTERFACE... 

	// ---------------------------------------------------

	/**

	 * User selected something in the _systemViewForm.

	 */

	public void selectionChanged(SelectionChangedEvent e)

	{

		_isValid = true;

		ISelection selection = e.getSelection();

		outputObjects = null;

		int selectionSize = ((IStructuredSelection)selection).size();

		if ((selectionSize > 1) && !_systemViewForm.sameParent())

		{

			clearErrorMessage();

			setPathText(""); //$NON-NLS-1$

			setPageComplete();

		    return; // don't enable OK/Add if selections from different parents

		}

		if (_ps != null)

			  _ps.selectionChanged(selection);

		Object selectedObject = getFirstSelection(selection);

		if (selectedObject == previousSelection && selectionSize == 1)

		{

			// DKM we null set this before, so we need to reset it

			outputObjects = getSelections(selection);

			return;	

		}

		clearErrorMessage();

		setPathText(""); //$NON-NLS-1$

		setPageComplete();

		previousSelection = selectedObject;  

		if (selectedObject != null)

		{

		  ISystemRemoteElementAdapter remoteAdapter = getRemoteAdapter(selectedObject);

		  if (remoteAdapter != null)

		  {

			setPathTextFromSelection(selectedObject);

			outputObjects = getSelections(selection);			

			outputConnection = remoteAdapter.getSubSystem(selectedObject).getHost();

		 	_history.put(outputConnection, previousSelection);

		  }

		  else

		  {

			  ISystemViewElementAdapter elementAdapter = (ISystemViewElementAdapter)((IAdaptable)selectedObject).getAdapter(ISystemViewElementAdapter.class);

			  if (elementAdapter != null)

			  {

					setPathTextFromSelection(selectedObject);

					outputObjects = getSelections(selection);			

					outputConnection = elementAdapter.getSubSystem(selectedObject).getHost();

				 	_history.put(outputConnection, previousSelection);

			  }

		  }

		  if (_selectionValidator != null) 

		  {

			  SystemMessage selectionMsg  = _selectionValidator.isValid(outputConnection, getSelections(selection), getRemoteAdapters(selection));

		  	  if (selectionMsg != null)

		  	  {

		  	  	_isValid = false;

		  	    setErrorMessage(selectionMsg);

		  	  }

		  }

		  setPageComplete();

		}

	}

	/**

	 * This method can be called by the dialog or wizard page host, to decide whether to enable

	 * or disable the next, final or ok buttons. It returns true if the minimal information is

	 * available and is correct.

	 */

	public boolean isPageComplete()

	{

		return ( (_pathText.getText().length() > 0) ) && _isValid;

	}

	/**

	 * Inform caller of page-complete status of this form

	 */

	public void setPageComplete()

	{

		if (callerInstanceOfWizardPage)

		{

		  ((WizardPage)caller).setPageComplete(isPageComplete());

		}

		else if (callerInstanceOfSystemPromptDialog)

		{

		  ((SystemPromptDialog)caller).setPageComplete(isPageComplete());

		}		

	}

    /**

     * Show the property sheet on the right hand side, to show the properties of the

     * selected object.

     * <p>

     * Default is false

     */

    public void setShowPropertySheet(boolean show)

    {

    	this.showPropertySheet = show;

    }

    /**

     * Specify a validator to use when the user selects a remote file or folder.

     * This allows you to decide if OK should be enabled or not for that remote file or folder.

     */

    public void setSelectionValidator(IValidatorRemoteSelection selectionValidator)

    {

    	_selectionValidator = selectionValidator;

    }

    protected void clearErrorMessage()

    {

    	if (_msgLine != null)

    	  _msgLine.clearErrorMessage();

    }

    protected void setErrorMessage(String msg)

    {

    	if (_msgLine != null)

    	  if (msg != null)

    	    _msgLine.setErrorMessage(msg);

    	  else

    	    _msgLine.clearErrorMessage();

    }

    protected void setErrorMessage(SystemMessage msg)

    {

    	if (_msgLine != null)

    	  if (msg != null)

    	    _msgLine.setErrorMessage(msg);

    	  else

    	    _msgLine.clearErrorMessage();

    }

    /**

     * Set the message shown as the text at the top of the form. Eg, "Select a file"

     */

    public void setMessage(String message)

    {

    	this._verbiage = message;

    	if (verbiageLabel != null)

    	  verbiageLabel.setText(message);

    }

    /**

     * Set the tooltip text for the remote systems tree from which an item is selected.

     */

    public void setSelectionTreeToolTipText(String tip)

    {

    	_systemViewForm.setToolTipText(tip);

    }

}

/********************************************************************************

 * Copyright (c) 2006, 2007 IBM Corporation and others. All rights reserved.

 * This program and the accompanying materials are made available under the terms

 * of the Eclipse Public License v1.0 which accompanies this distribution, and is 

 * available at http://www.eclipse.org/legal/epl-v10.html

 * 

 * Initial Contributors:

 * The following IBM employees contributed to the Remote System Explorer

 * component that contains this file: David McKnight, Kushal Munir, 

 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 

 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.

 * 

 * Contributors:

 * Martin Oberhuber (Wind River) - [168975] Move RSE Events API to Core

 * Martin Oberhuber (Wind River) - [190271] Move ISystemViewInputProvider to Core

 * Xuan Chen        (IBM)        - [222263] Need to provide a PropertySet Adapter for System Team View

 ********************************************************************************/

package org.eclipse.rse.internal.ui.view;

import org.eclipse.core.runtime.IAdapterFactory;

import org.eclipse.core.runtime.IAdapterManager;

import org.eclipse.rse.core.filters.ISystemFilter;

import org.eclipse.rse.core.filters.ISystemFilterPool;

import org.eclipse.rse.core.filters.ISystemFilterPoolReference;

import org.eclipse.rse.core.filters.ISystemFilterReference;

import org.eclipse.rse.core.filters.ISystemFilterString;

import org.eclipse.rse.core.model.IHost;

import org.eclipse.rse.core.model.ISystemMessageObject;

import org.eclipse.rse.core.model.ISystemProfile;

import org.eclipse.rse.core.model.ISystemViewInputProvider;

import org.eclipse.rse.core.subsystems.ISubSystem;

import org.eclipse.rse.core.subsystems.ISystemDragDropAdapter;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewCategoryAdapter;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewCategoryNode;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewProfileAdapter;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewPropertySetAdapter;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewPropertySetNode;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewSubSystemConfigurationAdapter;

import org.eclipse.rse.internal.ui.view.team.SystemTeamViewSubSystemConfigurationNode;

import org.eclipse.rse.ui.SystemBasePlugin;

import org.eclipse.rse.ui.internal.model.SystemNewConnectionPromptObject;

import org.eclipse.rse.ui.model.ISystemPromptableObject;

import org.eclipse.rse.ui.view.ISystemViewElementAdapter;

import org.eclipse.ui.IActionFilter;

import org.eclipse.ui.model.IWorkbenchAdapter;

import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;

import org.eclipse.ui.views.properties.IPropertySource;

/**

 * This factory maps requests for an adapter object from a given

 *  element object.

 */

public class SystemViewAdapterFactory implements IAdapterFactory {

	private SystemViewRootInputAdapter rootAdapter = new SystemViewRootInputAdapter();

	private SystemViewConnectionAdapter connectionAdapter = new SystemViewConnectionAdapter();

	private SystemViewSubSystemAdapter subsystemAdapter = new SystemViewSubSystemAdapter();

	private SystemViewFilterPoolAdapter filterPoolAdapter = new SystemViewFilterPoolAdapter();

	private SystemViewFilterAdapter filterAdapter = new SystemViewFilterAdapter();

	private SystemViewFilterPoolReferenceAdapter filterPoolReferenceAdapter = new SystemViewFilterPoolReferenceAdapter();

	private SystemViewFilterReferenceAdapter filterReferenceAdapter = new SystemViewFilterReferenceAdapter();

	private SystemViewMessageAdapter msgAdapter = new SystemViewMessageAdapter();

	private SystemViewPromptableAdapter promptAdapter = new SystemViewPromptableAdapter();

	private SystemViewNewConnectionPromptAdapter newConnPromptAdapter = new SystemViewNewConnectionPromptAdapter();

	private SystemTeamViewProfileAdapter profileAdapter = new SystemTeamViewProfileAdapter();

	private SystemTeamViewCategoryAdapter categoryAdapter = new SystemTeamViewCategoryAdapter();

	private SystemTeamViewSubSystemConfigurationAdapter subsysFactoryAdapter = new SystemTeamViewSubSystemConfigurationAdapter();

	private SystemTeamViewPropertySetAdapter propertySetAdapter = new SystemTeamViewPropertySetAdapter();

	private SystemViewFilterStringAdapter filterStringAdapter = new SystemViewFilterStringAdapter();

	/**

	 * @see IAdapterFactory#getAdapterList()

	 */

	public Class[] getAdapterList() {

		return new Class[] { ISystemViewElementAdapter.class, ISystemDragDropAdapter.class, IPropertySource.class, IWorkbenchAdapter.class,

													IActionFilter.class, IDeferredWorkbenchAdapter.class };

	}

	/**

	 * Called by our plugin's startup method to register our adaptable object types 

	 * with the platform. We prefer to do it here to isolate/encapsulate all factory

	 * logic in this one place.

	 * @param manager the adapter manager controlling this factory

	 */

	public void registerWithManager(IAdapterManager manager) {

		manager.registerAdapters(this, ISystemViewInputProvider.class);

		manager.registerAdapters(this, ISystemProfile.class);

		manager.registerAdapters(this, IHost.class);

		manager.registerAdapters(this, ISubSystem.class);

		manager.registerAdapters(this, ISystemFilter.class);

		manager.registerAdapters(this, ISystemFilterPool.class);

		manager.registerAdapters(this, ISystemFilterPoolReference.class);

		manager.registerAdapters(this, ISystemFilterReference.class);

		manager.registerAdapters(this, ISystemFilterString.class);

		manager.registerAdapters(this, ISystemMessageObject.class);

		manager.registerAdapters(this, ISystemPromptableObject.class);

		manager.registerAdapters(this, SystemTeamViewCategoryNode.class);

		manager.registerAdapters(this, SystemTeamViewSubSystemConfigurationNode.class);

		manager.registerAdapters(this, SystemTeamViewPropertySetNode.class);

		// FIXME - UDAs no longer in core

		//manager.registerAdapters(this, SystemTeamViewCompileTypeNode.class);

		//manager.registerAdapters(this, SystemTeamViewCompileCommandNode.class);	

		//manager.registerAdapters(this, SystemUDActionElement.class);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.runtime.IAdapterFactory#getAdapter(java.lang.Object, java.lang.Class)

	 */

	public Object getAdapter(Object adaptableObject, Class adapterType) {

		Object adapter = null;

		if (adaptableObject instanceof ISystemViewElementAdapter)

			adapter = adaptableObject;

		else if (adaptableObject instanceof ISystemDragDropAdapter)

			adapter = adaptableObject;

		else if (adaptableObject instanceof ISystemViewInputProvider)

			adapter = rootAdapter;

		else if (adaptableObject instanceof ISystemProfile)

			adapter = profileAdapter;

		else if (adaptableObject instanceof IHost)

			adapter = connectionAdapter;

		else if (adaptableObject instanceof ISubSystem)

			adapter = subsystemAdapter;

		else if (adaptableObject instanceof ISystemFilterPoolReference)

			adapter = filterPoolReferenceAdapter;

		else if (adaptableObject instanceof ISystemFilterPool)

			adapter = filterPoolAdapter;

		else if (adaptableObject instanceof ISystemFilterReference)

			adapter = filterReferenceAdapter;

		else if (adaptableObject instanceof ISystemFilterString)

			adapter = filterStringAdapter;

		else if (adaptableObject instanceof ISystemFilter)

			adapter = filterAdapter;

		else if (adaptableObject instanceof ISystemMessageObject)

			adapter = msgAdapter;

		else if (adaptableObject instanceof ISystemPromptableObject) {

			if (adaptableObject instanceof SystemNewConnectionPromptObject) {

				adapter = newConnPromptAdapter;

			} else {

				adapter = promptAdapter;

			}

		} else if (adaptableObject instanceof SystemTeamViewCategoryNode)

			adapter = categoryAdapter;

		else if (adaptableObject instanceof SystemTeamViewSubSystemConfigurationNode) adapter = subsysFactoryAdapter;

		else if (adaptableObject instanceof SystemTeamViewPropertySetNode) adapter = propertySetAdapter;

		/** FIXME - UDAs no longer in core

		 else if (adaptableObject instanceof SystemTeamViewCompileTypeNode)

		 adapter = getCompileTypeAdapter();

		 else if (adaptableObject instanceof SystemTeamViewCompileCommandNode)

		 adapter = getCompileCommandAdapter();	      	      

		 else if (adaptableObject instanceof SystemUDActionElement)

		 adapter = getUserActionAdapter();

		 */

		if ((adapter != null) && (adapterType == IPropertySource.class)) {

			((ISystemViewElementAdapter) adapter).setPropertySourceInput(adaptableObject);

		} else if (adapter == null) {

			SystemBasePlugin.logWarning("No adapter found for object of type: " + adaptableObject.getClass().getName()); //$NON-NLS-1$

		}

		return adapter;

	}

	/**

	 * Because we use singletons for our adapters, it is possible to speed up 

	 * access to them by simply returning them from here.

	 * <p>

	 * This method returns the RSE adapter for profile objects

	 * @return SystemViewProfileAdapter

	 * 

	 * @deprecated Call getAdapter(...) directly with a <code>ISystemProfile</code>. instance as adaptable object.

	 */

	public SystemTeamViewProfileAdapter getProfileAdapter() {

		return profileAdapter;

	}

}

/*******************************************************************************

 * Copyright (c) 2000, 2008 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Initial Contributors:

 * The following IBM employees contributed to the Remote System Explorer

 * component that contains this file: David McKnight, Kushal Munir, 

 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 

 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.

 * 

 * Contributors:

 * Kevin Doyle (IBM) - [187553] - Removed code and related methods for toolbar/button bar.

 * Martin Oberhuber (Wind River) - [190271] Move ISystemViewInputProvider to Core

 * David McKnight    (IBM)   - [187711] select SystemView APIs exposed by the ISystemTree interface

 *******************************************************************************/

package org.eclipse.rse.internal.ui.view;

import java.util.List;

import java.util.Vector;

import org.eclipse.jface.action.ToolBarManager;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.rse.core.filters.ISystemFilter;

import org.eclipse.rse.core.filters.ISystemFilterReference;

import org.eclipse.rse.core.model.ISystemViewInputProvider;

import org.eclipse.rse.core.subsystems.ISubSystem;

import org.eclipse.rse.ui.dialogs.SystemPromptDialog;

import org.eclipse.rse.ui.messages.ISystemMessageLine;

import org.eclipse.rse.ui.view.ISystemLongRunningRequestListener;

import org.eclipse.rse.ui.view.ISystemTree;

import org.eclipse.rse.ui.view.SystemLongRunningRequestEvent;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Item;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.ToolBar;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.swt.widgets.TreeItem;

/**

 * This re-usable widget is for a single widget that displays a 

 *  toolbar underneath which is a systems view tree.

 */

public class SystemViewForm extends Composite implements  ISystemTree

{

	private ToolBar        toolbar = null;

	private ToolBarManager toolbarMgr = null;

	private Button         refreshButton, getListButton;

	private SystemView     tree = null;

	private ISystemMessageLine msgLine = null;

	private boolean        showActions = true;

	private boolean        deferLoading = false;	

	private boolean        requestInProgress = false;

    private ISystemViewInputProvider inputProvider = null;

    private ISystemViewInputProvider emptyProvider = new SystemEmptyListAPIProviderImpl();

    private Vector         requestListeners = null;

	public static final int DEFAULT_WIDTH = 300;

	public static final int DEFAULT_HEIGHT = 300;

	// the following allows us to identify dialog/wizard hosting this widget so we can 

	// disable it's close capability while a remote request is in place.

	protected Object  caller;

	protected boolean callerInstanceOfWizardPage, callerInstanceOfSystemPromptDialog;

	// viewer filters

	protected ViewerFilter[] initViewerFilters = null;

	/**

	 * Constructor

	 * @param shell The owning window

	 * @param parent The owning composite

	 * @param style The swt style to apply to the overall composite. Typically SWT.NULL

	 * @param inputProvider Who is supplying the roots for the system viewer?

     * @param singleSelectionMode Are users allowed to select multiple things at once?

	 * @param msgLine where to show messages and tooltip text

	 */

	public SystemViewForm(Shell shell, Composite parent, int style, ISystemViewInputProvider inputProvider, 

	                      boolean singleSelectionMode, ISystemMessageLine msgLine)

	{

		this(shell, parent, style, inputProvider, singleSelectionMode, msgLine, 1, 1);	

	}

	/**

	 * Constructor when you want to span more than one column or row

	 * @param shell The owning window

	 * @param parent The owning composite

	 * @param style The swt style to apply to the overall composite. Typically SWT.NULL

	 * @param inputProvider Who is supplying the roots for the system viewer?

     * @param singleSelectionMode Are users allowed to select multiple things at once?

	 * @param msgLine where to show messages and tooltip text

	 * @param horizontalSpan how many columns in parent composite to span

	 * @param verticalSpan how many rows in parent composite to span

	 */

	public SystemViewForm(Shell shell, Composite parent, int style, ISystemViewInputProvider inputProvider, 

	                      boolean singleSelectionMode, ISystemMessageLine msgLine,  

	                      int horizontalSpan, int verticalSpan)

	{

		this(shell, parent, style, inputProvider, singleSelectionMode, msgLine, horizontalSpan, verticalSpan, null);

	}

	/**

	 * Constructor when you want to span more than one column or row

	 * @param shell The owning window

	 * @param parent The owning composite

	 * @param style The swt style to apply to the overall composite. Typically SWT.NULL

	 * @param inputProvider Who is supplying the roots for the system viewer?

     * @param singleSelectionMode Are users allowed to select multiple things at once?

	 * @param msgLine where to show messages and tooltip text

	 * @param horizontalSpan how many columns in parent composite to span

	 * @param verticalSpan how many rows in parent composite to span

	 * @param initViewerFilters the initial viewer filters to apply.

	 */

	public SystemViewForm(Shell shell, Composite parent, int style, ISystemViewInputProvider inputProvider, 

	                      boolean singleSelectionMode, ISystemMessageLine msgLine,  

	                      int horizontalSpan, int verticalSpan, ViewerFilter[] initViewerFilters)

	{

		super(parent, style);	

		this.inputProvider = inputProvider;

		this.msgLine = msgLine;

		callerInstanceOfWizardPage = (caller instanceof WizardPage);

		callerInstanceOfSystemPromptDialog = (caller instanceof SystemPromptDialog);				

		prepareComposite(1, horizontalSpan, verticalSpan);

	    // set viewer filters

	    this.initViewerFilters = initViewerFilters;

	    createSystemView(shell, inputProvider, singleSelectionMode);

	}

	/**

	 * Return the toolbar widget manager

	 */

	public ToolBarManager getToolBarManager()

	{

		return toolbarMgr;

	}

	/**

	 * Return the system view tree viewer

	 */

	public SystemView getSystemView()

	{

		return tree;

	}

	/**

	 * Return the system view tree viewer tree widget

	 */

	public Tree getTreeControl()

	{

		return tree.getTree();

	}

    /**

     * Set the tree's tooltip text

     */

    public void setToolTipText(String tip)

    {

    	tree.getTree().setToolTipText(tip);

    }

    /**

     * Refresh contents

     */

    public void refresh()

    {

    	tree.refreshAll();

    }

    /**

     * Reset contents

     */

    public void reset(ISystemViewInputProvider inputProvider)

    {

    	this.inputProvider = inputProvider;

    	if (deferLoading)

    	{

    	  tree.setSelection(null);

    	  tree.setInputProvider(emptyProvider);

    	}

    	else

    	{

    	  tree.setSelection(null);

    	  tree.setInputProvider(inputProvider);

    	}

    }

	/*

	 * Turn off right-click actions

	 *

	 NOW SET VIA INPUT PROVIDER METHODS

	public void setShowActions(boolean show)

	{

		this.showActions = show;

		if (tree != null)

		  tree.setShowActions(show);

	}*/

	/**

	 * Disable/Enable all the child controls.

	 */

	public void setEnabled(boolean enabled)

	{

		if (toolbar != null)

		  toolbar.setEnabled(enabled);

		tree.setEnabled(enabled);

		//if ((tree != null) && (tree.getTree() != null))

		//  tree.getTree().setEnabled(enabled);		

		//super.setEnabled(enabled);

	}

	/**

	 * Register a listener interested in an item is selected in the system view

     * @see #removeSelectionChangedListener(ISelectionChangedListener)

     */

    public void addSelectionChangedListener(ISelectionChangedListener listener) 

    {

	    tree.addSelectionChangedListener(listener);

    }

    /** 

     * Remove a previously set system view selection listener.

     * @see #addSelectionChangedListener(ISelectionChangedListener)

     */

    public void removeSelectionChangedListener(ISelectionChangedListener listener) 

    {

	    tree.removeSelectionChangedListener(listener);

    }

    /**

     * Add a listener that is informed when a remote list request starts and stops.

     * This allows for the listener to do things like disable the Close button

     */

    public void addListRequestListener(ISystemLongRunningRequestListener listener)

    {

    	if (requestListeners == null)

    	  requestListeners = new Vector();

    	requestListeners.addElement(listener);

    }

    /**

     * Add a listener that is informed when a remote list request starts and stops.

     * This allows for the listener to do things like disable the Close button

     */

    public void removeListRequestListener(ISystemLongRunningRequestListener listener)

    {

    	if (requestListeners != null)

    	  requestListeners.removeElement(listener);

    }

    /**

     * Return the selection of the tree viewer

     */

    public ISelection getSelection()

    {

    	return tree.getSelection();

    }

	// --------------------------------------------	

	// ISystemTree methods to facilitate our GUI...

	//  ... all these are delegated to the SystemView tree

	// --------------------------------------------

    /**

     * Returns true if any of the selected items are currently expanded

     */

    public boolean areAnySelectedItemsExpanded()

    {

    	return tree.areAnySelectedItemsExpanded();

    }    

    /**

     * Returns true if any of the selected items are expandable but not yet expanded

     */

    public boolean areAnySelectedItemsExpandable()

    {

    	return tree.areAnySelectedItemsExpandable();

    }

	/**

	 * This is called to ensure all elements in a multiple-selection have the same parent in the

	 *  tree viewer. If they don't we automatically disable all actions. 

	 * <p>

	 * Designed to be as fast as possible by going directly to the SWT widgets

	 */

	public boolean sameParent()

	{

		return tree.sameParent();

	}

	/**

	 * This is called to accurately get the parent object for the current selection

	 *  for this viewer. 

	 * <p>

	 * The getParent() method in the adapter is very unreliable... adapters can't be sure

	 * of the context which can change via filtering and view options.

	 */

	public Object getSelectedParent()

	{

		return tree.getSelectedParent();

	}

	/**

	 * This returns the element immediately before the first selected element in this tree level.

	 * Often needed for enablement decisions for move up actions.

	 */

	public Object getPreviousElement()

	{

		 return tree.getPreviousElement();

	}

	/**

	 * This returns the element immediately after the last selected element in this tree level

	 * Often needed for enablement decisions for move down actions.

	 */

	public Object getNextElement()

	{

		 return tree.getNextElement();

	}

	/**

	 * This is called to walk the tree back up to the roots and return the visible root

	 *  node for the first selected object.

	 */

	public Object getRootParent()

	{

		return tree.getRootParent();

	}

	/**

	 * This returns an array containing each element in the tree, up to but not including the root.

	 * The array is in reverse order, starting at the leaf and going up.

	 */

	public Object[] getElementNodes(Object element)

	{

		return tree.getElementNodes(element);

	}

	/**

	 * Helper method to determine if a given object is currently selected.

	 * Does consider if a child node of the given object is currently selected.

	 */

	public boolean isSelectedOrChildSelected(Object parentElement)

	{

		return tree.isSelectedOrChildSelected(parentElement);

	}

	/**

	 * Return the number of immediate children in the tree, for the given tree node

	 */

    public int getChildCount(Object element)

	{

        return tree.getChildCount(element);

	}

    /**

     * Called when a property is updated and we need to inform the Property Sheet viewer.

     * There is no formal mechanism for this so we simulate a selection changed event as

     *  this is the only event the property sheet listens for.

     */

    public void updatePropertySheet()

    {

        tree.updatePropertySheet();

    }

    /**

     * Called to select an object within the tree, and optionally expand it

     */   

    public void select(Object element, boolean expand)

    {

        tree.select(element, expand);

    }

    /**

     * Returns the tree item of the first selected object. Used for setViewerItem in a resource

     *  change event.

     */

    public Item getViewerItem()

    {

    	return tree.getViewerItem();

    }	

    /**

     * Returns true if it is ok to close the dialog or wizard page. Returns false if there

     *  is a remote request currently in progress.

     */

    public boolean okToClose()

    {

    	return !requestInProgress; //d43433

    }

	// -----------------------

	// INTERNAL-USE METHODS...

	// -----------------------

	/**

	 * Prepares this composite control and sets the default layout data.

	 * @param Number of columns the new group will contain.     

	 */

	protected Composite prepareComposite(int numColumns,

	                                     int horizontalSpan, int verticalSpan)	

	{

		Composite composite = this;

		//GridLayout

		GridLayout layout = new GridLayout();

		layout.numColumns = numColumns;

		layout.marginWidth = 0;

		layout.marginHeight = 0;

		layout.horizontalSpacing = 0;		

		layout.verticalSpacing = 0;		

		composite.setLayout(layout);

		//GridData

		GridData data = new GridData();

		data.verticalAlignment = GridData.FILL;

		data.horizontalAlignment = GridData.FILL;

	    data.grabExcessHorizontalSpace = true;        

	    data.grabExcessVerticalSpace = true;	    

	    data.widthHint = DEFAULT_WIDTH;	    

	    data.heightHint = DEFAULT_HEIGHT;	

	    data.horizontalSpan = horizontalSpan;

	    data.verticalSpan = verticalSpan;    

		composite.setLayoutData(data);

		return composite;

	}

	protected void createSystemView(Shell shell, ISystemViewInputProvider inputProvider, boolean singleSelectionMode)

	{

		// TREE

        int style = (singleSelectionMode ? SWT.SINGLE : SWT.MULTI) | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER;

		tree = new SystemView(shell, this, style, deferLoading ? emptyProvider : inputProvider, msgLine, initViewerFilters);        

	    GridData treeData = new GridData();

	    treeData.horizontalAlignment = GridData.FILL;

	    treeData.verticalAlignment = GridData.FILL;	    

	    treeData.grabExcessHorizontalSpace = true;

	    treeData.grabExcessVerticalSpace = true;	    

	    treeData.widthHint = 300;        

	    treeData.heightHint= 200;

	    tree.getTree().setLayoutData(treeData);  	  	    		

	    tree.setShowActions(showActions);

	}

	protected void addOurMouseListener()

	{

	   MouseListener mouseListener = new MouseAdapter() 

	   {

		   public void mouseDown(MouseEvent e) 

		   {

			   //requestActivation();

		   }

	   };	

	   toolbar.addMouseListener(mouseListener);

	}

    /**

     * Fire long running request listener event

     */

    protected void fireRequestStartEvent()

    {

    	if (requestListeners != null)

    	{

    		SystemLongRunningRequestEvent event = new SystemLongRunningRequestEvent(); 

    		for (int idx=0; idx<requestListeners.size(); idx++)

    		   ((ISystemLongRunningRequestListener)requestListeners.elementAt(idx)).startingLongRunningRequest(event);

    	}

    }

    /**

     * Fire long running request listener event

     */

    protected void fireRequestStopEvent()

    {

    	if (requestListeners != null)

    	{

    		SystemLongRunningRequestEvent event = new SystemLongRunningRequestEvent(); 

    		for (int idx=0; idx<requestListeners.size(); idx++)

    		   ((ISystemLongRunningRequestListener)requestListeners.elementAt(idx)).endingLongRunningRequest(event);

    	}

    }

    /**

     * wrapper method to satisfy the ISystemTree interface

     */

	public void createTreeItems(TreeItem widget, Object[] children)

	{

		tree.createTreeItems(widget, children);

	}

    /**

     * wrapper method to satisfy the ISystemTree interface

     */

	public List findAllRemoteItemReferences(Object element,

			Object elementObject, List matches) {

		return tree.findAllRemoteItemReferences(element, elementObject, matches);

	}

    /**

     * wrapper method to satisfy the ISystemTree interface

     */

	public Item findFirstRemoteItemReference(Object remoteObject,

			Item parentItem) {

		return tree.findFirstRemoteItemReference(remoteObject, parentItem);

	}

    /**

     * wrapper method to satisfy the ISystemTree interface

     */

	public Tree getTree() {

		return tree.getTree();

	}

    /**

     * wrapper method to satisfy the ISystemTree interface

     */

	public ISystemFilterReference revealAndExpand(ISubSystem parentSubSystem,

			ISystemFilter filter) {

		return tree.revealAndExpand(parentSubSystem, filter);

	}

}

/********************************************************************************

 * Copyright (c) 2002, 2008 IBM Corporation and others. All rights reserved.

 * This program and the accompanying materials are made available under the terms

 * of the Eclipse Public License v1.0 which accompanies this distribution, and is 

 * available at http://www.eclipse.org/legal/epl-v10.html

 * 

 * Initial Contributors:

 * The following IBM employees contributed to the Remote System Explorer

 * component that contains this file: David McKnight, Kushal Munir, 

 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 

 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.

 * 

 * Contributors:

 * Martin Oberhuber (Wind River) - [186773] split ISystemRegistryUI from ISystemRegistry

 * Tobias Schwarz   (Wind River) - [173267] "empty list" should not be displayed 

 * Martin Oberhuber (Wind River) - [190271] Move ISystemViewInputProvider to Core

 * Martin Oberhuber (Wind River) - [218524][api] Remove deprecated ISystemViewInputProvider#getShell()

 ********************************************************************************/

package org.eclipse.rse.internal.ui.view;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Preferences;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.rse.core.RSECorePlugin;

import org.eclipse.rse.core.model.ISystemMessageObject;

import org.eclipse.rse.core.model.ISystemRegistry;

import org.eclipse.rse.core.model.ISystemViewInputProvider;

import org.eclipse.rse.core.model.SystemMessageObject;

import org.eclipse.rse.ui.ISystemMessages;

import org.eclipse.rse.ui.ISystemPreferencesConstants;

import org.eclipse.rse.ui.RSEUIPlugin;

import org.eclipse.rse.ui.view.ISystemRemoteElementAdapter;

import org.eclipse.rse.ui.view.ISystemViewElementAdapter;

import org.eclipse.rse.ui.view.SystemAdapterHelpers;

import org.eclipse.swt.widgets.Shell;

/**

 * This is a base class that a provider of root nodes to the remote systems tree viewer part can

 * use as a parent class.

 */

public abstract class SystemAbstractAPIProvider 

       implements ISystemViewInputProvider

{

	protected Viewer viewer;

	protected ISystemRegistry sr;

	protected Object[] emptyList = new Object[0];

	protected Object[] msgList   = new Object[1];

	/**

	 * @deprecated Use {@link #checkForEmptyList(Object[], Object, boolean)} instead.

	 */

	protected SystemMessageObject nullObject     = null;

	protected SystemMessageObject canceledObject = null;	

	protected SystemMessageObject errorObject    = null;	

	private Preferences fPrefStore = null;

	/**

	 * Constructor 

	 */

	public SystemAbstractAPIProvider()

	{

		super();

		sr = RSECorePlugin.getTheSystemRegistry();

	}

    /**

	 * This is the method required by the IAdaptable interface.

	 * Given an adapter class type, return an object castable to the type, or

	 *  null if this is not possible.

	 */

    public Object getAdapter(Class adapterType)

    {

   	    return Platform.getAdapterManager().getAdapter(this, adapterType);	

    }           

    /*

     * (non-Javadoc)

     * @see org.eclipse.rse.ui.view.ISystemViewInputProvider#setViewer(java.lang.Object)

     */

    public void setViewer(Object viewer)

    {

    	this.viewer = (Viewer)viewer;

    }

    /*

     * (non-Javadoc)

     * @see org.eclipse.rse.ui.view.ISystemViewInputProvider#getViewer()

     */

    public Object getViewer()

    {

    	return viewer;

    }

    protected final void initMsgObjects()

 	{

 		nullObject     = new SystemMessageObject(RSEUIPlugin.getPluginMessage(ISystemMessages.MSG_EXPAND_EMPTY),ISystemMessageObject.MSGTYPE_EMPTY, null);

 		canceledObject = new SystemMessageObject(RSEUIPlugin.getPluginMessage(ISystemMessages.MSG_LIST_CANCELED),ISystemMessageObject.MSGTYPE_CANCEL, null);

 		errorObject    = new SystemMessageObject(RSEUIPlugin.getPluginMessage(ISystemMessages.MSG_EXPAND_FAILED),ISystemMessageObject.MSGTYPE_ERROR, null);

 	}

    /**

     * <i>Callable by subclasses. Do not override</i><br>

     * In getChildren, return <samp>checkForEmptyList(children, parent, true/false)<.samp>

     * versus your array directly. This method checks for a null array which is

     * not allowed and replaces it with an empty array. 

     * If true is passed then it returns the "Empty list" message object if the array is null or empty

     * 

     * @param children The list of children.

     * @param parent The parent for the children.

     * @param returnNullMsg <code>true</code> if an "Empty List" message should be returned.

     * @return The list of children, a list with the "Empty List" message object or an empty list.

     */

    protected Object[] checkForEmptyList(Object[] children, Object parent, boolean returnNullMsg) {

    	if ((children == null) || (children.length == 0)) {

    		if (fPrefStore == null) {

    			fPrefStore = RSEUIPlugin.getDefault().getPluginPreferences();

    		}

    		if (!returnNullMsg

    				|| (fPrefStore != null && !fPrefStore

    						.getBoolean(ISystemPreferencesConstants.SHOW_EMPTY_LISTS))) {

    			return emptyList;

    		} else {

    			return new Object[] {

    				new SystemMessageObject(

    					RSEUIPlugin.getPluginMessage(ISystemMessages.MSG_EXPAND_EMPTY),

    					ISystemMessageObject.MSGTYPE_EMPTY, 

    					parent)};

    		}

    	}

    	return children;

    }

    /**

     * In getChildren, return checkForNull(children, true/false) vs your array directly.

     * This method checks for a null array which not allow and replaces it with an empty array.

     * If true is passed then it returns the "Empty list" message object if the array is null or empty

     * 

     * @deprecated Use {@link #checkForEmptyList(Object[], Object, boolean)} instead.

     */

    protected Object[] checkForNull(Object[] children, boolean returnNullMsg)

    {

	   if ((children == null) || (children.length==0))

	   {

	   	 if (!returnNullMsg)

           return emptyList;

         else

         {

	 	   if (nullObject == null)

	 	     initMsgObjects();

	 	   msgList[0] = nullObject;

	 	   return msgList;

         }

	   }

       else

         return children;

    }

    /**

     * Return the "Operation cancelled by user" msg as an object array so can be used to answer getChildren()

     */

    protected Object[] getCancelledMessageObject()

    {    	

		 if (canceledObject == null)

		   initMsgObjects();

		 msgList[0] = canceledObject;

		 return msgList;

    }    

    /**

     * Return the "Operation failed" msg as an object array so can be used to answer getChildren()

     */

    protected Object[] getFailedMessageObject()

    {    	

		 if (errorObject == null)

		   initMsgObjects();

		 msgList[0] = errorObject;

		 return msgList;

    }    

	/**

	 * Return true if we are listing connections or not, so we know whether we are interested in 

	 *  connection-add events

	 */

	public boolean showingConnections()

	{

		return false;

	}

	// ------------------

	// HELPER METHODS...

	// ------------------