@deephaven/iris-grid 0.15.1-beta.4 → 0.15.2-beta.6

package/dist/mousehandlers/IrisGridContextMenuHandler.js

@@ -7,7 +7,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 /* eslint class-methods-use-this: "off" */
 import React from 'react';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
-import { dhFilterFilled, vsRemove, vsCheck, vsFilter, vsReply } from '@deephaven/icons';
+import { dhFilterFilled, vsRemove, vsCheck, vsFilter } from '@deephaven/icons';
 import debounce from 'lodash.debounce';
 import { ContextActions, ContextActionUtils, GLOBAL_SHORTCUTS } from '@deephaven/components';
 import { GridMouseHandler, isEditableGridModel } from '@deephaven/grid';
@@ -27,33 +27,41 @@ var CONTEXT_MENU_DATE_FORMAT = 'yyyy-MM-dd HH:mm:ss.SSSSSSSSS';
 
 class IrisGridContextMenuHandler extends GridMouseHandler {
   /**
-   * Get filter condition for quick filter with existed column filter and the new filter to be applied,
-   * returns new filter if filters are not additive.
-   * if filters are additive, returns filter conditions combined with 'and'.
+   * Get filter condition for quick filter and combines with a new filter using the operator specified,
+   * returns new filter if no operator supplied.
    * @param columnFilter
    * @param newColumnFilter
-   * @param additive
+   * @param operator
    */
-  static getQuickFilterCondition(columnFilter, newColumnFilter) {
-    var additive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  static getQuickFilterCondition(columnFilter, newColumnFilter, operator) {
+    if (columnFilter && operator === '&&') {
+      return columnFilter.and(newColumnFilter);
+    }
 
-    if (!additive || !columnFilter) {
-      return newColumnFilter;
+    if (columnFilter && operator === '||') {
+      return columnFilter.or(newColumnFilter);
     }
 
-    return columnFilter.and(newColumnFilter);
+    return newColumnFilter;
   }
   /**
-   * combines filter text with '&&' if filters are additive
+   * combines filter text with operator if declared
    * @param filterText
    * @param newFilterText
-   * @param additive
+   * @param operator
+   */
+
+
+  static getQuickFilterText(filterText, newFilterText, operator) {
+    return operator && filterText ? "".concat(filterText, " ").concat(operator, " ").concat(newFilterText) : newFilterText;
+  }
+  /**
+   * Converts operator to text string,
    */
 
 
-  static getQuickFilterText(filterText, newFilterText) {
-    var additive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    return additive && filterText ? "".concat(filterText, " && ").concat(newFilterText) : newFilterText;
+  static getOperatorAsText(operator) {
+    return operator === '&&' ? 'And' : 'Or';
   }
   /**
    * Gets an equality filter for the provided numeric value
@@ -196,7 +204,7 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
       action: () => {
         this.irisGrid.clearAllFilters();
       },
-      disabled: !(quickFilters.size > 0 || advancedFilters.size > 0 || searchFilter !== null)
+      disabled: !(quickFilters.size > 0 || advancedFilters.size > 0 || searchFilter != null)
     });
     actions.push({
       title: 'Sort by',
@@ -319,133 +327,121 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
       showTimeZone: settings === null || settings === void 0 ? void 0 : settings.showTimeZone,
       showTSeparator: settings === null || settings === void 0 ? void 0 : settings.showTSeparator,
       defaultDateTimeFormatString: CONTEXT_MENU_DATE_FORMAT
-    }); // grid data area context menu options
-
-    if (column != null && rowIndex != null) {
-      if (model.isFilterable(modelColumn)) {
-        // cell data area contextmenu options
-        var filterMenu = {
-          title: 'Filter By Value',
-          icon: vsRemove,
-          iconColor: filterIconColor,
-          group: IrisGridContextMenuHandler.GROUP_FILTER,
-          order: 10,
-          actions: []
-        };
-        var andFilterMenu = {
-          title: 'Add Filter By Value',
-          icon: vsRemove,
-          iconColor: filterIconColor,
-          group: IrisGridContextMenuHandler.GROUP_FILTER,
-          order: 20,
-          actions: [],
-          disabled: !quickFilters.get(modelColumn)
-        };
-        var gotoRow = {
-          title: 'Go to',
-          icon: vsReply,
-          iconColor: filterIconColor,
-          shortcut: SHORTCUTS.TABLE.GOTO_ROW,
-          group: IrisGridContextMenuHandler.GROUP_GOTO,
-          order: 10,
-          action: () => this.irisGrid.handleGotoRowOpened()
-        };
-
-        if (value != null) {
-          // Chars get treated like numbers in terms of which filters are available
-          if (TableUtils.isNumberType(column.type) || TableUtils.isCharType(column.type)) {
-            assertNotNull(modelColumn); // We want to show the full unformatted value if it's a number, so user knows which value they are matching
-            // If it's a Char we just show the char
-
-            var numberValueText = TableUtils.isCharType(column.type) ? String.fromCharCode(value) : "".concat(value);
-            filterMenu.actions = this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn));
-            andFilterMenu.actions = this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn), true);
-          } else if (TableUtils.isBooleanType(column.type)) {
-            filterMenu.actions = this.booleanFilterActions(column, valueText);
-            andFilterMenu.actions = this.booleanFilterActions(column, valueText, quickFilters.get(modelColumn), true);
-          } else if (TableUtils.isDateType(column.type)) {
-            var dateValueText = dateFilterFormatter.format(value);
-            var previewValue = previewFilterFormatter.format(value);
-            filterMenu.actions = this.dateFilterActions(column, dateValueText, previewValue, value);
-            andFilterMenu.actions = this.dateFilterActions(column, dateValueText, previewValue, value, quickFilters.get(modelColumn), true);
-          } else {
-            filterMenu.actions = this.stringFilterActions(column, valueText, value);
-            andFilterMenu.actions = this.stringFilterActions(column, valueText, value, quickFilters.get(modelColumn), true);
-          }
-        } else {
-          filterMenu.actions = this.nullFilterActions(column);
-          andFilterMenu.actions = this.nullFilterActions(column, quickFilters.get(modelColumn), true);
-        }
+    });
+    if (column == null || rowIndex == null) return actions; // grid data area context menu options
 
-        if (filterMenu.actions != null && filterMenu.actions.length > 0) {
-          actions.push(filterMenu);
-        }
+    if (model.isFilterable(modelColumn)) {
+      // cell data area contextmenu options
+      var filterMenu = {
+        title: 'Filter By Value',
+        icon: vsRemove,
+        iconColor: filterIconColor,
+        group: IrisGridContextMenuHandler.GROUP_FILTER,
+        order: 10,
+        actions: []
+      };
 
-        if (andFilterMenu.actions != null && andFilterMenu.actions.length > 0) {
-          actions.push(andFilterMenu);
+      if (value == null) {
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.nullFilterActions(column, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
         }
 
-        actions.push(gotoRow);
-      }
+        filterMenu.actions.push(...this.nullFilterActions(column));
+      } else if (TableUtils.isBooleanType(column.type)) {
+        // boolean should have OR condition, and handles it's own null menu options
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'Or',
+            actions: this.booleanFilterActions(column, valueText, quickFilters.get(modelColumn), '||'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
 
-      if (canCopy) {
-        actions.push({
-          title: 'Copy Cell',
-          group: IrisGridContextMenuHandler.GROUP_COPY,
-          order: 10,
-          action: () => {
-            irisGrid.copyCell(columnIndex, rowIndex);
-          }
-        });
-        actions.push({
-          title: 'Copy Cell Unformatted',
-          group: IrisGridContextMenuHandler.GROUP_COPY,
-          order: 20,
-          action: () => {
-            irisGrid.copyCell(columnIndex, rowIndex, true);
-          }
-        });
-      }
-    } // data area, including blank space context menu options
+        filterMenu.actions.push(...this.booleanFilterActions(column, valueText));
+      } else if (TableUtils.isNumberType(column.type) || TableUtils.isCharType(column.type)) {
+        // Chars get treated like numbers in terms of which filters are available
+        assertNotNull(modelColumn); // We want to show the full unformatted value if it's a number, so user knows which value they are matching
+        // If it's a Char we just show the char
+
+        var numberValueText = TableUtils.isCharType(column.type) ? String.fromCharCode(value) : "".concat(value);
+
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
 
+        filterMenu.actions.push(...this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn)));
+      } else if (TableUtils.isDateType(column.type)) {
+        var dateValueText = dateFilterFormatter.format(value);
+        var previewValue = previewFilterFormatter.format(value);
+
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.dateFilterActions(column, dateValueText, previewValue, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
 
-    var {
-      selectedRanges
-    } = grid.state;
+        filterMenu.actions.push(...this.dateFilterActions(column, dateValueText, previewValue, value, quickFilters.get(modelColumn)));
+      } else {
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.stringFilterActions(column, valueText, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
 
-    if (selectedRanges.length > 0) {
-      if (canCopy) {
-        actions.push({
-          title: 'Copy Selection',
-          shortcut: GLOBAL_SHORTCUTS.COPY,
-          group: IrisGridContextMenuHandler.GROUP_COPY,
-          order: 30,
-          action: () => {
-            irisGrid.copyRanges(selectedRanges);
-          }
-        });
-        actions.push({
-          title: 'Copy Selection w/ Headers',
-          group: IrisGridContextMenuHandler.GROUP_COPY,
-          order: 40,
-          action: () => {
-            irisGrid.copyRanges(selectedRanges, true);
-          }
-        });
+        filterMenu.actions.push(...this.stringFilterActions(column, valueText, value));
       }
 
-      if (isEditableGridModel(model) && model.isEditable) {
-        actions.push({
-          title: 'Delete Selected Rows',
-          group: IrisGridContextMenuHandler.GROUP_EDIT,
-          order: 50,
-          action: () => {
-            this.irisGrid.deleteRanges(selectedRanges);
-          }
-        });
+      if (filterMenu.actions != null && filterMenu.actions.length > 0) {
+        actions.push(filterMenu);
       }
     }
 
+    var gotoRow = {
+      title: 'Go to',
+      iconColor: filterIconColor,
+      shortcut: SHORTCUTS.TABLE.GOTO_ROW,
+      group: IrisGridContextMenuHandler.GROUP_GOTO,
+      order: 10,
+      action: () => this.irisGrid.toggleGotoRow("".concat(rowIndex + 1))
+    };
+    actions.push(gotoRow);
+
+    if (canCopy) {
+      actions.push({
+        title: 'Copy Cell',
+        group: IrisGridContextMenuHandler.GROUP_COPY,
+        order: 10,
+        action: () => {
+          irisGrid.copyCell(columnIndex, rowIndex);
+        }
+      });
+      actions.push({
+        title: 'Copy Cell Unformatted',
+        group: IrisGridContextMenuHandler.GROUP_COPY,
+        order: 20,
+        action: () => {
+          irisGrid.copyCell(columnIndex, rowIndex, true);
+        }
+      });
+    }
+
     return actions;
   }
 
@@ -461,7 +457,8 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     var modelColumn = irisGrid.getModelColumn(columnIndex);
     var modelRow = irisGrid.getModelRow(rowIndex);
     var {
-      model
+      model,
+      canCopy
     } = irisGrid.props;
     var {
       columns
@@ -470,7 +467,8 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
       metrics,
       isFilterBarShown,
       quickFilters,
-      advancedFilters
+      advancedFilters,
+      selectedRanges
     } = irisGrid.state;
     assertNotNull(metrics);
     var {
@@ -499,30 +497,63 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
           modelColumn
         }));
       }
+    }
 
-      if (modelColumn != null && column != null && model.isFilterable(modelColumn)) {
+    if (modelColumn != null && model.isFilterable(modelColumn)) {
+      // Clear column filter should still be available after last row
+      // And should be available in both header and body context menus
+      actions.push({
+        title: 'Clear Column Filter',
+        group: IrisGridContextMenuHandler.GROUP_FILTER,
+        order: 30,
+        action: () => {
+          this.irisGrid.removeColumnFilter(modelColumn);
+        },
+        disabled: !(quickFilters.has(modelColumn) || advancedFilters.has(modelColumn))
+      });
+    }
+
+    if (isFilterBarShown ? y <= gridY : y <= columnHeaderHeight) {
+      // grid header context menu options
+      if (modelColumn != null) {
+        actions.push(...this.getHeaderActions(modelColumn, gridPoint));
+      }
+    } else {
+      // grid body context menu options
+      if (modelColumn != null && modelRow != null) {
+        actions.push(...this.getCellActions(modelColumn, grid, gridPoint));
+      } // blank space context menu options
+
+
+      if (canCopy && selectedRanges.length > 0) {
         actions.push({
-          title: 'Clear Column Filter',
-          group: IrisGridContextMenuHandler.GROUP_FILTER,
+          title: 'Copy Selection',
+          shortcut: GLOBAL_SHORTCUTS.COPY,
+          group: IrisGridContextMenuHandler.GROUP_COPY,
           order: 30,
           action: () => {
-            this.irisGrid.removeColumnFilter(modelColumn);
-          },
-          disabled: !(quickFilters.has(modelColumn) || advancedFilters.has(modelColumn))
+            irisGrid.copyRanges(selectedRanges);
+          }
+        });
+        actions.push({
+          title: 'Copy Selection w/ Headers',
+          group: IrisGridContextMenuHandler.GROUP_COPY,
+          order: 40,
+          action: () => {
+            irisGrid.copyRanges(selectedRanges, true);
+          }
         });
       }
-    }
 
-    if (modelColumn != null) {
-      var _column = columns[modelColumn];
-
-      if (isFilterBarShown ? y <= gridY : y <= columnHeaderHeight) {
-        // grid header context menu options
-        if (_column != null) {
-          actions.push(...this.getHeaderActions(modelColumn, gridPoint));
-        }
-      } else {
-        actions.push(...this.getCellActions(modelColumn, grid, gridPoint));
+      if (isEditableGridModel(model) && model.isEditable && selectedRanges.length > 0) {
+        actions.push({
+          title: 'Delete Selected Rows',
+          group: IrisGridContextMenuHandler.GROUP_EDIT,
+          order: 50,
+          action: () => {
+            this.irisGrid.deleteRanges(selectedRanges);
+          }
+        });
       }
     }
 
@@ -636,8 +667,7 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     return actions;
   }
 
-  stringFilterActions(column, valueText, value, quickFilter) {
-    var additive = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  stringFilterActions(column, valueText, value, quickFilter, operator) {
     var filterValue = dh.FilterValue.ofString(value);
     var newQuickFilter = quickFilter;
 
@@ -661,62 +691,68 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     actions.push({
       menuElement: /*#__PURE__*/React.createElement("div", {
         className: "iris-grid-filter-menu-item-value"
-      }, "\"", valueText, "\""),
-      order: 1
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText, "\""),
+      order: 1,
+      group: ContextActions.groups.high
     });
     actions.push({
       title: 'text is exactly',
       description: "Show only rows where ".concat(column.name, " is ").concat(value, " (case sensitive)"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), operator));
       },
