| /******************************************************************************* |
| * Copyright (c) 2012, 2020 Original authors and others. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Original authors and others - initial API and implementation |
| * Dirk Fauth <dirk.fauth@googlemail.com> - changed key for NatEventData and added column group menu items |
| * Thanh Liem PHAN (ALL4TEC) <thanhliem.phan@all4tec.net> - Bug 509361 |
| ******************************************************************************/ |
| package org.eclipse.nebula.widgets.nattable.ui.menu; |
| |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.nebula.widgets.nattable.Messages; |
| import org.eclipse.nebula.widgets.nattable.NatTable; |
| import org.eclipse.nebula.widgets.nattable.columnCategories.ChooseColumnsFromCategoriesCommand; |
| import org.eclipse.nebula.widgets.nattable.columnChooser.command.DisplayColumnChooserCommand; |
| import org.eclipse.nebula.widgets.nattable.columnRename.DisplayColumnRenameDialogCommand; |
| import org.eclipse.nebula.widgets.nattable.export.ExportConfigAttributes; |
| import org.eclipse.nebula.widgets.nattable.export.command.ExportTableCommand; |
| import org.eclipse.nebula.widgets.nattable.export.command.ExportTableCommandHandler; |
| import org.eclipse.nebula.widgets.nattable.export.image.ImageExporter; |
| import org.eclipse.nebula.widgets.nattable.filterrow.command.ClearAllFiltersCommand; |
| import org.eclipse.nebula.widgets.nattable.filterrow.command.ToggleFilterRowCommand; |
| import org.eclipse.nebula.widgets.nattable.freeze.command.FreezeColumnCommand; |
| import org.eclipse.nebula.widgets.nattable.freeze.command.FreezePositionCommand; |
| import org.eclipse.nebula.widgets.nattable.freeze.command.FreezeRowCommand; |
| import org.eclipse.nebula.widgets.nattable.freeze.command.UnFreezeGridCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.CreateColumnGroupCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.CreateRowGroupCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.DisplayColumnGroupRenameDialogCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.DisplayRowGroupRenameDialogCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.OpenCreateColumnGroupDialog; |
| import org.eclipse.nebula.widgets.nattable.group.command.RemoveColumnGroupCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.RemoveRowGroupCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.UngroupColumnCommand; |
| import org.eclipse.nebula.widgets.nattable.group.command.UngroupRowCommand; |
| import org.eclipse.nebula.widgets.nattable.group.performance.gui.HeaderGroupNameDialog; |
| import org.eclipse.nebula.widgets.nattable.group.performance.gui.HeaderGroupNameDialog.HeaderGroupNameDialogLabels; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.ColumnHideCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.ColumnShowCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.RowHideCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.RowPositionHideCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.RowShowCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.ShowAllColumnsCommand; |
| import org.eclipse.nebula.widgets.nattable.hideshow.command.ShowAllRowsCommand; |
| import org.eclipse.nebula.widgets.nattable.layer.ILayer; |
| import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommand; |
| import org.eclipse.nebula.widgets.nattable.resize.command.InitializeAutoResizeColumnsCommand; |
| import org.eclipse.nebula.widgets.nattable.resize.command.InitializeAutoResizeRowsCommand; |
| import org.eclipse.nebula.widgets.nattable.style.editor.command.DisplayColumnStyleEditorCommand; |
| import org.eclipse.nebula.widgets.nattable.ui.NatEventData; |
| import org.eclipse.nebula.widgets.nattable.util.GCFactory; |
| import org.eclipse.nebula.widgets.nattable.util.GUIHelper; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.MessageBox; |
| import org.eclipse.swt.widgets.Widget; |
| |
| /** |
| * Helper class that provides several {@link IMenuItemProvider} for menu items |
| * that can be used within a popup menu in the NatTable to execute NatTable |
| * specific actions. |
| */ |
| public final class MenuItemProviders { |
| |
| private MenuItemProviders() { |
| // private default constructor for helper class |
| } |
| |
| /** |
| * Key that is used to put the NatEventData into the data of a menu. |
| */ |
| public static final String NAT_EVENT_DATA_KEY = "natEventData"; //$NON-NLS-1$ |
| |
| /** |
| * Walk up the MenuItems (in case they are nested) and find the parent |
| * {@link Menu} |
| * |
| * @param selectionEvent |
| * on the {@link MenuItem} |
| * @return data associated with the parent {@link Menu} |
| */ |
| public static NatEventData getNatEventData(SelectionEvent selectionEvent) { |
| Widget widget = selectionEvent.widget; |
| if (!(widget instanceof MenuItem)) { |
| return null; |
| } |
| |
| MenuItem menuItem = (MenuItem) widget; |
| Menu parentMenu = menuItem.getParent(); |
| Object data = null; |
| while (parentMenu != null) { |
| if (parentMenu.getData(NAT_EVENT_DATA_KEY) == null) { |
| parentMenu = parentMenu.getParentMenu(); |
| } else { |
| data = parentMenu.getData(NAT_EVENT_DATA_KEY); |
| break; |
| } |
| } |
| |
| return data != null ? (NatEventData) data : null; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ColumnHideCommand} to a popup menu. This command |
| * is intended to hide the current selected column immediately. |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ColumnHideCommand}. The {@link MenuItem} will |
| * be shown with the localized default text configured in NatTable |
| * core. |
| */ |
| public static IMenuItemProvider hideColumnMenuItemProvider() { |
| return hideColumnMenuItemProvider("%MenuItemProviders.hideColumn"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ColumnHideCommand} to a popup menu. This command |
| * is intended to hide the current selected column immediately. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ColumnHideCommand}. |
| */ |
| public static IMenuItemProvider hideColumnMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(GUIHelper.getDisplayImage("hide_column")); //$NON-NLS-1$ |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand(new ColumnHideCommand(natTable, columnPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllColumnsCommand} to a popup menu. This |
| * command is intended to show all columns of the NatTable and is used to |
| * unhide previous hidden columns. |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllColumnsCommand}. The {@link MenuItem} |
| * will be shown with the localized default text configured in |
| * NatTable core. |
| */ |
| public static IMenuItemProvider showAllColumnsMenuItemProvider() { |
| return showAllColumnsMenuItemProvider("%MenuItemProviders.showAllColumns"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllColumnsCommand} to a popup menu. This |
| * command is intended to show all columns of the NatTable and is used to |
| * unhide previous hidden columns. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllColumnsCommand}. |
| */ |
| public static IMenuItemProvider showAllColumnsMenuItemProvider(final String menuLabel) { |
| return showAllColumnsMenuItemProvider(menuLabel, GUIHelper.getDisplayImage("show_column")); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllColumnsCommand} to a popup menu. This |
| * command is intended to show all columns of the NatTable and is used to |
| * unhide previous hidden columns. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label and the |
| * given image. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @param image |
| * The image that will be showed with the generated |
| * {@link MenuItem}. Can be <code>null</code> to not showing an |
| * image. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllColumnsCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showAllColumnsMenuItemProvider(final String menuLabel, final Image image) { |
| return (natTable, popupMenu) -> { |
| MenuItem showAllColumns = new MenuItem(popupMenu, SWT.PUSH); |
| showAllColumns.setText(Messages.getLocalizedMessage(menuLabel)); |
| showAllColumns.setImage(image); |
| showAllColumns.setEnabled(true); |
| |
| showAllColumns.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new ShowAllColumnsCommand()); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ColumnShowCommand} to a popup menu. This command |
| * is intended to show the column(s) at the clicked position of the NatTable |
| * and is used to unhide previous hidden columns. |
| * |
| * @param showAll |
| * Whether all hidden adjacent columns should be shown again or |
| * only the single direct adjacent column. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ColumnShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showColumnMenuItemProvider(final boolean showAll) { |
| return showColumnMenuItemProvider(showAll, "%MenuItemProviders.showColumns"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ColumnShowCommand} to a popup menu. This command |
| * is intended to show the column(s) at the clicked position of the NatTable |
| * and is used to unhide previous hidden columns. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param showAll |
| * Whether all hidden adjacent columns should be shown again or |
| * only the single direct adjacent column. |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ColumnShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showColumnMenuItemProvider(final boolean showAll, final String menuLabel) { |
| return showColumnMenuItemProvider(showAll, menuLabel, GUIHelper.getDisplayImage("show_column")); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ColumnShowCommand} to a popup menu. This command |
| * is intended to show the column(s) at the clicked position of the NatTable |
| * and is used to unhide previous hidden columns. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label and the |
| * given image. |
| * |
| * @param showAll |
| * Whether all hidden adjacent columns should be shown again or |
| * only the single direct adjacent column. |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @param image |
| * The image that will be showed with the generated |
| * {@link MenuItem}. Can be <code>null</code> to not showing an |
| * image. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ColumnShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showColumnMenuItemProvider(final boolean showAll, final String menuLabel, final Image image) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(image); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| int diffToCellStart = eventData.getOriginalEvent().x |
| - natTable.getStartXOfColumnPosition(columnPosition); |
| int diffToCellEnd = natTable.getStartXOfColumnPosition(columnPosition) |
| + natTable.getColumnWidthByPosition(columnPosition) |
| - eventData.getOriginalEvent().x; |
| natTable.doCommand( |
| new ColumnShowCommand(natTable, columnPosition, diffToCellStart < diffToCellEnd, showAll)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowHideCommand} to a popup menu. This command is |
| * intended to hide the current selected row immediately. |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowHideCommand}. The {@link MenuItem} will be |
| * shown with the localized default text configured in NatTable |
| * core. |
| */ |
| public static IMenuItemProvider hideRowMenuItemProvider() { |
| return hideRowMenuItemProvider("%MenuItemProviders.hideRow"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowHideCommand} to a popup menu. This command is |
| * intended to hide the current selected row immediately. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowHideCommand}. |
| */ |
| public static IMenuItemProvider hideRowMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(GUIHelper.getDisplayImage("hide_row")); //$NON-NLS-1$ |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| natTable.doCommand(new RowHideCommand(natTable, rowPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowPositionHideCommand} to a popup menu. This |
| * command is intended to hide the current selected row immediately. |
| * <p> |
| * With the additional column position information this command is intended |
| * to be used with the HierarchicalTreeLayer to support hiding of multiple |
| * rows on a spanned level header column. |
| * </p> |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowPositionHideCommand}. The {@link MenuItem} |
| * will be shown with the localized default text configured in |
| * NatTable core. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider hideRowPositionMenuItemProvider() { |
| return hideRowPositionMenuItemProvider("%MenuItemProviders.hideRow"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowPositionHideCommand} to a popup menu. This |
| * command is intended to hide the current selected row immediately. |
| * <p> |
| * With the additional column position information this command is intended |
| * to be used with the HierarchicalTreeLayer to support hiding of multiple |
| * rows on a spanned level header column. |
| * </p> |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowPositionHideCommand}. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider hideRowPositionMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(GUIHelper.getDisplayImage("hide_row")); //$NON-NLS-1$ |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand(new RowPositionHideCommand(natTable, columnPosition, rowPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllRowsCommand} to a popup menu. This |
| * command is intended to show all rows of the NatTable and is used to |
| * unhide previous hidden rows. |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllRowsCommand}. The {@link MenuItem} |
| * will be shown with the localized default text configured in |
| * NatTable core. |
| */ |
| public static IMenuItemProvider showAllRowsMenuItemProvider() { |
| return showAllRowsMenuItemProvider("%MenuItemProviders.showAllRows"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllRowsCommand} to a popup menu. This |
| * command is intended to show all rows of the NatTable and is used to |
| * unhide previous hidden rows. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllRowsCommand}. |
| */ |
| public static IMenuItemProvider showAllRowsMenuItemProvider(final String menuLabel) { |
| return showAllRowsMenuItemProvider(menuLabel, GUIHelper.getDisplayImage("show_row")); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ShowAllRowsCommand} to a popup menu. This |
| * command is intended to show all rows of the NatTable and is used to |
| * unhide previous hidden rows. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label and given |
| * image. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @param image |
| * The image that will be showed with the generated |
| * {@link MenuItem}. Can be <code>null</code> to not showing an |
| * image. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ShowAllRowsCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showAllRowsMenuItemProvider(final String menuLabel, final Image image) { |
| return (natTable, popupMenu) -> { |
| MenuItem showAllRows = new MenuItem(popupMenu, SWT.PUSH); |
| showAllRows.setText(Messages.getLocalizedMessage(menuLabel)); |
| showAllRows.setImage(image); |
| showAllRows.setEnabled(true); |
| |
| showAllRows.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new ShowAllRowsCommand()); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowShowCommand} to a popup menu. This command is |
| * intended to show the row(s) at the clicked position of the NatTable and |
| * is used to unhide previous hidden rows. |
| * |
| * @param showAll |
| * Whether all hidden adjacent rows should be shown again or only |
| * the single direct adjacent row. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showRowMenuItemProvider(final boolean showAll) { |
| return showRowMenuItemProvider(showAll, "%MenuItemProviders.showRow"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowShowCommand} to a popup menu. This command is |
| * intended to show the row(s) at the clicked position of the NatTable and |
| * is used to unhide previous hidden rows. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param showAll |
| * Whether all hidden adjacent rows should be shown again or only |
| * the single direct adjacent row. |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showRowMenuItemProvider(final boolean showAll, final String menuLabel) { |
| return showRowMenuItemProvider(showAll, menuLabel, GUIHelper.getDisplayImage("show_row")); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link RowShowCommand} to a popup menu. This command is |
| * intended to show the row(s) at the clicked position of the NatTable and |
| * is used to unhide previous hidden rows. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label and given |
| * image. |
| * |
| * @param showAll |
| * Whether all hidden adjacent rows should be shown again or only |
| * the single direct adjacent row. |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @param image |
| * The image that will be showed with the generated |
| * {@link MenuItem}. Can be <code>null</code> to not showing an |
| * image. |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link RowShowCommand}. |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider showRowMenuItemProvider(final boolean showAll, final String menuLabel, final Image image) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(image); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| int diffToCellStart = eventData.getOriginalEvent().y |
| - natTable.getStartYOfRowPosition(rowPosition); |
| int diffToCellEnd = natTable.getStartYOfRowPosition(rowPosition) |
| + natTable.getRowHeightByPosition(rowPosition) |
| - eventData.getOriginalEvent().y; |
| natTable.doCommand( |
| new RowShowCommand(natTable, rowPosition, diffToCellStart < diffToCellEnd, showAll)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider autoResizeColumnMenuItemProvider() { |
| return autoResizeColumnMenuItemProvider("%MenuItemProviders.autoResizeColumn"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider autoResizeColumnMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem autoResizeColumns = new MenuItem(popupMenu, SWT.PUSH); |
| autoResizeColumns.setText(Messages.getLocalizedMessage(menuLabel)); |
| autoResizeColumns.setImage(GUIHelper.getDisplayImage("auto_resize")); //$NON-NLS-1$ |
| autoResizeColumns.setEnabled(true); |
| |
| autoResizeColumns.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand( |
| new InitializeAutoResizeColumnsCommand( |
| natTable, |
| columnPosition, |
| natTable.getConfigRegistry(), |
| new GCFactory(natTable))); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider autoResizeRowMenuItemProvider() { |
| return autoResizeRowMenuItemProvider("%MenuItemProviders.autoResizeRow"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider autoResizeRowMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem autoResizeRows = new MenuItem(popupMenu, SWT.PUSH); |
| autoResizeRows.setText(Messages.getLocalizedMessage(menuLabel)); |
| autoResizeRows.setImage(GUIHelper.getDisplayImage("auto_resize_row")); //$NON-NLS-1$ |
| autoResizeRows.setEnabled(true); |
| |
| autoResizeRows.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| natTable.doCommand( |
| new InitializeAutoResizeRowsCommand( |
| natTable, |
| rowPosition, |
| natTable.getConfigRegistry(), |
| new GCFactory(natTable))); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider autoResizeAllSelectedColumnMenuItemProvider() { |
| return autoResizeAllSelectedColumnMenuItemProvider("%MenuItemProviders.autoResizeAllSelectedColumns"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider autoResizeAllSelectedColumnMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem autoResizeColumns = new MenuItem(popupMenu, SWT.PUSH); |
| autoResizeColumns.setText(Messages.getLocalizedMessage(menuLabel)); |
| autoResizeColumns.setEnabled(true); |
| |
| autoResizeColumns.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand( |
| new InitializeAutoResizeColumnsCommand( |
| natTable, |
| columnPosition, |
| natTable.getConfigRegistry(), |
| new GCFactory(natTable))); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider columnChooserMenuItemProvider() { |
| return columnChooserMenuItemProvider("%MenuItemProviders.chooseColumns"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider columnChooserMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnChooser = new MenuItem(popupMenu, SWT.PUSH); |
| columnChooser.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnChooser.setImage(GUIHelper.getDisplayImage("column_chooser")); //$NON-NLS-1$ |
| columnChooser.setEnabled(true); |
| |
| columnChooser.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand( |
| new DisplayColumnChooserCommand(natTable)); |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider columnStyleEditorMenuItemProvider() { |
| return columnStyleEditorMenuItemProvider("%MenuItemProviders.editStyles"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider columnStyleEditorMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnStyleEditor = new MenuItem(popupMenu, SWT.PUSH); |
| columnStyleEditor.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnStyleEditor.setImage(GUIHelper.getDisplayImage("preferences")); //$NON-NLS-1$ |
| columnStyleEditor.setEnabled(true); |
| |
| columnStyleEditor.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand( |
| new DisplayColumnStyleEditorCommand( |
| natTable, |
| natTable.getConfigRegistry(), |
| columnPosition, |
| rowPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider renameColumnMenuItemProvider() { |
| return renameColumnMenuItemProvider("%MenuItemProviders.renameColumn"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider renameColumnMenuItemProvider(final String label) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(label)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| natTable.doCommand( |
| new DisplayColumnRenameDialogCommand( |
| natTable, |
| eventData.getColumnPosition())); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider createColumnGroupMenuItemProvider() { |
| return createColumnGroupMenuItemProvider("%MenuItemProviders.createColumnGroup"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider createColumnGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnStyleEditor = new MenuItem(popupMenu, SWT.PUSH); |
| columnStyleEditor.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnStyleEditor.setEnabled(true); |
| |
| columnStyleEditor.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand( |
| new OpenCreateColumnGroupDialog(natTable.getShell())); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to create a |
| * column group with the new performance ColumnGroupHeaderLayer. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider createPerformanceColumnGroupMenuItemProvider() { |
| return createPerformanceColumnGroupMenuItemProvider("%MenuItemProviders.createColumnGroup"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to create a |
| * column group with the new performance ColumnGroupHeaderLayer. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider createPerformanceColumnGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem createColumnGroup = new MenuItem(popupMenu, SWT.PUSH); |
| createColumnGroup.setText(Messages.getLocalizedMessage(menuLabel)); |
| createColumnGroup.setEnabled(true); |
| |
| createColumnGroup.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| HeaderGroupNameDialog dialog = |
| new HeaderGroupNameDialog(natTable.getShell(), HeaderGroupNameDialogLabels.CREATE_COLUMN_GROUP); |
| int result = dialog.open(); |
| if (result == IDialogConstants.OK_ID) { |
| natTable.doCommand(new CreateColumnGroupCommand(dialog.getGroupName())); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider ungroupColumnsMenuItemProvider() { |
| return ungroupColumnsMenuItemProvider("%MenuItemProviders.ungroupColumns"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider ungroupColumnsMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnStyleEditor = new MenuItem(popupMenu, SWT.PUSH); |
| columnStyleEditor.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnStyleEditor.setEnabled(true); |
| |
| columnStyleEditor.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new UngroupColumnCommand()); |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider inspectLabelsMenuItemProvider() { |
| return (natTable, popupMenu) -> { |
| MenuItem inspectLabelsMenuItem = new MenuItem(popupMenu, SWT.PUSH); |
| inspectLabelsMenuItem.setText(Messages.getString("MenuItemProviders.debugInfo")); //$NON-NLS-1$ |
| inspectLabelsMenuItem.setEnabled(true); |
| |
| inspectLabelsMenuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| NatTable natTable = eventData.getNatTable(); |
| int columnPosition = eventData.getColumnPosition(); |
| int rowPosition = eventData.getRowPosition(); |
| |
| String msg = "Display mode: " + natTable.getDisplayModeByPosition(columnPosition, rowPosition) + "\nConfig labels: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + natTable.getConfigLabelsByPosition(columnPosition, rowPosition) |
| + "\nData value: " //$NON-NLS-1$ |
| + natTable.getDataValueByPosition(columnPosition, rowPosition) |
| + "\n\nColumn position: " + columnPosition + "\nColumn index: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + natTable.getColumnIndexByPosition(columnPosition) |
| + "\n\nRow position: " + rowPosition + "\nRow index: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + natTable.getRowIndexByPosition(rowPosition); |
| |
| MessageBox messageBox = |
| new MessageBox(natTable.getShell(), SWT.ICON_INFORMATION | SWT.OK); |
| messageBox.setText(Messages.getString("MenuItemProviders.debugInformation")); //$NON-NLS-1$ |
| messageBox.setMessage(msg); |
| messageBox.open(); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider categoriesBasedColumnChooserMenuItemProvider() { |
| return categoriesBasedColumnChooserMenuItemProvider("%MenuItemProviders.columnCategoriesChooser"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider categoriesBasedColumnChooserMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnChooser = new MenuItem(popupMenu, SWT.PUSH); |
| columnChooser.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnChooser.setImage(GUIHelper.getDisplayImage("column_categories_chooser")); //$NON-NLS-1$ |
| columnChooser.setEnabled(true); |
| |
| columnChooser.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand( |
| new ChooseColumnsFromCategoriesCommand(natTable)); |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider clearAllFiltersMenuItemProvider() { |
| return clearAllFiltersMenuItemProvider("%MenuItemProviders.clearAllFilters"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider clearAllFiltersMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(GUIHelper.getDisplayImage("remove_filter")); //$NON-NLS-1$ |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new ClearAllFiltersCommand()); |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider clearToggleFilterRowMenuItemProvider() { |
| return clearToggleFilterRowMenuItemProvider("%MenuItemProviders.toggleFilterRow"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider clearToggleFilterRowMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setImage(GUIHelper.getDisplayImage("toggle_filter")); //$NON-NLS-1$ |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new ToggleFilterRowCommand()); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link DisplayPersistenceDialogCommand} to a popup |
| * menu. This command is intended to open the DisplayPersistenceDialog for |
| * managing NatTable states (also called view management). |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link DisplayPersistenceDialogCommand} The |
| * {@link MenuItem} will be shown with the localized default text |
| * configured in NatTable core. |
| */ |
| public static IMenuItemProvider stateManagerMenuItemProvider() { |
| return stateManagerMenuItemProvider("%MenuItemProviders.stateManager"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link DisplayPersistenceDialogCommand} to a popup |
| * menu. This command is intended to open the DisplayPersistenceDialog for |
| * managing NatTable states (also called view management). |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link DisplayPersistenceDialogCommand} The |
| * {@link MenuItem} will be shown with the localized default text |
| * configured in NatTable core. |
| */ |
| public static IMenuItemProvider stateManagerMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem saveState = new MenuItem(popupMenu, SWT.PUSH); |
| saveState.setText(Messages.getLocalizedMessage(menuLabel)); |
| saveState.setImage(GUIHelper.getDisplayImage("table_icon")); //$NON-NLS-1$ |
| saveState.setEnabled(true); |
| |
| saveState.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand( |
| new DisplayPersistenceDialogCommand(natTable)); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * @return An {@link IMenuItemProvider} for adding a separator to the popup |
| * menu. |
| */ |
| public static IMenuItemProvider separatorMenuItemProvider() { |
| return (natTable, popupMenu) -> new MenuItem(popupMenu, SWT.SEPARATOR); |
| } |
| |
| public static IMenuItemProvider renameColumnGroupMenuItemProvider() { |
| return renameColumnGroupMenuItemProvider("%ColumnGroups.renameColumnGroup"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider renameColumnGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnStyleEditor = new MenuItem(popupMenu, SWT.PUSH); |
| columnStyleEditor.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnStyleEditor.setEnabled(true); |
| |
| columnStyleEditor.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand( |
| new DisplayColumnGroupRenameDialogCommand(natTable, columnPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| public static IMenuItemProvider removeColumnGroupMenuItemProvider() { |
| return removeColumnGroupMenuItemProvider("%ColumnGroups.removeColumnGroup"); //$NON-NLS-1$ |
| } |
| |
| public static IMenuItemProvider removeColumnGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem columnStyleEditor = new MenuItem(popupMenu, SWT.PUSH); |
| columnStyleEditor.setText(Messages.getLocalizedMessage(menuLabel)); |
| columnStyleEditor.setEnabled(true); |
| |
| columnStyleEditor.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| int columnIndex = eventData.getNatTable().getColumnIndexByPosition(columnPosition); |
| natTable.doCommand(new RemoveColumnGroupCommand(columnIndex)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ExportTableCommand} to a popup menu. This |
| * command is intended to to export the NatTable to image. |
| * |
| * <p> |
| * <b>IMPORTANT:</b> the {@link ImageExporter} needs to be configured for |
| * the configuration attribute {@link ExportConfigAttributes#TABLE_EXPORTER} |
| * to really export to an image. Also the {@link ExportTableCommandHandler} |
| * needs to be registered on an {@link ILayer} in the layer stack, e.g. the |
| * GridLayer. |
| * </p> |
| * |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ExportTableCommand}. The {@link MenuItem} |
| * will be shown with the localized default text configured in |
| * NatTable core. |
| * @since 1.5 |
| */ |
| public static IMenuItemProvider exportToImageMenuItemProvider() { |
| return exportToImageMenuItemProvider("%MenuItemProviders.exportToImage"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Will create and return the {@link IMenuItemProvider} that adds the action |
| * for executing the {@link ExportTableCommand} to a popup menu. This |
| * command is intended to export the NatTable to image. |
| * <p> |
| * The {@link MenuItem} will be shown with the given menu label. |
| * </p> |
| * <p> |
| * <b>IMPORTANT:</b> the {@link ImageExporter} needs to be configured for |
| * the configuration attribute {@link ExportConfigAttributes#TABLE_EXPORTER} |
| * to really export to an image. Also the {@link ExportTableCommandHandler} |
| * needs to be registered on an {@link ILayer} in the layer stack, e.g. the |
| * GridLayer. |
| * </p> |
| * |
| * @param menuLabel |
| * The text that will be showed for the generated |
| * {@link MenuItem} |
| * @return The {@link IMenuItemProvider} for the {@link MenuItem} that |
| * executes the {@link ExportTableCommand}. |
| * @since 1.5 |
| */ |
| public static IMenuItemProvider exportToImageMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem exportToImage = new MenuItem(popupMenu, SWT.PUSH); |
| exportToImage.setText(Messages.getLocalizedMessage(menuLabel)); |
| exportToImage.setImage(GUIHelper.getDisplayImage("export_image")); //$NON-NLS-1$ |
| exportToImage.setEnabled(true); |
| |
| exportToImage.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new ExportTableCommand(natTable.getConfigRegistry(), natTable.getShell())); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to create a |
| * row group with the new performance RowGroupHeaderLayer. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider createRowGroupMenuItemProvider() { |
| return createRowGroupMenuItemProvider("%MenuItemProviders.createRowGroup"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to create a |
| * row group with the new performance RowGroupHeaderLayer. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider createRowGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem createRowGroup = new MenuItem(popupMenu, SWT.PUSH); |
| createRowGroup.setText(Messages.getLocalizedMessage(menuLabel)); |
| createRowGroup.setEnabled(true); |
| |
| createRowGroup.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| HeaderGroupNameDialog dialog = |
| new HeaderGroupNameDialog(natTable.getShell(), HeaderGroupNameDialogLabels.CREATE_ROW_GROUP); |
| int result = dialog.open(); |
| if (result == IDialogConstants.OK_ID) { |
| natTable.doCommand(new CreateRowGroupCommand(dialog.getGroupName())); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to ungroup |
| * selected rows from an existing row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider ungroupRowsMenuItemProvider() { |
| return ungroupRowsMenuItemProvider("%MenuItemProviders.ungroupRows"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to ungroup |
| * selected rows from an existing row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider ungroupRowsMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem ungroupRow = new MenuItem(popupMenu, SWT.PUSH); |
| ungroupRow.setText(Messages.getLocalizedMessage(menuLabel)); |
| ungroupRow.setEnabled(true); |
| |
| ungroupRow.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new UngroupRowCommand()); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item for renaming |
| * a row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider renameRowGroupMenuItemProvider() { |
| return renameRowGroupMenuItemProvider("%RowGroups.renameRowGroup"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item for renaming |
| * a row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider renameRowGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem renameRowGroup = new MenuItem(popupMenu, SWT.PUSH); |
| renameRowGroup.setText(Messages.getLocalizedMessage(menuLabel)); |
| renameRowGroup.setEnabled(true); |
| |
| renameRowGroup.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| natTable.doCommand(new DisplayRowGroupRenameDialogCommand(natTable, rowPosition)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to remove a |
| * row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider removeRowGroupMenuItemProvider() { |
| return removeRowGroupMenuItemProvider("%RowGroups.removeRowGroup"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to remove a |
| * row group. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider removeRowGroupMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| int rowIndex = eventData.getNatTable().getRowIndexByPosition(rowPosition); |
| natTable.doCommand(new RemoveRowGroupCommand(rowIndex)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * column. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezeColumnMenuItemProvider() { |
| return freezeColumnMenuItemProvider("%MenuItemProviders.freezeColumn"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * column. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezeColumnMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| natTable.doCommand(new FreezeColumnCommand(natTable, columnPosition, false, true)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * row. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezeRowMenuItemProvider() { |
| return freezeRowMenuItemProvider("%MenuItemProviders.freezeRow"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * row. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezeRowMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int rowPosition = eventData.getRowPosition(); |
| natTable.doCommand(new FreezeRowCommand(natTable, rowPosition, false, true)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * cell position. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezePositionMenuItemProvider(boolean include) { |
| return freezePositionMenuItemProvider("%MenuItemProviders.freezePosition", include); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @param include |
| * whether the selected cell should be included in the freeze |
| * region or not. Include means the freeze borders will be to the |
| * right and bottom, while exclude means the freeze borders are |
| * to the left and top. |
| * @return The {@link IMenuItemProvider} for adding a menu item to freeze a |
| * cell position. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider freezePositionMenuItemProvider(final String menuLabel, final boolean include) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| NatEventData eventData = getNatEventData(event); |
| if (eventData != null) { |
| int columnPosition = eventData.getColumnPosition(); |
| int rowPosition = eventData.getRowPosition(); |
| natTable.doCommand( |
| new FreezePositionCommand(natTable, columnPosition, rowPosition, false, true, include)); |
| } |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * |
| * @return The {@link IMenuItemProvider} for adding a menu item to remove a |
| * frozen state. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider unfreezeMenuItemProvider() { |
| return unfreezeMenuItemProvider("%MenuItemProviders.unfreeze"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * |
| * @param menuLabel |
| * The label to be used for showing the menu item. |
| * @return The {@link IMenuItemProvider} for adding a menu item to remove a |
| * frozen state. |
| * |
| * @since 1.6 |
| */ |
| public static IMenuItemProvider unfreezeMenuItemProvider(final String menuLabel) { |
| return (natTable, popupMenu) -> { |
| MenuItem menuItem = new MenuItem(popupMenu, SWT.PUSH); |
| menuItem.setText(Messages.getLocalizedMessage(menuLabel)); |
| menuItem.setEnabled(true); |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| natTable.doCommand(new UnFreezeGridCommand()); |
| } |
| }); |
| }; |
| } |
| |
| } |
