Plugin Development

@PluginInfo(
    category = "MyCategory",
    description = "Description of what this plugin does",
    packageName = MyPluginPackage.NAME,
    shortDescription = "Short description",
    status = PluginStatus.RELEASED
)
public class MyPlugin extends Plugin {
    
    public MyPlugin(PluginTool tool) {
        super(tool);
        // Plugin initialization code
    }
    
    @Override
    protected void init() {
        // Additional initialization after dependencies are met
    }
}

public MyPlugin(PluginTool tool) {
    super(tool);
    // Base class constructor is called first
    // Services from @PluginInfo are added to dependency list
    // Publish services using registerServiceProvided()
    // Create actions (optional)
    // Register options (optional)
}

@Override
protected void init() {
    // Called when all dependencies are met
    // Retrieve service implementations via tool.getService(Class)
    // Create additional actions
    // Perform other initialization
}

@Override
public void readConfigState(SaveState saveState) {
    // Restore plugin configuration from tool state
}

@Override
public void writeConfigState(SaveState saveState) {
    // Save plugin configuration to tool state
}

@Override
protected void dispose() {
    // Free resources and perform cleanup
    // Services and events are de-registered automatically
}

@PluginInfo(
    servicesRequired = { ClipboardService.class, ProgramManager.class }
)
public class MyPlugin extends Plugin {
    private ClipboardService clipboardService;
    
    @Override
    protected void init() {
        // Retrieve services after dependencies are met
        clipboardService = tool.getService(ClipboardService.class);
    }
}

@PluginInfo(
    servicesProvided = { MyService.class }
)
public class MyPlugin extends Plugin implements MyService {
    // Service methods are automatically registered
    // Do NOT call registerServiceProvided() for directly implemented services
}

@PluginInfo(
    servicesProvided = { MyService.class }
)
public class MyPlugin extends Plugin {
    
    public MyPlugin(PluginTool tool) {
        super(tool);
        MyService serviceObj = new MyServiceImpl();
        registerServiceProvided(MyService.class, serviceObj);
    }
}

@PluginInfo(
    category = "BSim",
    description = "This plugin allows users to search selected functions against a database " +
        "of previously analyzed functions and returns a table of similar functions",
    packageName = BsimPluginPackage.NAME,
    shortDescription = "Search Bsim database(s) for similar functions",
    status = PluginStatus.RELEASED
)
public class BSimSearchPlugin extends ProgramPlugin {
    
    private BSimSearchService searchService;
    private BSimServerManager serverManager;
    
    public BSimSearchPlugin(PluginTool plugintool) {
        super(plugintool);
        searchService = new MyBSimSearchService();
        serverManager = BSimServerManager.getBSimServerManager();
    }
    
    @Override
    protected void init() {
        createActions();
    }
    
    private void createActions() {
        new ActionBuilder("BSim Search Functions", getName())
            .menuPath("BSim", "Search Functions...")
            .toolBarIcon(ICON)
            .enabledWhen(c -> currentProgram != null)
            .onAction(c -> showSearchDialog(getSelectedFunctions()))
            .buildAndInstall(tool);
    }
    
    @Override
    public void dispose() {
        closeAllProviders();
    }
}

private void createActions() {
    // Menu action
    new ActionBuilder("My Action", getName())
        .menuPath("Tools", "My Action")
        .menuGroup("MyGroup")
        .keyBinding("ctrl M")
        .helpLocation(new HelpLocation("MyPlugin", "MyAction"))
        .enabledWhen(c -> someCondition())
        .onAction(c -> performAction(c))
        .buildAndInstall(tool);
    
    // Toolbar action
    new ActionBuilder("Toolbar Action", getName())
        .toolBarIcon(Icons.MY_ICON)
        .toolBarGroup("View")
        .description("Action description")
        .onAction(c -> doSomething())
        .buildAndInstall(tool);
}

public class MyProvider extends ComponentProvider {
    private JComponent component;
    
    public MyProvider(PluginTool tool, String owner) {
        super(tool, "My Provider", owner);
        buildComponent();
    }
    
    private void buildComponent() {
        component = new JPanel();
        // Build UI
    }
    
    @Override
    public JComponent getComponent() {
        return component;
    }
}

@Override
protected void init() {
    ToolOptions options = tool.getOptions("MyPlugin");
    options.registerOption("My Option", true, null, 
        "Description of this option");
    
    boolean value = options.getBoolean("My Option", true);
}

public class MyPlugin extends Plugin implements OptionsChangeListener {
    
    @Override
    public void optionsChanged(ToolOptions options, String optionName, 
                               Object oldValue, Object newValue) {
        if (optionName.equals("My Option")) {
            // Handle option change
        }
    }
}

@Override
public void writeConfigState(SaveState saveState) {
    saveState.putString("lastFile", lastFile);
    saveState.putInt("windowWidth", width);
}

@Override
public void readConfigState(SaveState saveState) {
    lastFile = saveState.getString("lastFile", "");
    width = saveState.getInt("windowWidth", 800);
}

@Override
protected void programOpened(Program program) {
    // Handle new program being opened
}

@Override
protected void programClosed(Program program) {
    // Clean up resources for closed program
}

@Override
protected void programActivated(Program program) {
    // Update UI for newly activated program
}

private void performLongOperation() {
    Task task = new Task("My Operation", true, true, false) {
        @Override
        public void run(TaskMonitor monitor) {
            // Perform work with progress monitoring
            monitor.setMessage("Processing...");
            // ...
        }
    };
    tool.execute(task);
}