-      order: 10
+      order: 10,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'text is not exactly',
       description: "Show only rows where ".concat(column.name, " is not ").concat(valueText, " (case sensitive)"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), operator));
       },
-      order: 20
+      order: 20,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: "text contains",
       description: "Show only rows where ".concat(column.name, " contains ").concat(valueText),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().contains(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "~".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().contains(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "~".concat(valueText), operator));
       },
-      order: 30
+      order: 30,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'text does not contain',
       description: "Show only rows where ".concat(column.name, " does not contain ").concat(value),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().contains(filterValue).not(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!~".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().contains(filterValue).not(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!~".concat(valueText), operator));
       },
-      order: 40
+      order: 40,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'text starts with',
       description: "Show only rows where ".concat(column.name, " starts with ").concat(valueText),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().invoke('startsWith', filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "".concat(valueText, "*"), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().invoke('startsWith', filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "".concat(valueText, "*"), operator));
       },
-      order: 50
+      order: 50,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'text ends with',
       description: "Show only rows where ".concat(column.name, " ends with ").concat(valueText),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().invoke('endsWith', filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "*".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().invoke('endsWith', filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "*".concat(valueText), operator));
       },
-      order: 60
+      order: 60,
+      group: ContextActions.groups.low
     });
     return actions;
   }
 
