import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    logger.debug ( "createObservable - {}", target );

    if ( target instanceof IObservableList )
    {
        return Observables.proxyObservableList ( (IObservableList)target );
    }
    else if ( target instanceof KeyProviderFactory )
    {
        return Observables.proxyObservableList ( ( (KeyProviderFactory)target ).getKeyProviders () );
    }
    else if ( target instanceof KeyProvider )
    {
        return Observables.proxyObservableList ( ( (KeyProvider)target ).getKeys () );
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    logger.info ( "create observable: {}", target );

    if ( target instanceof ConnectionHolder )
    {
        return new RootFolderObserver ( (ConnectionHolder)target );
    }
    else if ( target instanceof FolderEntryWrapper )
    {
        final FolderEntry entry = AdapterHelper.adapt ( target, FolderEntry.class );
        if ( entry != null )
        {
            // only return a new observer if the folder entry is of type FolderEntry
            return new SubFolderObserver ( (FolderEntryWrapper)target );
        }
        else
        {
            return null;
        }
    }

    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target instanceof ConnectionHolder )
    {
        return new ConnectionWrapper ( (ConnectionHolder)target );
    }
    else if ( target instanceof ItemListWrapper )
    {
        return new ItemListObserver ( ( (ItemListWrapper)target ).getConnection () );
    }
    else if ( target instanceof QueryWrapper )
    {
        return ( (QueryWrapper)target ).getQueriesObservable ();
    }

    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target instanceof IObservableSet )
    {
        return (IObservable)target;
    }
    else if ( target instanceof TreeNode )
    {
        return ( (TreeNode)target ).createObservable ();
    }
    else
    {
        return null;
    }
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
/**
 * Status changed.
 *
 * @param status the status
 */
private void statusChanged(IStatus status)
{
	for (Iterator it = targets.iterator(); it.hasNext();)
	{
		IObservable observable = (IObservable) it.next();
		updater.updateBackground(findControl(observable), status);
	}
	for (Iterator it = targetDecorations.iterator(); it.hasNext();)
	{
		TargetDecoration targetDecoration = (TargetDecoration) it.next();
		ControlDecoration decoration = targetDecoration.decoration;
		updater.update(decoration, status);
		updater.updateBackground(findControl(targetDecoration.target), status);

	}
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public IObservable createObservable(final Object target)
{
	if (target instanceof IObservableList)
	{
		return (IObservable) target;
	} else if (target instanceof BTSProject)
	{
		return project_multi.observe(target);
	} else if (target instanceof BTSProjectDBCollection)
	{
		return coll_multi.observe(target);
	} else if (target instanceof BTSDBCollectionRoleDesc)
	{
		return roleMembers_multi.observe(target);
	}

	return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public void dispose(){
	if(this.cells != null){
		for(TreeCell cell : this.cells){
			if(cell != null){
				cell.dispose();
			}
		}
	}
	
	if(this.currentChildren != null){
		for(TreeRow row: this.currentChildren){
			if(row != null){
				row.dispose();
			}
		}
	}

	this.currentChildren = null;
	
	for(IObservable o : externalObservables.values()){
		o.dispose();
	}
	externalObservables.clear();
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target instanceof TreeNode )
    {
        return Observables.proxyObservableList ( ( (TreeNode)target ).getItems () );
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
/**
* @since 1.2
*/
  protected void processRemove ( final Object element )
  {
      final IObservable obs = this.observables.remove ( element );
      if ( obs != null )
      {
          obs.dispose ();
      }
      else
      {
          removeListenerFrom ( element );
      }
  }
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public void dispose ()
{
    for ( final IObservable obs : this.observables.values () )
    {
        obs.dispose ();
    }
    this.observables.clear ();
    super.dispose ();
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public IObservable createObservable ( final Object target )
{
    if ( target instanceof ConnectionHolder )
    {
        return new ConnectionWrapper ( (ConnectionHolder)target );
    }
    else if ( target instanceof FactoryInformationBean )
    {
        return Observables.proxyObservableSet ( ( (FactoryInformationBean)target ).getConfigurations () );
    }

    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target == Activator.ROOT )
    {
        return Observables.proxyObservableSet ( Activator.getDefault ().getTreeRoot () );
    }
    else if ( target instanceof TreeNode )
    {
        return new UnionSet ( new IObservableSet[] { ( (TreeNode)target ).getChildren (), ( (TreeNode)target ).getConnections () } );
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target == Activator.ROOT )
    {
        return Activator.getDefault ().createDiscovererSet ();
    }
    else if ( target instanceof ConnectionDiscovererBean )
    {
        final ConnectionDiscovererBean element = (ConnectionDiscovererBean)target;
        return element.getKnownConnections ();
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public IObservable createObservable ( final Object target )
{
    if ( target instanceof ConnectionHolder )
    {
        return new ConnectionWrapper ( (ConnectionHolder)target );
    }
    else if ( target instanceof QueryListWrapper )
    {
        return ( (QueryListWrapper)target ).getObservableQueries ();
    }

    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public IObservable createObservable ( final Object target )
{
    if ( target instanceof ConnectionHolder )
    {
        return new ConnectionWrapper ( (ConnectionHolder)target );
    }

    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
public IObservable createObservable ()
{
    if ( !this.subscribed )
    {
        subscribe ();
    }
    return Observables.proxyObservableSet ( this.groups );
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    if ( target instanceof ServerManager )
    {
        return Observables.proxyObservableSet ( ( (ServerManager)target ).getServers () );
    }
    else if ( target instanceof ServerDescriptor )
    {
        return Observables.proxyObservableSet ( ( (ServerDescriptor)target ).getEndpoints () );
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable ( final Object target )
{
    logger.debug ( "Getting observable for: {}", target );
    if ( target instanceof IObservableSet )
    {
        return Observables.proxyObservableSet ( (IObservableSet)target );
    }
    else if ( target instanceof Master )
    {
        return Observables.proxyObservableSet ( ( (Master)target ).getEntries () );
    }
    else if ( target instanceof ItemEntry )
    {
        final ItemEntry itemEntry = (ItemEntry)target;
        if ( itemEntry.getCustomizationRequest () != null && itemEntry.getCustomizationRequest ().getComponent () != null )
        {
            final WritableSet result = new WritableSet ();
            result.add ( new ClassInformationProvider ( itemEntry.getCustomizationRequest ().getComponent ().getClass () ) );
            return result;
        }
    }
    else if ( target instanceof ClassInformationProvider )
    {
        return ( (ClassInformationProvider)target ).createSuper ( null );
    }
    return null;
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
@Override
public IObservable createObservable(Object target, String path) {
	EObject eObject = (EObject) target;
	EClass eClass = eObject.eClass();
	EStructuralFeature feature = eClass.getEStructuralFeature(path);

	if (feature == null) {
		throw new IllegalArgumentException("Feature not found: eClass=" + eClass.getName() + ", name=" + path);
	}
	
	return EMFObservables.observeValue(eObject, feature);
}
 

import org.eclipse.core.databinding.observable.IObservable; //导入依赖的package包/类
private IObservable toObservable(Object dataContext, Binding binding) {
	WritableValue wv = new WritableValue();

	if (dataContext != null) {
		// this binding element has a path to the root data context
		wv.setValue(dataContext);
	}

	IObservable modelObservableValue = observe(wv, binding.getPath());
	return modelObservableValue;
}