private void createChoices() {
		choices = new ArrayList<>();
		programContextCB = new Choice("Program Context", false);
		programContextCB.addActionListener(e -> {
			applyProgramContext = programContextCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.PROGRAM_CONTEXT, applyProgramContext);
			applyFilterChanged();
		});
		choices.add(programContextCB);

		bytesCB = new Choice("Bytes", false);
		bytesCB.addActionListener(e -> {
			applyBytes = bytesCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.BYTES, applyBytes);
			applyFilterChanged();
		});
		choices.add(bytesCB);

		codeUnitsCB = new Choice("Code Units", false);
		codeUnitsCB.addActionListener(e -> {
			applyCodeUnits = codeUnitsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.CODE_UNITS | ProgramMergeFilter.EQUATES,
				applyCodeUnits);
			applyFilterChanged();
		});
		choices.add(codeUnitsCB);

		refsCB = new Choice("References", false);
		refsCB.addActionListener(e -> {
			applyReferences = refsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.REFERENCES, applyReferences);
			applyFilterChanged();
		});
		choices.add(refsCB);

		plateCommentsCB = new Choice("Comments, Plate", true);
		plateCommentsCB.addActionListener(e -> {
			applyPlateComments = plateCommentsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.PLATE_COMMENTS, applyPlateComments);
			applyFilterChanged();
		});
		choices.add(plateCommentsCB);

		preCommentsCB = new Choice("Comments, Pre", true);
		preCommentsCB.addActionListener(e -> {
			applyPreComments = preCommentsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.PRE_COMMENTS, applyPreComments);
			applyFilterChanged();
		});
		choices.add(preCommentsCB);

		eolCommentsCB = new Choice("Comments, EOL", true);
		eolCommentsCB.addActionListener(e -> {
			applyEolComments = eolCommentsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.EOL_COMMENTS, applyEolComments);
			applyFilterChanged();
		});
		choices.add(eolCommentsCB);

		repeatableCommentsCB = new Choice("Comments, Repeatable", true);
		repeatableCommentsCB.addActionListener(e -> {
			applyRepeatableComments = repeatableCommentsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.REPEATABLE_COMMENTS, applyRepeatableComments);
			applyFilterChanged();
		});
		choices.add(repeatableCommentsCB);

		postCommentsCB = new Choice("Comments, Post", true);
		postCommentsCB.addActionListener(e -> {
			applyPostComments = postCommentsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.POST_COMMENTS, applyPostComments);
			applyFilterChanged();
		});
		choices.add(postCommentsCB);

		symbolsCB = new SymbolsChoice();
		symbolsCB.addActionListener(e -> {
			SYMBOL_MERGE_CHOICE symbols =
				SYMBOL_MERGE_CHOICE.values()[symbolsCB.getSelectedIndex()];
			MERGE_CHOICE merge =
				plugin.applySettingsMgr.convertSymbolMergeChoiceToMergeChoice(symbols);
			REPLACE_CHOICE primary =
				plugin.applySettingsMgr.convertSymbolMergeChoiceToReplaceChoiceForPrimay(symbols);
			applySymbols = merge.ordinal();
			replacePrimary = primary.ordinal();
			applyFilter.setFilter(ProgramMergeFilter.SYMBOLS, applySymbols);
			applyFilter.setFilter(ProgramMergeFilter.PRIMARY_SYMBOL, replacePrimary);
			applyFilterChanged();
		});
		choices.add(symbolsCB);

		bookmarksCB = new Choice("Bookmarks", false);
		bookmarksCB.addActionListener(e -> {
			applyBookmarks = bookmarksCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.BOOKMARKS, applyBookmarks);
			applyFilterChanged();
		});
		choices.add(bookmarksCB);

		propertiesCB = new Choice("Properties", false);
		propertiesCB.addActionListener(e -> {
			applyProperties = propertiesCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.PROPERTIES, applyProperties);
			applyFilterChanged();
		});
		choices.add(propertiesCB);

		functionsCB = new Choice("Functions", false);
		functionsCB.addActionListener(e -> {
			applyFunctions = functionsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.FUNCTIONS, applyFunctions);
			applyFilterChanged();
		});
		choices.add(functionsCB);

		functionTagsCB = new Choice("Function Tags", true);
		functionTagsCB.addActionListener(e -> {
			applyFunctionTags = functionTagsCB.getSelectedIndex();
			applyFilter.setFilter(ProgramMergeFilter.FUNCTION_TAGS, applyFunctionTags);
			applyFilterChanged();
		});
		choices.add(functionTagsCB);

		sourceMapCB = new Choice("Source Map", false);
		if (!plugin.getFirstProgram().hasExclusiveAccess()) {
			sourceMapCB.setSelectedIndex(ProgramMergeFilter.IGNORE);
		}
		sourceMapCB.addActionListener(e -> {
			applySourceMap = sourceMapCB.getSelectedIndex();
			if (!plugin.getFirstProgram().hasExclusiveAccess()) {
				if (applySourceMap != ProgramMergeFilter.IGNORE) {
					Msg.showWarn(this, null, "Exclusive Access Required",
						"Exclusive access required to change source map information");
					sourceMapCB.setSelectedIndex(ProgramMergeFilter.IGNORE);
					applySourceMap = ProgramMergeFilter.IGNORE;
				}
			}
			applyFilter.setFilter(ProgramMergeFilter.SOURCE_MAP, applySourceMap);
			applyFilterChanged();
		});
		choices.add(sourceMapCB);

		int maxLabelWidth = 0;
		int maxComboWidth = 0;
		for (Choice choice : choices) {
			maxLabelWidth = Math.max(maxLabelWidth, choice.label.getPreferredSize().width);
			maxComboWidth = Math.max(maxComboWidth, choice.applyCB.getPreferredSize().width);
		}
		for (Choice choice : choices) {
			int height = choice.label.getPreferredSize().height;
			choice.label.setPreferredSize(new Dimension(maxLabelWidth, height));
			height = choice.applyCB.getPreferredSize().height;
			choice.applyCB.setPreferredSize(new Dimension(maxComboWidth, height));
		}
		Collections.sort(choices);
	}
Create a panel for the user choices to indicate the filter settings.
Ghidra/Features/ProgramDiff/src/main/java/ghidra/app/plugin/core/diff/DiffApplySettingsProvider.java