-  numberFilterActions(column, valueText, value, quickFilter) {
-    var additive = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  numberFilterActions(column, valueText, value, quickFilter, operator) {
     var filterValue = IrisGridContextMenuHandler.getFilterValueForNumberOrChar(column.type, value);
     var filter = null;
     var filterText = null;
@@ -736,26 +772,29 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     actions.push({
       menuElement: /*#__PURE__*/React.createElement("div", {
         className: "iris-grid-filter-menu-item-value"
-      }, additive ? ' AND ' : '', "\"", valueText, "\""),
-      order: 1
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText, "\""),
+      order: 1,
+      group: ContextActions.groups.high
     });
     actions.push({
       title: 'is equal to',
       description: "Show only rows where ".concat(column.name, " is ").concat(valueText),
       action: () => {
         var valueFilter = IrisGridContextMenuHandler.getNumberValueEqualsFilter(column, value);
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), operator));
       },
-      order: 10
+      order: 10,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'is not equal to',
       description: "Show only rows where ".concat(column.name, " is not ").concat(valueText),
       action: () => {
         var valueFilter = IrisGridContextMenuHandler.getNumberValueEqualsFilter(column, value).not();
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), operator));
       },
-      order: 20
+      order: 20,
+      group: ContextActions.groups.low
     }); // IDS-6092 Less/greater than filters don't make sense for Infinite/NaN
     // TODO (DH-11799): These char filters should work in Bard, with the merge for DH-11040: https://gitlab.eng.illumon.com/illumon/iris/merge_requests/5801
     // They do not work in Powell though, so disable them.
