/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.displayers.selector;
  
  import java.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  import java.util.ArrayList;
  import java.util.Arrays;
  
  import com.cosylab.util.ListenerList;
  import com.cosylab.util.NumericStringComparator;
  
  import de.desy.acop.transport.AccessMode;
  import de.desy.tine.queryUtils.TQuery;
  
  /**
   * <code>Selector</code> is a non-visual bean which performs all queries for
   * remote property names. The queries are bean started by selecting the
   * higher level parameter. First the access protocol should be selected, which
   * triggers the context query. Upon selecting the context, subsystem query will
   * be performed etc. 
   * <p>
   * All queries made in this bean are synchronous. However one cannot explicitely
   * demand a list of parameters if the query has not been completed. After each
   * of the queries completes it will set the parameters to the property
   * whic will fire a PropertyChangeEvent notifying the listeners that one
   * of the properties has changed. In addition to that selector also fires 
   * <code>QueryEvent</code>s each time a query was started or finished.
   * </p>
   * 
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @version $Id: Templates.xml,v 1.10 2004/01/13 16:17:13 jbobnar Exp $
   * @see TQuery
   */
  public class Selector {
  
  	
  	public static void main(String[] args) {
  		String[] prop = TQuery.getContexts();
  		System.out.println(prop);
  		System.exit(0);
      }
  	
  	public static final String PROTOCOL_TINE = "TINE";
  			
  	private PropertyChangeSupport propertyChangeSupport;
  	private String selectedSubSystem = null;
  	private String[] availableSubsystems = null;
  	private String[] availableContexts = null;
  	private String selectedContext = null;
  	private String[] availableServers = null;
  	private String selectedServer = null;
  	private String[] availableDevices = null;
  	private String selectedDevice = null;
  	private String[] availableProperties = null;
  	private String selectedProperty = null;
  	private String[] availableProtcols = new String[]{PROTOCOL_TINE};
  	private String selectedProtocol = null;
  	private int accessRate = 1000;
  	private AccessMode accessMode = AccessMode.POLL;
  	private volatile int queries=0;
  	
  	private boolean showStockProperties = false;
  	
  	private boolean propertyPrecedence = false;
  	private boolean devicePrecedence = false;
  	
  	private ListenerList queryListeners = new ListenerList(QueryListener.class);
  	private ListenerList exceptionListeners = new ListenerList(ExceptionListener.class);
  	
  	private NumericStringComparator comparator = new NumericStringComparator();
  	
  	private int searchingContext = 0;
  	private int searchingServer = 0;
  	private int searchingDevice = 0;
  	private int searchingProperty = 0;
  	private int searchingSubsystem = 0;
  	
  	/**
 	 * Constructs a new Selector.
 	 *
 	 */
 	public Selector() {
 		super();
 		propertyChangeSupport = new PropertyChangeSupport(this);
 	}
 	
 	private void performContextQuery() {
 		try {
 			searchingContext++;
 	    	setAvailableContexts(null);
 	    	setAvailableServers(null);
 	    	setAvailableDevices(null);
 	    	setAvailableProperties(null);
 	    	setAvailableContexts(TQuery.getContexts());
 		} catch (Exception e) {
 			handleException(e);
 		} finally {
 			searchingContext--;
 			checkIfIsWorking();
 		}
 	}
 	
 	private void performServerQuery() {
 		try {
 			searchingServer++;
 	    	setAvailableProperties(null);
 	    	setAvailableDevices(null);
 	    	setAvailableServers(null);
 			if (selectedContext != null) {
 				setAvailableServers(TQuery.getDeviceServers(selectedContext, selectedSubSystem));
 			}
 		} catch (Exception e) {
 			handleException(e);
 		} finally {
 			searchingServer--;
 			checkIfIsWorking();
 		}
 	}
 	
 	private void performSubsystemQuery() {
 		try {
 			searchingSubsystem++;
 	    	setAvailableProperties(null);
 	    	setAvailableDevices(null);
 	    	setAvailableServers(null);
 	    	setAvailableSubsystems(null);
 			if (selectedContext != null) {
 				setAvailableSubsystems(TQuery.getDeviceSubsystems(selectedContext));
 			}
 		} catch (Exception e) {
 			handleException(e);
 		} finally {
 			searchingSubsystem--;
 			checkIfIsWorking();
 		}
 	}
 	
 	private void performDeviceNameQuery(boolean clearAvailableProperties) {
 		try {
 			searchingDevice++;
 	    	if (clearAvailableProperties)
 	    		setAvailableProperties(null);
 			if (!(selectedContext == null || selectedServer == null))  {
 				
 				String[] devices = null;
 				
 				if (!propertyPrecedence) {
 					devices = TQuery.getDeviceNames(selectedContext, selectedServer);
 					if (TQuery.devices_have_query_function) 
 						propertyPrecedence = true;
 			    } else {
 		        	devices = TQuery.getDeviceNames(selectedContext, selectedServer, selectedProperty);
 			    }
 
 				setAvailableDevices(devices);
 			} else {
 				setAvailableDevices(null);
 			}
 			
 			
 		} catch (Exception e) {
 			handleException(e);
 		} finally {
 			searchingDevice--;
 			checkIfIsWorking();
 		}
 	}
 	
 	private void performPropertyNameQuery(String wildCharProp) {
     	try {
     		searchingProperty++;
         	if (selectedContext == null || selectedServer == null) return;
     		
     		String[] properties = TQuery.getDeviceProperties(selectedContext, selectedServer, selectedDevice, wildCharProp);
     		
     		if (TQuery.properties_have_query_function) {
     	        devicePrecedence = true;
     	        propertyPrecedence = false;
     	    }
     		
     		String[] stocks = new String[0];
     		if (showStockProperties) {
     			stocks = TQuery.getStockProperties(selectedContext, selectedServer);
     		}
     		
     		if (properties != null) {
 	    		int offset = properties.length;
 	    		String[] available = new String[offset + stocks.length];
 	    		for (int i = 0; i < offset; i++) {
 	    			available[i] = properties[i];
 	    		}
 	    		for (int i = 0; i < stocks.length; i++) {
 	    			available[offset+i] = stocks[i];
 	    		}
 		    	
 	    		setAvailableProperties(available);
     		} 
             
         } catch (Exception e) {
             handleException(e);
         } finally {
         	searchingProperty--;
         	checkIfIsWorking();
         }
     }
 	
 	public boolean isBusy() {
 		return searchingContext!=0 || searchingDevice!=0 || searchingProperty!=0
 				|| searchingServer!=0 || searchingSubsystem!=0;
 	}
 	
 	private void checkIfIsWorking() {
 		if (!isBusy())  {
 			fireQueryFinished("all");
 		}
 	}
 	
 	/**
 	 * Returns the selected context.
 	 * 
      * @return the selectedContext
      */
     public String getSelectedContext() {
     	return selectedContext;
     }
     
 	/**
 	 * Selects a context and initiates subsystem query.
 	 * 
      * @param selectedContext the selectedContext to set
      */
     public synchronized void setSelectedContext(String selectedContext) {
     	try {
     		searchingContext++;
 	    	if ("".equals(selectedContext)) {
 	    		selectedContext=null;
 	    	}
 	    	if (!acceptProperty(this.selectedContext, selectedContext)) {
 	    		return;
 	    	}
 	    	fireQueryStarted("context");
 	    	String old = this.selectedContext;
 	    	this.selectedContext = selectedContext;
 	    	firePropertyChange("selectedContext", old, selectedContext);
 	    	if (selectedContext != null)
 	    		performSubsystemQuery();
 	    	else {
 	    		setSelectedSubSystem(null);
 	    		setAvailableSubsystems(null);
 	    		setSelectedServer(null);
 	    		setAvailableServers(null);
 	    		setSelectedDevice(null);
 	    		setAvailableDevices(null);
 	    		setSelectedProperty(null);
 	    		setAvailableProperties(null);
 	    	}
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		searchingContext--;
     		fireQueryFinished("context");
     	}
     }
 
 	/**
 	 * Returns the selected device.
 	 * 
      * @return the selectedDevice
      */
     public String getSelectedDevice() {
     	return selectedDevice;
     }
 
 	/**
 	 * Selects a device and intiates property names query.
 	 * 
      * @param selectedDevice the selectedDevice to set
      */
     public synchronized void setSelectedDevice(String selectedDevice) {
     	try {
     		searchingDevice++;
 	    	if ("".equals(selectedDevice)) {
 	    		selectedDevice=null;
 	    	}
 	    	if (!acceptProperty(this.selectedDevice, selectedDevice)) {
 	    		return;
 	    	} 
 	    	fireQueryStarted("device");	 
 	    	String old = this.selectedDevice;
 	    	this.selectedDevice = selectedDevice;
 	    	firePropertyChange("selectedDevice", old, selectedDevice);	
 	    	if (selectedDevice != null && selectedDevice.contains("*")) {
 	    		return;
 	    	}
 	       	if (this.selectedDevice != null || devicePrecedence) {
 	    		performPropertyNameQuery(null);
 	    	} else if (!propertyPrecedence){
 	    		setAvailableProperties(null);
 	    	}
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		searchingDevice--;
     		fireQueryFinished("device");
     	}
     }
 
 	/**
 	 * Returns the selected property.
 	 * 
      * @return the selectedProperty
      */
     public String getSelectedProperty() {
     	return selectedProperty;
     }
 
 	/**
 	 * Selects the property and reinitiates the device name query for
 	 * potential reversed hierarchy.
 	 * 
      * @param selectedProperty the selectedProperty to set
      */
     public synchronized void setSelectedProperty(String selectedProperty) {
     	try {
     		searchingProperty++;
 	    	if ("".equals(selectedProperty)) {
 	    		selectedProperty=null;
 	    	}
 	    	
 	    	if (!acceptProperty(this.selectedProperty, selectedProperty)) {
 	    		return;
 	    	}
 	    	fireQueryStarted("property");
 	    	
 //	    	if (selectedProperty != null && selectedProperty.endsWith("*")) {
 //	    		String old = this.selectedProperty;
 //		    	this.selectedProperty = null;
 //	    		performPropertyNameQuery(selectedProperty);
 //	    		firePropertyChange("selectedProperty", old, null);
 //	    	} else {
 	    		String old = this.selectedProperty;
 		    	this.selectedProperty = selectedProperty;
 		    	if (propertyPrecedence || !devicePrecedence) {
 		    		performDeviceNameQuery(false);
 		    	}
 		    	firePropertyChange("selectedProperty", old, selectedProperty);
 //	    	}
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		searchingProperty--;
     		fireQueryFinished("property");
     	}
     }
 
 	/**
 	 * Returns the selected server.
 	 * 
      * @return the selectedServer
      */
     public String getSelectedServer() {
     	return selectedServer;
     }
 
 	/**
 	 * Selects the device server and initiates device and property name queryies.
 	 * 
      * @param selectedServer the selectedServer to set
      */
     public synchronized void setSelectedServer(String selectedServer) {
     	try {
     		searchingServer++;
 	    	if ("".equals(selectedServer)) {
 	    		selectedServer=null;
 	    	}
 	
 	    	if (!acceptProperty(this.selectedServer, selectedServer)) {
 	    		return;
 	    	}
 	    	fireQueryStarted("server");
 	    	String old = this.selectedServer;
 	    	this.selectedServer = selectedServer;
 	    	propertyPrecedence = false;
 	    	devicePrecedence = false;
 	    	firePropertyChange("selectedServer", old, selectedServer);
 	    	    	
 	    	setSelectedProperty(null);
 			setSelectedDevice(null);
 	
 	    	setAvailableDevices(null);
 	    	performDeviceNameQuery(true);
 	    	performPropertyNameQuery(null);
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		searchingServer--;
     		fireQueryFinished("server");
     	}
     }
     
 	/**
 	 * Returns the selected protocol.
 	 * 
      * @return the selectedProtocol
      */
     public String getSelectedProtocol() {
     	return selectedProtocol;
     }
     
     private boolean acceptProperty(String oldP, String newP) {
     	if (oldP == null && newP == null) return false;
     	else if (oldP != null && newP != null &&
     			oldP.equals(newP)) return false;
     	return true;
     }
 
 	/**
 	 * Selects a device protocol and initiates qontext search.
 	 * 
      * @param selectedProtocol the selectedProtocol to set
      */
     public synchronized void setSelectedProtocol(String selectedProtocol) {
     	try {
 	    	if ("".equals(selectedProtocol)) {
 	    		selectedProtocol=null;
 	    	}
 
 	    	if (!acceptProperty(this.selectedProtocol, selectedProtocol)) {
 	    		return;
 	    	}
 	    	
 	    	fireQueryStarted("protocol");
 	    	String old = this.selectedProtocol;
 	    	this.selectedProtocol = selectedProtocol;
 	
 	    	firePropertyChange("selectedProtocol", old, selectedProtocol);
 	    	if (selectedProtocol == null) {
 	    		setSelectedContext(null);
 	    		setAvailableContexts(null);
 	    		setSelectedServer(null);
 	    		setAvailableServers(null);
 	    		setSelectedDevice(null);
 	    		setAvailableDevices(null);
 	    		setSelectedProperty(null);
 	    		setAvailableProperties(null);
 	    	} else {
 	    		performContextQuery();
 	    	}
 
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		fireQueryFinished("protocol");
     	}
 
     	
     }
 
 	/**
 	 * Returns all available contexts loaded from remote server.
 	 * 
      * @return the availableContexts
      */
     public String[] getAvailableContexts() {
     	return availableContexts;
     }
 
 	/**
 	 * Returns all available devices loaded from remote server.
 	 * 
      * @return the availableDevices
      */
     public String[] getAvailableDevices() {
     	return availableDevices;
     }
 
 	/**
 	 * Returns all available properties loaded from remote server.
 	 * 
      * @return the availableProperties
      */
     public String[] getAvailableProperties() {
     	return availableProperties;
     }
 
 	/**
 	 * Returns all available servers loaded from remote server.
      * @return the availableServers
      */
     public String[] getAvailableServers() {
     	return availableServers;
     }
     
     protected void firePropertyChange(String name, Object oldValue, Object newValue) {
     	if (oldValue == null && newValue == null) return;
     	propertyChangeSupport.firePropertyChange(name, oldValue, newValue);
     }
     
     /**
      * Adds a PropertyChangeListener and assigns it to listen to a specific property.
      * 
      * @param name the name of the property
      * @param l the listener to be added
      */
     public void addPropertyChangeListener(String name, PropertyChangeListener l) {
     	propertyChangeSupport.addPropertyChangeListener(name, l);
     }
     
     /**
      * Removes a PropertyChangeListener from listening a specific property.
      * 
      * @param name the name of the property that the listener has been listening to
      * @param l the listener to be removed
      */
     public void removePropertyChangeListener(String name, PropertyChangeListener l) {
     	propertyChangeSupport.removePropertyChangeListener(name, l);
     }
     
     /**
      * Adds a PropertyChangeListener for all properties.
      * 
      * @param l listener to be added
      */
     public void addPropertyChangeListener(PropertyChangeListener l) {
     	propertyChangeSupport.addPropertyChangeListener(l);
     }
     
     /**
      * Removes a PropertyChangeListener.
      * 
      * @param l listener to be removed
      */
     public void removePropertyChangeListener(PropertyChangeListener l) {
     	propertyChangeSupport.removePropertyChangeListener(l);
     }
 
     private String[] addDefaultContext(String[] contexts) {
     	String[] availableContextsTemp = new String[contexts.length + 1];
     	availableContextsTemp[0] = "DEFAULT";
     	for (int i = 0; i < contexts.length; i++) {
     		availableContextsTemp[i+1] = contexts[i];
     	}
     	return availableContextsTemp;
     }
     
     @SuppressWarnings("unchecked")
 	private synchronized void setAvailableContexts(String[] availableContexts) {
     	if (this.availableContexts == null && availableContexts == null) return;
     	String[] old = this.availableContexts;
     	if (availableContexts != null) 
     		Arrays.sort(availableContexts, comparator);
     	else 
     		availableContexts = new String[0];
     	//add default context
     	String[] availableContextsTemp = addDefaultContext(availableContexts);
     	if (Arrays.equals(this.availableContexts, availableContextsTemp)) return;    	
     	this.availableContexts = availableContextsTemp;
     	firePropertyChange("availableContexts", old, availableContexts);
 	    	if (this.availableContexts != null) {
 		    	for (String p: this.availableContexts) {
 		    		if (p.equals(selectedContext)) {
 		    			performSubsystemQuery();
 		    			return;
 		    		}
 		    	}
 		    	if (this.availableContexts.length > 0) {
 		    		setSelectedContext(this.availableContexts[0]);
 		    	} else {
 		    		setSelectedContext(null);
 		    		setSelectedSubSystem(null);
 		    		setSelectedServer(null);
 			    	setSelectedDevice(null);
 			    	setSelectedProperty(null);
 		    	}
 	    	} 
     }
 
     private synchronized void setAvailableDevices(String[] availableDevices) {
     	if (this.availableDevices == null && availableDevices == null) return;
     	String[] old = this.availableDevices;
     	
     	if (Arrays.equals(this.availableDevices, availableDevices)) return;
     	
     	this.availableDevices = availableDevices;
 
     	firePropertyChange("availableDevices", old, availableDevices);
 	    	if (this.availableDevices != null) {
 				for (String p: this.availableDevices) {
 		    		if (p.equals(selectedDevice)) {
 		    			performPropertyNameQuery(null);
 		    			return;
 		    		}
 		    	}
 				
 				if (!propertyPrecedence) {
 					setSelectedDevice(null);
 		    		setSelectedProperty(null);
 				} else {
 					performPropertyNameQuery(null);
 				}
 				
 				if (!propertyPrecedence && !devicePrecedence) {
 					performPropertyNameQuery(null);
 				}
 							
 				for (String p: this.availableDevices) {
 		    		if (p.equals(selectedDevice)) {
 		    			return;
 		    		}
 		    	}
 				if (this.availableDevices.length > 0) {
 			 		setSelectedDevice(this.availableDevices[0]);
 		    	} else {
 		    		setSelectedDevice(null);
 		    	}
 	    	}
     }
 
     @SuppressWarnings("unchecked")
 	private synchronized void setAvailableProperties(String[] availableProperties) {
     	if (this.availableProperties == null && availableProperties == null) return;
     	String[] old = this.availableProperties;
     	if (availableProperties != null) 
     		Arrays.sort(availableProperties, comparator);
     	if (Arrays.equals(this.availableProperties, availableProperties)) return;
     	this.availableProperties = availableProperties;
     	
     	firePropertyChange("availableSubsystems", old, availableSubsystems);
 	    	if (this.availableProperties != null) {
 	    		for (String p: this.availableProperties) {
 		    		if (p.equals(selectedProperty)) {
 		    			if (propertyPrecedence) {
 		    	    		performDeviceNameQuery(false);
 		    	    	} 
 		    			return;
 		    		}
 		    	}
 	    		if (this.availableProperties.length > 0) {
 			 		setSelectedProperty(this.availableProperties[0]);
 		    	} else {
 		    		setSelectedProperty(null);
 		    	}
 	    	}
     }
 
     @SuppressWarnings("unchecked")
 	private synchronized void setAvailableServers(String[] availableServers) {
     	if (this.availableServers == null && availableServers == null)return;
     	String[] old = this.availableServers;
     	if (availableServers != null)
     		Arrays.sort(availableServers, comparator);
     	if (Arrays.equals(this.availableServers, availableServers)) return;
     	
     	this.availableServers = availableServers;
     	propertyPrecedence = false;
         devicePrecedence = false;
     	firePropertyChange("availableServers", old, availableServers);
 	    	if (this.availableServers != null) {
 		    	for (String p: this.availableServers) {
 		    		if (p.equals(selectedServer)) {
 		    			performDeviceNameQuery(true);
 		    			return;
 		    		}
 		    	}
 		    	if (this.availableServers.length > 0) {
 		    		setSelectedServer(this.availableServers[0]);
 		    	} else {
 		    		setSelectedServer(null);
 		    		setSelectedDevice(null);
 			    	setSelectedProperty(null);
 		    	}
 		    	
 	    	}
     }  
     
     private String[] filterSubsystems(String[] subs) {
     	
     	ArrayList<String> availableSubsystemsTemp = new ArrayList<String>();
     	availableSubsystemsTemp.add("ALL");
     	for (String sub : subs) {
     		if (sub == null || sub.trim().length()==0 || "TEST".equals(sub)) continue;
     		availableSubsystemsTemp.add(sub);
     	}
     	availableSubsystemsTemp.add("TEST");
     	return availableSubsystemsTemp.toArray(new String[availableSubsystemsTemp.size()]);
     }
     
     /**
      * Returns all available subsystems loaded from the remote server.
      * 
      * @return available subsystems
      */
     public String[] getAvailableSubsystems() {
     	return availableSubsystems;
     }
     
     @SuppressWarnings("unchecked")
 	private synchronized void setAvailableSubsystems(String[] availableSubsystems) {
     	if (this.availableSubsystems == null && availableSubsystems == null) return;
     	String[] old = this.availableSubsystems;
     	if (availableSubsystems != null) 
     		Arrays.sort(availableSubsystems, comparator);
     	else 
     		availableSubsystems = new String[0];
     	//add default context
     	String[] availableSubsystemsTemp = filterSubsystems(availableSubsystems);
     	if (Arrays.equals(this.availableSubsystems, availableSubsystems)) return;    	
     	this.availableSubsystems = availableSubsystemsTemp;
     	firePropertyChange("availableSubsystems", old, availableSubsystems);
 	    	if (this.availableSubsystems != null) {
 		    	for (String p: this.availableSubsystems) {
 		    		if (p.equals(selectedSubSystem)) {
 		    			performServerQuery();
 		    			return;
 		    		}
 		    	}
 		    	if (this.availableSubsystems.length > 0) {
 		    		setSelectedSubSystem(this.availableSubsystems[0]);
 		    	} else {
 		    		setSelectedSubSystem(null);
 		    		setSelectedServer(null);
 			    	setSelectedDevice(null);
 			    	setSelectedProperty(null);
 		    	}
 		    	
 	    	} 
     }   
 
 	/**
 	 * Returns all available protocols.
 	 * 
      * @return the availableProtcols
      */
     public String[] getAvailableProtcols() {
     	return availableProtcols;
     }
     
     /**
      * Adds a QueryListener which receives notifications when query is started or 
      * finished.
      * 
      * @param l listener to be added
      */
     public void addQueryListener(QueryListener l) {
     	queryListeners.add(l);
     }
     
     /**
      * Removes a QueryListener.
      * 
      * @param l listener to be removed
      */
     public void removeQueryListener(QueryListener l) {
     	queryListeners.remove(l);
     }
     
     protected synchronized void fireQueryStarted(String process) {
     	queries++;
     	QueryEvent e = new QueryEvent(this, process);
     	QueryListener[] listeners = (QueryListener[]) queryListeners.toArray();
     	for (QueryListener lis : listeners) {
     		try {
     			lis.queryStarted(e);
     		} catch (Exception e1) {
     			handleException(e1);
     		}
     	}
     }
     
     protected synchronized void fireQueryFinished(String process) {
     	if (--queries>0) {
     		return;
     	}
     	if (queries < 0) queries = 0;
     	QueryEvent e = new QueryEvent(this, process);
     	QueryListener[] listeners = (QueryListener[]) queryListeners.toArray();
     	for (QueryListener lis : listeners) {
     		try {
     			lis.queryFinished(e);
     		} catch (Exception e1) {
     			handleException(e1);
     		}
     	}
     }
     
     /**
      * Returns the remote name constructed from the selected parameters.
      * @return the remote name
      */
     public String getRemoteName() {
     	return (selectedProtocol != null ? selectedProtocol : "") + "/" + 
     		    (selectedContext != null ? selectedContext : "") + "/" + 
     		    (selectedServer != null ? selectedServer : "") + "/" +
     		    (selectedDevice != null ? selectedDevice : "") + "/" +
     		    (selectedProperty != null ? selectedProperty : "");
     }
     
     void resetSelector() {
     	availableContexts = null;
     	availableServers = null;
     	availableDevices = null;
     	availableProperties = null;
     	selectedProtocol = null;
     	selectedContext = null;
     	selectedServer = null;
     	selectedDevice = null;
     	selectedProperty = null;
     }
 
 	/**
 	 * Returns a flag if stock properties should also be loaded at the same time
 	 * when properties are loaded.
 	 * 
      * @return the showStockProperties
      */
     public boolean isShowStockProperties() {
     	return showStockProperties;
     }
 
 	/**
 	 * Sets the stock properties flag. If true stock properties will be 
 	 * loaded together with normal properties.
 	 * 
      * @param showStockProperties the showStockProperties to set
      */
     public synchronized void setShowStockProperties(boolean showStockProperties) {
     	try {
 	    	if (this.showStockProperties == showStockProperties) return;
 	    	
 	    	fireQueryStarted("stockProperty");
 	    	this.showStockProperties = showStockProperties;
 	    	firePropertyChange("showStockProperties", !showStockProperties, showStockProperties);
 			performPropertyNameQuery(null);
 	    	
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		fireQueryFinished("stockProperty");
     	}
     }
 
 	/**
 	 * Returns the selected subsystem.
 	 * 
      * @return the selectedSubSystem
      */
     public String getSelectedSubSystem() {
     	return selectedSubSystem;
     }
 
 	/**
 	 * Selects the subsystem and initiates server query.
 	 * 
      * @param selectedSubSystem the selectedSubSystem to set
      */
     public synchronized void setSelectedSubSystem(String selectedSubSystem) {
     	try {
     		searchingSubsystem++;
 //	    	if ("".equals(selectedSubSystem) || selectedSubSystem == null) {
 //	    		selectedSubSystem="ALL";
 //	    	}
 	
 	    	if (!acceptProperty(this.selectedSubSystem, selectedSubSystem)) {
 	    		return;
 	    	}
 	    	fireQueryStarted("subSystem");
 	    	String old = this.selectedSubSystem;
 	    	this.selectedSubSystem = selectedSubSystem;
 	    	firePropertyChange("selectedSubSystem", old, selectedSubSystem);
 	    	if (selectedSubSystem != null)
 	    		performServerQuery();
 	    	else {
 	    		setSelectedServer(null);
 	    		setAvailableServers(null);
 	    		setSelectedDevice(null);
 	    		setAvailableDevices(null);
 	    		setSelectedProperty(null);
 	    		setAvailableProperties(null);
 	    	}
 	    		
     	} catch (Exception e) {
     		handleException(e);
     	} finally {
     		searchingSubsystem--;
     		fireQueryFinished("subSystem");
     	}
     }
     
     /**
      * Sets the access rate.
      * 
      * @param value new access rate in millis
      */
     public void setAccessRate(int value) {
     	int oldValue = accessRate;
     	this.accessRate = value;
     	firePropertyChange("accessRate", oldValue, this.accessRate);
     }
     
     /**
      * Returns the access rate.
      * 
      * @return the access rate
      */
     public int getAccessRate() {
     	return this.accessRate;
     }
     
     /**
      * Sets the access mode.
      * 
      * @param mode new access mode
      */
     public void setAccessMode(AccessMode mode) {
     	AccessMode oldValue = accessMode;
     	this.accessMode = mode;
     	firePropertyChange("accessMode", oldValue, this.accessMode);
     }
     
     /**
      * Returns selected access mode.
      * 
      * @return the access mode
      */
     public AccessMode getAccessMode() {
     	return this.accessMode;
     }
        
     
     /**
      * Adds an ExceptionListener which receives notifications of all exceptions
      * that occured while queries were performed.
      * 
      * @param l listener to be added
      */
     public void addExceptionListener(ExceptionListener l) {
     	exceptionListeners.add(l);
     }
     
     /**
      * Removes an ExceptionListener.
      * 
      * @param l listener to be removed
      */
     public void removeExceptionListener(ExceptionListener l) {
     	exceptionListeners.remove(l);
     }
     
     private void handleException(Throwable e) {
     	ExceptionEvent event = new ExceptionEvent(this, e);
     	ExceptionListener[] listeners = (ExceptionListener[]) exceptionListeners.toArray();
     	for (ExceptionListener lis : listeners) {
     		try {
     			lis.exceptionReceived(event);
     		} catch (Exception e1) {
     			handleException(e1);
     		}
     	}
     }
     
     
 	
 }
 
 
 /* __oOo__ */