import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public static void ensurePanelVisible(CyServiceRegistrar registrar, CytoPanelComponent panel)
{
	CytoPanel cytoPanel = registrar.getService(CySwingApplication.class).getCytoPanel(panel.getCytoPanelName());
	if(cytoPanel.getState() == CytoPanelState.HIDE)
	{
		cytoPanel.setState(CytoPanelState.DOCK);
	}
	
	SwingUtilities.invokeLater(() -> {
		int index = cytoPanel.indexOfComponent(panel.getComponent());
		if(index >= 0)
		{
			cytoPanel.setSelectedIndex(index);;
		}
		
	});
	
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public void showPanel() {
    synchronized (panelMutex) {
        if (cytoPanelComponent == null) {
            getPanel();
            setNetworkView(applicationManager.getCurrentNetworkView());
        }

        if (!panelVisible) {
            registrar.registerService(cytoPanelComponent, CytoPanelComponent.class, new Properties());
            panelVisible = true;
        }

        CytoPanel panel = application.getCytoPanel(cytoPanelComponent.getCytoPanelName());
        int index = panel.indexOfComponent(cytoPanelComponent.getIdentifier());

        if (panel.getState() == CytoPanelState.HIDE) {
            panel.setState(CytoPanelState.DOCK);
        }

        if (index != -1) {
            panel.setSelectedIndex(index);
        }
    }
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public synchronized void hide() {
	if(showing) {
		registrar.unregisterService(mainPanel, CytoPanelComponent.class);
		mainPanel.dispose();
		mainPanel = null;
		
		registrar.unregisterService(optionsPanel, CytoPanelComponent.class);
		optionsPanel.dispose();
		optionsPanel = null;
		
		// clear all annotations
		ModelManager modelManager = modelManagerProvider.get();
		modelManager.deselectAll();
		
		if(showHideAction != null)
			showHideAction.setName(showName);
		
		showing = false;
	}
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public synchronized void show() {
	if(!showing) {
		ModelManager modelManager = modelManagerProvider.get();
		Optional<NetworkViewSet> networkViewSet = modelManager.getActiveNetworkViewSet();
		Optional<AnnotationSet> annotationSet = networkViewSet.flatMap(NetworkViewSet::getActiveAnnotationSet);
		
		mainPanel = mainPanelProvider.get();
		registrar.registerService(mainPanel, CytoPanelComponent.class, new Properties());
		mainPanel.setNetworkViewSet(networkViewSet);
		
		optionsPanel = optionsPanelProvider.get();
		registrar.registerService(optionsPanel, CytoPanelComponent.class, new Properties());
		optionsPanel.setAnnotationSet(annotationSet);
		
		if(showHideAction != null)
			showHideAction.setName(hideName);
		
		showing = true;
	}
	
	bringToFront(mainPanel);
	bringToFront(optionsPanel);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
	CyApplicationManager manager = getService(context, CyApplicationManager.class);
	CySwingAppAdapter adapter = getService(context, CySwingAppAdapter.class);
	CySwingApplication desktopApp = adapter.getCySwingApplication();
       OpenBrowser openBrowser = getService(context,OpenBrowser.class);
       CyEventHelper eventHelper = getService(context, CyEventHelper.class);
       CyNetworkFactory networkFactory = getService(context, CyNetworkFactory.class);
       CyNetworkManager networkManager = getService(context, CyNetworkManager.class);
       CyNetworkViewFactory networkViewFactory = getService(context, CyNetworkViewFactory.class);
       CyNetworkViewManager networkViewManager = getService(context, CyNetworkViewManager.class);
       VisualMappingManager visualMappingManager = getService(context,VisualMappingManager.class);

	Properties properties = new Properties();

	SlimPanel slimPanel = new SlimPanel(manager, adapter, openBrowser, eventHelper, networkFactory, networkManager,
               networkViewFactory, networkViewManager, visualMappingManager);
	registerService(context, slimPanel, CytoPanelComponent.class, properties);

	SlimscapePluginAction slimscapePluginAction = new SlimscapePluginAction(manager, adapter, desktopApp, slimPanel);
	registerService(context, slimscapePluginAction, CyAction.class, properties);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void run(TaskMonitor arg0) throws Exception {
	// TODO Auto-generated method stub
	synchronized (this) {
		MyControlPanel mainPanel = null;
		
		// First we must make sure that the app is not already open
		if (!isOpen()) {
			mainPanel = new MyControlPanel(swingApplication, registrar, appManager);

			registrar.registerService(mainPanel, CytoPanelComponent.class, new Properties());
		} else {
			mainPanel = getMainPanel();
		}

		if (mainPanel != null) {
			CytoPanel cytoPanel = swingApplication.getCytoPanel(CytoPanelName.WEST);;
			int index = cytoPanel.indexOfComponent(mainPanel);
			cytoPanel.setSelectedIndex(index);
		}
	}
	
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public void hidePanel() {
    synchronized (panelMutex) {
        if (!panelVisible) {
            return;
        }
        registrar.unregisterService(cytoPanelComponent, CytoPanelComponent.class);
        panelVisible = false;
    }
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
private void bringToFront(CytoPanelComponent panel) {
	CytoPanelName compassPoint = panel.getCytoPanelName();
	Component component = panel.getComponent();
	CytoPanel cytoPanel = swingApplication.getCytoPanel(compassPoint);
	cytoPanel.setState(CytoPanelState.DOCK);
	int index = cytoPanel.indexOfComponent(component);
	cytoPanel.setSelectedIndex(index);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void run(TaskMonitor arg0) throws Exception {
	// TODO Auto-generated method stub
	MyControlPanel mainPanel = getMainPanel();
	if (mainPanel != null) {
		registrar.unregisterService(mainPanel, CytoPanelComponent.class);
	}
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
	CyApplicationManager cyApplicationManager = getService(context, CyApplicationManager.class);
	CyNetworkViewFactory networkViewFactory = getService(context, CyNetworkViewFactory.class);
	CyNetworkFactory networkFactory = getService(context, CyNetworkFactory.class);
	CyNetworkManager networkManager = getService(context, CyNetworkManager.class);
	DialogTaskManager dialogTaskManager = getService(context, DialogTaskManager.class);
	VisualMappingManager vmmServiceRef = getService(context,VisualMappingManager.class);
	VisualStyleFactory visualStyleFactoryServiceRef = getService(context,VisualStyleFactory.class);
	VisualMappingFunctionFactory vmfFactoryC = getService(context,VisualMappingFunctionFactory.class, "(mapping.type=continuous)");
	VisualMappingFunctionFactory vmfFactoryD = getService(context,VisualMappingFunctionFactory.class, "(mapping.type=discrete)");
	VisualMappingFunctionFactory vmfFactoryP = getService(context,VisualMappingFunctionFactory.class, "(mapping.type=passthrough)");
	CyLayoutAlgorithmManager cyAlgorithmManager = getService(context, CyLayoutAlgorithmManager.class);
	CyNetworkViewManager cyNetworkViewManager = getService(context, CyNetworkViewManager.class);
	CySwingApplication cySwingApplication = getService(context, CySwingApplication.class);
	OpenBrowser openBrowser = getService(context, OpenBrowser.class);
					
	Plugin plugin = new Plugin(networkFactory, networkManager, dialogTaskManager, networkViewFactory, vmmServiceRef, visualStyleFactoryServiceRef,
			vmfFactoryC, vmfFactoryD, vmfFactoryP, cyAlgorithmManager, cyApplicationManager, cyNetworkViewManager, cySwingApplication);
	registerService(context, plugin, NetworkDestroyedListener.class, new Properties());
	
	// CyTargetLinker implements two actions: extend network and help
	ExtensionAction extAction = new ExtensionAction("Extend network", plugin);
	registerAllServices(context, extAction, new Properties());
	
	HelpAction helpAction = new HelpAction("Help", openBrowser);
	registerAllServices(context, helpAction, new Properties());
	
	// property stores last used RegIN directory
	CyTargetLinkerProperty property = new CyTargetLinkerProperty();
	CyProperty<Properties> prop = property.checkCyProperties(getService(context, CySessionManager.class));
	registerService(context, prop, CyProperty.class, new Properties());
	
	// registers the panel for CyTargetLinker
	CyTargetLinkerPanel panel = new CyTargetLinkerPanel(plugin);
	registerService(context, panel, CytoPanelComponent.class, new Properties());
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public static void addPanel(CytoPanelComponent panel) {
    serviceRegistrar.registerService(panel, CytoPanelComponent.class, new Properties());
    selectPanel(panel);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public static void removePanel(CytoPanelComponent panel) {
    serviceRegistrar.unregisterService(panel, CytoPanelComponent.class);
    getEastPanel().setState(CytoPanelState.HIDE);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
public static void selectPanel(CytoPanelComponent panel) {
    int panelIndex = getEastPanel().indexOfComponent(panel.getComponent());
    getEastPanel().setSelectedIndex(panelIndex);
    getEastPanel().setState(CytoPanelState.DOCK);
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void start(BundleContext bc) throws Exception {
	
	CySwingApplication cytoscapeDesktopService = getService(bc,CySwingApplication.class);

	// register visualization related managers to Cytoscape
	// network creation
	CyNetworkManager cyNetworkManagerServiceRef = getService(bc,CyNetworkManager.class);
	CyNetworkNaming cyNetworkNamingServiceRef = getService(bc,CyNetworkNaming.class);
	CyNetworkFactory cyNetworkFactoryServiceRef = getService(bc,CyNetworkFactory.class);
	
	// progress dialog
	DialogTaskManager dialogTaskManager = getService(bc, DialogTaskManager.class);
	
	// view creation
	CyNetworkViewFactory networkViewFactory = getService(bc, CyNetworkViewFactory.class);
	CyNetworkViewManager networkViewManager = getService(bc, CyNetworkViewManager.class);
 
	// visual style manager
	VisualMappingManager vmmServiceRef = getService(bc,VisualMappingManager.class);
	VisualStyleFactory vsfServiceRef = getService(bc,VisualStyleFactory.class);

	// visual mapping functions
	VisualMappingFunctionFactory vmfFactoryC = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=continuous)");
	VisualMappingFunctionFactory vmfFactoryD = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=discrete)");
	VisualMappingFunctionFactory vmfFactoryP = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=passthrough)");

	// layout manager
	CyLayoutAlgorithmManager clamRef = getService(bc, CyLayoutAlgorithmManager.class);
	
	// main control panel added to the left of Cytoscape panel
	kddnConfigurePanel = new KddnConfigurePanel(cyNetworkManagerServiceRef,
			cyNetworkNamingServiceRef,cyNetworkFactoryServiceRef,
			dialogTaskManager, networkViewFactory, networkViewManager,
			vmmServiceRef, vsfServiceRef, vmfFactoryC,
			vmfFactoryD, vmfFactoryP, clamRef);
	registerService(bc,kddnConfigurePanel,CytoPanelComponent.class, new Properties());
	
	// results panel added to the right of Cytoscape panel
	kddnResultsPanel = new KddnResultsPanel(cytoscapeDesktopService);
	registerService(bc, kddnResultsPanel, CytoPanelComponent.class, new Properties());
	
	// menu items
	CyApplicationManager cyApplicationManager = getService(bc, CyApplicationManager.class);
	
	KddnMenuAction runMenu = new KddnMenuAction(cyApplicationManager, "Run analysis", cytoscapeDesktopService, kddnConfigurePanel);
	registerAllServices(bc, runMenu, new Properties());

	KddnMenuAction helpMenu = new KddnMenuAction(cyApplicationManager, "Help", cytoscapeDesktopService, kddnConfigurePanel);
	registerAllServices(bc, helpMenu, new Properties());
	
	KddnMenuAction aboutMenu = new KddnMenuAction(cyApplicationManager, "About", cytoscapeDesktopService, kddnConfigurePanel);
	registerAllServices(bc, aboutMenu, new Properties());
	
	// help doc
	cyHelpBroker = getService(bc, CyHelpBroker.class);

	final String HELP_SET_NAME = "/help/jhelpset";
	final ClassLoader classLoader = getClass().getClassLoader();
	URL helpSetURL;
	try {
		helpSetURL = HelpSet.findHelpSet(classLoader, HELP_SET_NAME);
		final HelpSet newHelpSet = new HelpSet(classLoader, helpSetURL);
		cyHelpBroker.getHelpSet().add(newHelpSet);
	} catch (final Exception e) {
		System.err.println("Could not find help set: \"" + HELP_SET_NAME + ".");
	}
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
/**
 * Upon bundle activation (install or startup).
 */
public void start(BundleContext bc) {
    // Manager services.
    //CySwingApplication desktopManager = getService(bc, CySwingApplication.class);
    
    // Basic access to current and/or currently selected networks, 
    // views and rendering engines in an instance of Cytoscape.
    CyApplicationManager applicationManager = getService(bc, CyApplicationManager.class);
    
    // Access to all root networks
    CyRootNetworkManager rootNetworkManager = getService(bc, CyRootNetworkManager.class);
    
    // Access to all networks
    CyNetworkManager networkManager = getService(bc, CyNetworkManager.class);
    
    // This object manages mapping from view model to VisualStyle. 
    // User objects can access all VisualStyles and VisualMappingFunctions through this class.
    VisualMappingManager visualMappingManager = getService(bc, VisualMappingManager.class);
    
    // The CyGroupManager maintains information about all of the groups an instance of Cytoscape.
    CyGroupManager groupManager = getService(bc, CyGroupManager.class);
    
    // An interface describing a factory used for creating CyGroup objects.
    CyGroupFactory groupFactory = getService(bc, CyGroupFactory.class);
    
    TaskManager taskManager = getService(bc, TaskManager.class);
    
    // Action, the group viewer
    ViewerAction viewerAction =
            new ViewerAction(applicationManager,
                             visualMappingManager,
                             groupManager,
                             groupFactory);
    
    // Action, the group selector
    /*GroupsFromColumnsAction groupsAction =
            new GroupsFromColumnsAction(applicationManager,
                                        groupManager,
                                        groupFactory);*/
    
    // The eXamine control panel
    ControlPanel controlPanel = new ControlPanel(networkManager, rootNetworkManager, 
    		applicationManager, groupManager, groupFactory, taskManager);

    // Register it as a service.
    registerService(bc, viewerAction, CyAction.class, new Properties());
    //registerService(bc, groupsAction, CyAction.class, new Properties());
    registerService(bc, controlPanel, CytoPanelComponent.class, new Properties());
    registerService(bc, controlPanel, SetCurrentNetworkListener.class, new Properties());
    registerService(bc, controlPanel, RowsSetListener.class, new Properties());
    registerService(bc, controlPanel, ColumnNameChangedListener.class, new Properties());
    registerService(bc, controlPanel, ColumnDeletedListener.class, new Properties());
    registerService(bc, controlPanel, ColumnCreatedListener.class, new Properties());
    registerService(bc, controlPanel, NetworkDestroyedListener.class, new Properties());
    registerService(bc, controlPanel, SessionLoadedListener.class, new Properties());
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void run(TaskMonitor taskMonitor) throws Exception {
	
	SmoothingPreviewPanel panel = new SmoothingPreviewPanel(registrar, timeSeries.getSelectedValue());

	registrar.registerService(panel, CytoPanelComponent.class, new Properties());
	
	UIUtils.ensurePanelVisible(registrar, panel);		
}
 

import org.cytoscape.application.swing.CytoPanelComponent; //导入依赖的package包/类
@Override
public void start(BundleContext bc) throws Exception {
	
	CyApplicationManager cyApplicationManager = getService(bc,CyApplicationManager.class);

	CyServiceRegistrar serviceRegistrar = getService(bc, CyServiceRegistrar.class);		

	DataSeriesMappingManagerImpl mappingManager = new DataSeriesMappingManagerImpl(bc);
	registerAllServices(bc, mappingManager, new Properties());

	DataSeriesManagerImpl dataSeriesManager = new DataSeriesManagerImpl(bc, mappingManager);
	registerAllServices(bc, dataSeriesManager, new Properties());

	DataSeriesStorageManager storageManager = new DataSeriesStorageManagerImpl(bc, serviceRegistrar.getService(CyNetworkManager.class), dataSeriesManager, mappingManager);
	registerAllServices(bc, storageManager, new Properties());

	registerService(bc, new TimeSeriesStorageProviderImpl(), DataSeriesStorageProvider.class, new Properties());
	registerService(bc, new NamedDoubleDataSeriesStorageProviderImpl(), DataSeriesStorageProvider.class, new Properties());

	SmoothingService smoothingService = new SmoothingServiceImpl(); 
	registerService(bc, smoothingService, SmoothingService.class, new Properties());
	
	registerService(bc, new TabularFileImportParametersGUIHandlerFactory(), GUITunableHandlerFactory.class, new Properties());
	registerService(bc, new SoftFileImportParametersGUIHandlerFactory(), GUITunableHandlerFactory.class, new Properties());
	
	registerService(bc, new TimeSeriesImportProviderImpl(), DataSeriesImportProvider.class, new Properties());
	registerService(bc, new NamedDoubleDataSeriesImportProviderImpl(), DataSeriesImportProvider.class, new Properties());

	registerService(bc, new DataSeriesFactoryImpl(), DataSeriesFactory.class, new Properties());

	registerService(bc, new MappingManipulationServiceImpl(serviceRegistrar), MappingManipulationService.class, new Properties());
	
	DataSeriesImportManager importManager = new DataSeriesImportManagerImpl(bc);
	registerService(bc, importManager, DataSeriesImportManager.class, new Properties());
	
	
	ImportDataSeriesTaskFactory importTaskFactory = new ImportDataSeriesTaskFactory(serviceRegistrar);
	registerMenuItem(bc, "File.Import.Data Series", "From tabular file (.csv,.tsv, etc.) ...", importTaskFactory);
	ImportSoftFileTaskFactory importSoftTaskFactory = new ImportSoftFileTaskFactory(serviceRegistrar);
	registerMenuItem(bc, "File.Import.Data Series", "From SOFT file...", importSoftTaskFactory);

	registerMenuItem(bc, "File.Export", "Data Series...", new ExportDataSeriesTaskFactory(dataSeriesManager, storageManager));

	registerMenuItem(bc, "Remove Data Series", new RemoveDataSeriesTaskFactory(dataSeriesManager));

	MapColumnTaskFactory mapColumnTaskFactory = new MapColumnTaskFactory(serviceRegistrar);
	//registerMenuItem(bc, "Map Column to Series", mapColumnTaskFactory);

	//registerMenuItem(bc, "Remove Column Mapping", new RemoveColumnMappingTaskFactory(mappingManager));

	registerMenuItem(bc, "Manage Column Mappings", new ManageMappingsTaskFactory(serviceRegistrar));

	registerMenuItem(bc, DEFAULT_MENU + ".Advanced smoothing", "Linear kernel", new SmoothDataSeriesTaskFactory(serviceRegistrar));

	registerMenuItem(bc, "Exponentiate Data Series", new ExponentiateDataSeriesTaskFactory(dataSeriesManager));
	
	SmoothInteractiveShowUITaskFactory smoothInteractiveTaskFactory = new SmoothInteractiveShowUITaskFactory(serviceRegistrar);
	registerMenuItem(bc, "Interactive smoothing", smoothInteractiveTaskFactory);
	
	DataSeriesPanel panel = new DataSeriesPanel(serviceRegistrar);
	registerService(bc, panel, CytoPanelComponent.class, new Properties());
	registerService(bc, panel, DataSeriesListener.class, new Properties());
	
	DataSeriesVisualPanel visualPanel = new DataSeriesVisualPanel(cyApplicationManager, dataSeriesManager, mappingManager);
	registerService(bc, visualPanel, CytoPanelComponent.class, new Properties());
	registerService(bc, visualPanel, RowsSetListener.class, new Properties());
	registerService(bc, visualPanel, DataSeriesListener.class, new Properties());
	registerService(bc, visualPanel, DataSeriesMappingListener.class, new Properties());
	
	registerService(bc, new DataSeriesPublicTasksImpl(importTaskFactory, importSoftTaskFactory, mapColumnTaskFactory, smoothInteractiveTaskFactory), DataSeriesPublicTasks.class, new Properties());
}