@@ -765,91 +804,101 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
         title: 'greater than',
         description: "Show only rows where ".concat(column.name, " is greater than ").concat(valueText),
         action: () => {
-          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), additive));
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), operator));
         },
-        order: 30
+        order: 30,
+        group: ContextActions.groups.low
       });
       actions.push({
         title: 'greater than or equal to',
         description: "Show only rows where ".concat(column.name, " is greater than or equal to ").concat(valueText),
         action: () => {
-          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), additive));
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), operator));
         },
-        order: 40
+        order: 40,
+        group: ContextActions.groups.low
       });
       actions.push({
         title: 'less than',
         description: "Show only rows where ".concat(column.name, " is less than ").concat(valueText),
         action: () => {
-          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), additive));
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), operator));
         },
-        order: 50
+        order: 50,
+        group: ContextActions.groups.low
       });
       actions.push({
         title: 'less than or equal to',
         description: "Show only rows where ".concat(column.name, " is less than or equal to ").concat(valueText),
         action: () => {
-          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), additive));
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), operator));
         },
-        order: 60
+        order: 60,
+        group: ContextActions.groups.low
       });
     }
 
     return actions;
   }
 
-  booleanFilterActions(column, valueText, quickFilter) {
-    var additive = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  booleanFilterActions(column, valueText, quickFilter, operator) {
     var actions = [];
-
-    if (quickFilter == null) {
-      return actions;
-    }
-
-    var {
-      filter,
-      text: filterText
-    } = quickFilter;
     var {
       model
     } = this.irisGrid.props;
+    var {
+      filter,
+      text: filterText
+    } = quickFilter || {};
     var columnIndex = model.getColumnIndexByName(column.name);
     assertNotNull(columnIndex);
     actions.push({
       menuElement: /*#__PURE__*/React.createElement("div", {
         className: "iris-grid-filter-menu-item-value"
-      }, additive ? 'AND ' : '', "\"", valueText, "\""),
-      order: 1
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText || 'null', "\""),
+      order: 1,
+      group: ContextActions.groups.high
     });
     actions.push({
       title: 'true',
       description: "Show only rows where ".concat(column.name, " is true"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isTrue(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'true', additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isTrue(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'true', operator));
       },
-      order: 10
+      order: 10,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'false',
       description: "Show only rows where ".concat(column.name, " is false"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isFalse(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'false', additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isFalse(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'false', operator));
       },
-      order: 20
+      order: 20,
+      group: ContextActions.groups.low
     });
     actions.push({
-      title: 'null',
+      title: 'is null',
       description: "Show only rows where ".concat(column.name, " is null"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', operator));
       },
-      order: 30
+      order: 30,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is not null',
+      description: "Show only rows where ".concat(column.name, " is not null"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, '!null', operator));
+      },
+      order: 40,
+      group: ContextActions.groups.low
     });
     return actions;
   }
 
