import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public void removeTab(String tabText, int tabMapEntryType)
{
  TabItem tabItem = null;
	for (TabMapEntry tabMapEntry : getTabs()) {
		if (tabMapEntry.getObjectName().equals(tabText) && tabMapEntry.getObjectType()==tabMapEntryType) {
       tabItem = tabMapEntry.getTabItem();
			tabMap.remove(tabMapEntry);
			break;
		}
	}

	if(tabItem != null){
    if (!tabItem.isDisposed()){
      tabItem.dispose();
    }
	}

}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public EngineMetaInterface getActiveMeta()
{
	TabSet tabfolder = spoon.tabfolder;
	if (tabfolder == null)
		return null;
	TabItem tabItem = tabfolder.getSelected();
	if (tabItem == null)
		return null;

	// What transformation is in the active tab?
	// TransLog, TransGraph & TransHist contain the same transformation
	//
	TabMapEntry mapEntry = getTab(tabfolder.getSelected());
	EngineMetaInterface meta = null;
	if (mapEntry != null)
	{
		if (mapEntry.getObject() instanceof TransGraph)
			meta = (mapEntry.getObject()).getMeta();
		if (mapEntry.getObject() instanceof JobGraph)
			meta = (mapEntry.getObject()).getMeta();
	}

	return meta;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param transMeta
 *            the transformation to close, make sure it's ok to dispose of
 *            it BEFORE you call this.
 */
public void closeJob(JobMeta jobMeta)
{
	String tabName = spoon.delegates.tabs.makeJobGraphTabName(jobMeta);

	// Close the associated tabs...
	TabItem graphTab = spoon.delegates.tabs.findTabItem(tabName, TabMapEntry.OBJECT_TYPE_JOB_GRAPH);
	if (graphTab != null)
	{
		spoon.delegates.tabs.removeTab(graphTab);
	}

	// Also remove it from the item from the jobMap
	// Otherwise it keeps showing up in the objects tree
	// Look for the job, not the key (name might have changed)
	//
	List<String> keys = new ArrayList<String>(jobMap.keySet());
	for (String key : keys) {
		if (jobMap.get(key).equals(jobMeta)) {
			jobMap.remove(key);
		}
	}
	
	spoon.refreshTree();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param transMeta
 *            the transformation to close, make sure it's ok to dispose of
 *            it BEFORE you call this.
 */
public synchronized void closeTransformation(TransMeta transMeta)
{
	String tabName = spoon.delegates.tabs.makeTransGraphTabName(transMeta);

	// Close the associated tabs...
	TabItem graphTab = spoon.delegates.tabs.findTabItem(tabName,
			TabMapEntry.OBJECT_TYPE_TRANSFORMATION_GRAPH);
	if (graphTab != null)
	{
		spoon.delegates.tabs.removeTab(graphTab);
	}
	
	// Also remove it from the item from the transformationMap
	// Otherwise it keeps showing up in the objects tree
	// Look for the transformation, not the key (name might have changed)
	//
	List<String> keys = new ArrayList<String>(transformationMap.keySet());
	for (String key : keys) {
		if (transformationMap.get(key).equals(transMeta)) {
			transformationMap.remove(key);
		}
	}
	
	spoon.refreshTree();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public TabMapEntry findTabMapEntry(Object managedObject)
{
	for (TabMapEntry entry : tabMap)
	{
		if (entry.getTabItem().isDisposed()) {
			continue;
		}
		Object entryManagedObj = entry.getObject().getManagedObject();
		// make sure they are the same class before comparing them
		if (entryManagedObj != null && managedObject != null) {
 			if (entryManagedObj.getClass().equals(managedObject.getClass())) {
 			  if (entryManagedObj.equals(managedObject)) {
 			    return entry;
 			  }
 			}
		}
	}
	return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param transMeta
 *            the transformation to close, make sure it's ok to dispose of
 *            it BEFORE you call this.
 */
public void closeJob(JobMeta jobMeta)
{
	// Close the associated tabs...
	//
	TabMapEntry entry = spoon.delegates.tabs.findTabMapEntry(jobMeta);
	if (entry!=null) {
		spoon.delegates.tabs.removeTab(entry);
	}
	
	// Also remove it from the item from the jobMap
	// Otherwise it keeps showing up in the objects tree
	//
	int index = jobMap.indexOf(jobMeta);
	if (index>=0) {
		jobMap.remove(index);
	}
	
	spoon.refreshTree();
	spoon.enableMenus();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param transMeta
 *            the transformation to close, make sure it's ok to dispose of
 *            it BEFORE you call this.
 */
public synchronized void closeTransformation(TransMeta transMeta)
{
	// Close the associated tabs...
	//
	TabMapEntry entry = spoon.delegates.tabs.findTabMapEntry(transMeta);
	if (entry!=null) {
		spoon.delegates.tabs.removeTab(entry);
	}
	
	// Also remove it from the item from the transformationMap
	// Otherwise it keeps showing up in the objects tree
	// Look for the transformation, not the key (name might have changed)
	//
	int index = transformationMap.indexOf(transMeta);
	if (index>=0) {
		transformationMap.remove(index);
	}
	
	spoon.refreshTree();
	spoon.enableMenus();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public EngineMetaInterface getActiveMeta() {
  TabSet tabfolder = spoon.tabfolder;
  if ( tabfolder == null ) {
    return null;
  }
  TabItem tabItem = tabfolder.getSelected();
  if ( tabItem == null ) {
    return null;
  }

  // What transformation is in the active tab?
  // TransLog, TransGraph & TransHist contain the same transformation
  //
  TabMapEntry mapEntry = getTab( tabfolder.getSelected() );
  EngineMetaInterface meta = null;
  if ( mapEntry != null ) {
    if ( mapEntry.getObject() instanceof TransGraph ) {
      meta = ( mapEntry.getObject() ).getMeta();
    }
    if ( mapEntry.getObject() instanceof JobGraph ) {
      meta = ( mapEntry.getObject() ).getMeta();
    }
  }

  return meta;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public TabMapEntry findTabMapEntry( Object managedObject ) {
  for ( TabMapEntry entry : tabMap ) {
    if ( !entry.getTabItem().isDisposed() ) {
      Object entryManagedObj = entry.getObject().getManagedObject();
      // make sure they are the same class before comparing them
      if ( entryManagedObj != null && managedObject != null ) {
        if ( entryManagedObj.getClass().equals( managedObject.getClass() ) ) {
          if ( entryManagedObj.equals( managedObject ) ) {
            return entry;
          }
        }
      }
    }
  }
  return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public void tabSelected( TabItem item ) {
  // See which core objects to show
  //
  for ( TabMapEntry entry : tabMap ) {
    boolean isAbstractGraph = ( entry.getObject() instanceof AbstractGraph );
    if ( item.equals( entry.getTabItem() ) ) {
      if ( isAbstractGraph ) {
        EngineMetaInterface meta = entry.getObject().getMeta();
        if ( meta != null ) {
          meta.setInternalKettleVariables();
        }
        if ( spoon.getCoreObjectsState() != SpoonInterface.STATE_CORE_OBJECTS_SPOON ) {
          spoon.refreshCoreObjects();
        }
        ( (AbstractGraph) entry.getObject() ).setFocus();
      }
      break;
    }
  }

  // Also refresh the tree
  spoon.refreshTree();
  spoon.setShellText(); // calls also enableMenus() and markTabsChanged()
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param jobMeta
 *          the transformation to close, make sure it's ok to dispose of it BEFORE you call this.
 */
public void closeJob( JobMeta jobMeta ) {
  // Close the associated tabs...
  //
  TabMapEntry entry = getSpoon().delegates.tabs.findTabMapEntry( jobMeta );
  if ( entry != null ) {
    getSpoon().delegates.tabs.removeTab( entry );
  }

  // Also remove it from the item from the jobMap
  // Otherwise it keeps showing up in the objects tree
  //
  int index = getJobList().indexOf( jobMeta );
  while ( index >= 0 ) {
    getJobList().remove( index );
    index = getJobList().indexOf( jobMeta );
  }

  getSpoon().refreshTree();
  getSpoon().enableMenus();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
/**
 * @param transMeta
 *          the transformation to close, make sure it's ok to dispose of it BEFORE you call this.
 */
public synchronized void closeTransformation( TransMeta transMeta ) {
  // Close the associated tabs...
  //
  TabMapEntry entry = getSpoon().delegates.tabs.findTabMapEntry( transMeta );
  if ( entry != null ) {
    getSpoon().delegates.tabs.removeTab( entry );
  }

  // Also remove it from the item from the transformationMap
  // Otherwise it keeps showing up in the objects tree
  // Look for the transformation, not the key (name might have changed)
  //
  int index = getTransformationList().indexOf( transMeta );
  while ( index >= 0 ) {
    getTransformationList().remove( index );
    index = getTransformationList().indexOf( transMeta );
  }

  getSpoon().refreshTree();
  getSpoon().enableMenus();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
@Override
public void addTransGraph( TransMeta transMeta ) {
  super.addTransGraph( transMeta );
  TabMapEntry tabEntry = spoon.delegates.tabs.findTabMapEntry( transMeta );
  if ( tabEntry != null ) {
    TabItem tabItem = tabEntry.getTabItem();
    try {
      if ( ( service != null ) && ( transMeta.getObjectId() != null )
          && ( service.getTransformationLock( transMeta.getObjectId() ) != null ) ) {
        tabItem.setImage( GUIResource.getInstance().getImageLocked() );
      }
    } catch ( Exception e ) {
      throw new RuntimeException( e );
    }
  }
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
@Override
public void addJobGraph( JobMeta jobMeta ) {
  super.addJobGraph( jobMeta );
  TabMapEntry tabEntry = spoon.delegates.tabs.findTabMapEntry( jobMeta );
  if ( tabEntry != null ) {
    TabItem tabItem = tabEntry.getTabItem();
    try {
      if ( ( service != null ) && ( jobMeta.getObjectId() != null )
          && ( service.getJobLock( jobMeta.getObjectId() ) != null ) ) {
        tabItem.setImage( GUIResource.getInstance().getImageLocked() );
      }
    } catch ( Exception e ) {
      throw new RuntimeException( e );
    }
  }
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public TabMapEntry getTab(TabItem tabItem)
{
	for (TabMapEntry tabMapEntry : tabMap) {
		if (tabMapEntry.getTabItem().equals(tabItem)) {
			return tabMapEntry;
		}
	}
	return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public TabItem findTabItem(String tabItemText, int objectType)
{
	for (TabMapEntry entry : tabMap)
	{
		if (entry.getTabItem().isDisposed())
			continue;
		if (objectType == entry.getObjectType()
				&& entry.getTabItem().getText().equalsIgnoreCase(tabItemText))
		{
			return entry.getTabItem();
		}
	}
	return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public JobGraph findJobGraphOfJob(JobMeta jobMeta)
{
	// Now loop over the entries in the tab-map
	for (TabMapEntry mapEntry : spoon.delegates.tabs.getTabs())
	{
		if (mapEntry.getObject() instanceof JobGraph)
		{
			JobGraph jobGraph = (JobGraph) mapEntry.getObject();
			if (jobGraph.getMeta().equals(jobMeta))
				return jobGraph;
		}
	}
	return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public void tabSelected(TabItem item)
{
	List<TabMapEntry> collection = spoon.delegates.tabs.getTabs();

	// See which core objects to show
	//
	for (TabMapEntry entry : collection)
	{
		if (item.equals(entry.getTabItem()))
		{
			// TabItemInterface itemInterface = entry.getObject();

			//
			// Another way to implement this may be to keep track of the
			// state of the core object tree in method
			// addCoreObjectsToTree()
			//
			if (entry.getObject() instanceof TransGraph || entry.getObject() instanceof JobGraph)
			{
				EngineMetaInterface meta = entry.getObject().getMeta();
				if (meta != null)
				{
					meta.setInternalKettleVariables();
				}
				if (spoon.getCoreObjectsState() != SpoonInterface.STATE_CORE_OBJECTS_SPOON)
				{
					spoon.refreshCoreObjects();
				}
			}
		}
	}

	// Also refresh the tree
	spoon.refreshTree();
	spoon.enableMenus();
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public TransGraph findTransGraphOfTransformation(TransMeta transMeta)
{
	// Now loop over the entries in the tab-map
	for (TabMapEntry mapEntry : spoon.delegates.tabs.getTabs())
	{
		if (mapEntry.getObject() instanceof TransGraph)
		{
			TransGraph transGraph = (TransGraph) mapEntry.getObject();
			if (transGraph.getMeta().equals(transMeta))
				return transGraph;
		}
	}
	return null;
}
 

import org.pentaho.di.ui.spoon.TabMapEntry; //导入依赖的package包/类
public void removeTab(TabMapEntry tabMapEntry )
{
	for (TabMapEntry entry : getTabs()) {
		if (tabMapEntry.equals(entry)) {
			tabMap.remove(tabMapEntry);
		}
	}
	if (!tabMapEntry.getTabItem().isDisposed()){
	  tabMapEntry.getTabItem().dispose();
	}
}