columns.forEach( column => {
     var columnIsGrouped = rowGroupColumns.indexOf(column) >= 0;
     if (columnIsGrouped) {
         this.columnController.removeRowGroupColumn(column);
         this.columnController.setColumnVisible(column, true);
     }
 });

 protected addColumns(columns: Column[]) {
     if (this.gridOptionsWrapper.isFunctionsPassive()) {
         this.eventService.dispatchEvent(Events.EVENT_COLUMN_VALUE_ADD_REQUEST, {columns: columns} );
     } else {
         this.columnController.addValueColumns(columns);
     }
 }

 protected addColumns(columns: Column[]) {
     if (this.gridOptionsWrapper.isRowGroupPassive()) {
         this.eventService.dispatchEvent(Events.EVENT_COLUMN_PIVOT_ADD_REQUEST, {columns: columns} );
     } else {
         this.columnController.addPivotColumns(columns);
     }
 }

        Utils.iterateObject(uniqueValues, (key: string, value: any)=> {

            var newPivotKeys = pivotKeys.slice(0);
            newPivotKeys.push(key);

            var createGroup = index !== levelsDeep;
            if (createGroup) {
                var groupDef: ColGroupDef = {
                    children: [],
                    headerName: key
                };
                parentChildren.push(groupDef);
                this.recursivelyAddGroup(groupDef.children, pivotColumnDefs, index+1, value, newPivotKeys, columnIdSequence, levelsDeep);
            } else {

                var measureColumns = this.columnController.getAggregationColumns();
                var valueGroup: ColGroupDef = {
                    children: [],
                    headerName: key
                };
                parentChildren.push(valueGroup);
                measureColumns.forEach( measureColumn => {
                    var colDef = this.createColDef(measureColumn, measureColumn.getColDef().headerName, newPivotKeys, columnIdSequence);
                    valueGroup.children.push(colDef);
                    pivotColumnDefs.push(colDef);
                });
                valueGroup.children.sort(this.headerNameComparator.bind(this));

            }
            parentChildren.sort(this.headerNameComparator.bind(this));
        });

 protected removeColumns(columns: Column[]): void {
     if (this.gridOptionsWrapper.isFunctionsPassive()) {
         this.eventService.dispatchEvent(Events.EVENT_COLUMN_VALUE_REMOVE_REQUEST, {columns: columns} );
     } else {
         var columnsCurrentlyValueColumns = Utils.filter(columns, (column: Column) => column.isValueActive() );
         this.columnController.removeValueColumns(columnsCurrentlyValueColumns);
     }
 }

 protected removeColumns(columns: Column[]): void {
     if (this.gridOptionsWrapper.isFunctionsPassive()) {
         this.eventService.dispatchEvent(Events.EVENT_COLUMN_PIVOT_REMOVE_REQUEST, {columns: columns} );
     } else {
         var columnsPivoted = Utils.filter(columns, (column: Column) => column.isPivotActive() );
         this.columnController.removePivotColumns(columnsPivoted);
     }
 }

    @PostConstruct
    private init(): void {
        this.setTemplate(this.createTemplate());
        this.instantiate(this.context);

        this.cbPivotMode.setSelected(this.columnController.isPivotMode());

        this.addDestroyableEventListener(this.cbPivotMode, AgCheckbox.EVENT_CHANGED, this.onBtPivotMode.bind(this) );
        this.addDestroyableEventListener(this.eventService, Events.EVENT_COLUMN_EVERYTHING_CHANGED, this.onPivotModeChanged.bind(this));
        this.addDestroyableEventListener(this.eventService, Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, this.onPivotModeChanged.bind(this));
    }

 protected removeColumns(columns: Column[]) {
     // this panel only allows dragging columns (not column groups) so we are guaranteed
     // the dragItem is a column
     var rowGroupColumns = this.columnController.getRowGroupColumns();
     columns.forEach( column => {
         var columnIsGrouped = rowGroupColumns.indexOf(column) >= 0;
         if (columnIsGrouped) {
             this.columnController.removeRowGroupColumn(column);
             this.columnController.setColumnVisible(column, true);
         }
     });
 }

    private checkVisibility(): void {
        var pivotMode = this.columnController.isPivotMode();

        if (this.isHorizontal()) {
            // what we do for horizontal (ie the pivot panel at the top) depends
            // on the user property as well as pivotMode.
            switch (this.gridOptionsWrapper.getPivotPanelShow()) {
                case 'always':
                    this.setVisible(pivotMode);
                    break;
                case 'onlyWhenPivoting':
                    var pivotActive = this.columnController.isPivotActive();
                    this.setVisible(pivotMode && pivotActive);
                    break;
                default:
                    // never show it
                    this.setVisible(false);
                    break;
            }
        } else {
            // in toolPanel, the pivot panel is always shown when pivot mode is on
            this.setVisible(pivotMode);
        }
    }

    public createPivotColumnDefs(uniqueValues: any): PivotColDefServiceResult {

        var pivotColumnGroupDefs: (ColDef|ColGroupDef)[] = [];
        var pivotColumnDefs: ColDef[] = [];

        var pivotColumns = this.columnController.getPivotColumns();
        var levelsDeep = pivotColumns.length;
        var columnIdSequence = new NumberSequence();

        this.recursivelyAddGroup(pivotColumnGroupDefs, pivotColumnDefs, 1, uniqueValues, [], columnIdSequence, levelsDeep);

        return {
            pivotColumnGroupDefs: pivotColumnGroupDefs,
            pivotColumnDefs: pivotColumnDefs
        };
    }