-  dateFilterActions(column, valueText, previewValue, value, quickFilter) {
-    var additive = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  dateFilterActions(column, valueText, previewValue, value, quickFilter, operator) {
     var filterValue = dh.FilterValue.ofNumber(value);
     var filter = null;
     var filterText = null;
@@ -868,62 +917,68 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     actions.push({
       menuElement: /*#__PURE__*/React.createElement("div", {
         className: "iris-grid-filter-menu-item-value"
-      }, additive ? ' AND ' : '', "\"", previewValue, "\""),
-      order: 1
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", previewValue, "\""),
+      order: 1,
+      group: ContextActions.groups.high
     });
     actions.push({
       title: 'date is',
       description: "Show only rows where ".concat(column.name, " is ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), operator));
       },
-      order: 10
+      order: 10,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'date is not',
       description: "Show only rows where ".concat(column.name, " is not ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), operator));
       },
-      order: 20
+      order: 20,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'date is before',
       description: "Show only rows where ".concat(column.name, " is before ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), operator));
       },
-      order: 30
+      order: 30,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'date is before or equal',
       description: "Show only rows where ".concat(column.name, " is before or equal to ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), operator));
       },
-      order: 40
+      order: 40,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'date is after',
       description: "Show only rows where ".concat(column.name, " is greater than ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), operator));
       },
-      order: 50
+      order: 50,
+      group: ContextActions.groups.low
     });
     actions.push({
       title: 'date is after or equal',
       description: "Show only rows where ".concat(column.name, " is after or equal to ").concat(previewValue),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), operator));
       },
-      order: 60
+      order: 60,
+      group: ContextActions.groups.low
     });
     return actions;
   }
 
-  nullFilterActions(column, quickFilter) {
-    var additive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  nullFilterActions(column, quickFilter, operator) {
     var filter = null;
     var filterText = null;
 
@@ -941,24 +996,27 @@ class IrisGridContextMenuHandler extends GridMouseHandler {
     actions.push({
       menuElement: /*#__PURE__*/React.createElement("div", {
         className: "iris-grid-filter-menu-item-value"
-      }, additive ? ' AND ' : '', "\"null\""),
-      order: 1
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"null\""),
+      order: 1,
+      group: ContextActions.groups.high
     });
     actions.push({
-      title: 'equals null',
+      title: 'is null',
       description: "Show only rows where ".concat(column.name, " is null"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', operator));
       },
-      order: 10
+      order: 10,
+      group: ContextActions.groups.low
     });
     actions.push({
-      title: 'not equals null',
+      title: 'is not null',
       description: "Show only rows where ".concat(column.name, " is not null"),
       action: () => {
-        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not(), additive), IrisGridContextMenuHandler.getQuickFilterText(filterText, '!null', additive));
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, '!null', operator));
       },
-      order: 20
+      order: 20,
+      group: ContextActions.groups.low
     });
     return actions;
   }